diff --git a/pulumi/pulumi_state/.gitignore b/pulumi/pulumi_state/.gitignore new file mode 100644 index 00000000..d1ebe2b9 --- /dev/null +++ b/pulumi/pulumi_state/.gitignore @@ -0,0 +1,10 @@ +*.pyc +__pycache__/ +.venv/ +venv/ +*.egg-info/ +dist/ +build/ +.pulumi/ +Pulumi.*.yaml +!Pulumi.yaml diff --git a/pulumi/pulumi_state/Pulumi.yaml b/pulumi/pulumi_state/Pulumi.yaml new file mode 100644 index 00000000..eb092472 --- /dev/null +++ b/pulumi/pulumi_state/Pulumi.yaml @@ -0,0 +1,13 @@ +name: pulumi-state +runtime: + name: python + options: + virtualenv: .venv +description: Bootstrap project to create S3 bucket for Pulumi state storage +config: + aws:region: + value: eu-north-1 + pulumi:tags: + value: + pulumi:template: bootstrap + project: pulumi-state diff --git a/pulumi/pulumi_state/README.md b/pulumi/pulumi_state/README.md new file mode 100644 index 00000000..0b8ee40e --- /dev/null +++ b/pulumi/pulumi_state/README.md @@ -0,0 +1,350 @@ +# Pulumi State Storage Bootstrap + +Bootstrap project to create and manage the S3 bucket used for Pulumi state storage across all nf-core infrastructure projects. + +## Purpose + +This project creates an S3 bucket (`nf-core-pulumi-state`) that serves as the backend for all other Pulumi projects. It uses a **local backend** to avoid circular dependency issues. + +## S3 Bucket Configuration + +- **Bucket Name**: `nf-core-pulumi-state` +- **Region**: `eu-north-1` (Stockholm) +- **Versioning**: Enabled (keeps history of state changes) +- **Encryption**: AES-256 (SSE-S3) +- **Lifecycle**: Expires old versions after 90 days +- **Public Access**: Blocked +- **Purpose**: Pulumi state storage for all nf-core ops projects + +## Initial Setup + +```bash +# 1. Install dependencies +uv sync + +# 2. Login to local backend (this project only) +pulumi login --local + +# 3. Create production stack +pulumi stack init prod + +# 4. Preview changes +uv run pulumi preview + +# 5. Deploy the bucket +uv run pulumi up + +# 6. View outputs +uv run pulumi stack output +``` + +## Manual S3 Bucket Setup (Alternative) + +If you need to create the S3 bucket manually before using Pulumi (e.g., bootstrapping from scratch), use these AWS CLI commands: + +### 1. Set Up AWS Credentials + +Use 1Password to retrieve AWS credentials for the nf-core account: + +```bash +# Set 1Password account context +export OP_ACCOUNT=nf-core + +# Retrieve and export AWS credentials +export AWS_ACCESS_KEY_ID="$(op read 'op://Employee/Edmund Megatests AWS Creds/access key id')" +export AWS_SECRET_ACCESS_KEY="$(op read 'op://Employee/Edmund Megatests AWS Creds/secret access key')" +export AWS_DEFAULT_REGION="eu-north-1" +``` + +### 2. Create S3 Bucket + +```bash +aws s3 mb s3://nf-core-pulumi-state --region eu-north-1 +``` + +### 3. Configure Bucket Settings + +**Enable Versioning:** +```bash +aws s3api put-bucket-versioning \ + --bucket nf-core-pulumi-state \ + --versioning-configuration Status=Enabled +``` + +**Enable Encryption:** +```bash +aws s3api put-bucket-encryption \ + --bucket nf-core-pulumi-state \ + --server-side-encryption-configuration '{ + "Rules": [{ + "ApplyServerSideEncryptionByDefault": { + "SSEAlgorithm": "AES256" + }, + "BucketKeyEnabled": true + }] + }' +``` + +**Block Public Access:** +```bash +aws s3api put-public-access-block \ + --bucket nf-core-pulumi-state \ + --public-access-block-configuration \ + "BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true" +``` + +**Configure Lifecycle Policy:** +```bash +aws s3api put-bucket-lifecycle-configuration \ + --bucket nf-core-pulumi-state \ + --lifecycle-configuration '{ + "Rules": [ + { + "ID": "expire-old-versions", + "Status": "Enabled", + "Filter": {}, + "NoncurrentVersionExpiration": { + "NoncurrentDays": 90 + } + }, + { + "ID": "abort-incomplete-multipart-uploads", + "Status": "Enabled", + "Filter": {}, + "AbortIncompleteMultipartUpload": { + "DaysAfterInitiation": 7 + } + } + ] + }' +``` + +**Add Tags:** +```bash +aws s3api put-bucket-tagging \ + --bucket nf-core-pulumi-state \ + --tagging 'TagSet=[ + {Key=Name,Value=nf-core-pulumi-state}, + {Key=project,Value=pulumi-state}, + {Key=managed-by,Value=pulumi}, + {Key=environment,Value=shared}, + {Key=purpose,Value=pulumi-state-storage} + ]' +``` + +## Environment Variables + +### Required for Manual Setup + +When setting up the S3 bucket manually via AWS CLI: + +```bash +# 1Password account (for credential retrieval) +export OP_ACCOUNT=nf-core + +# AWS credentials (retrieved from 1Password) +export AWS_ACCESS_KEY_ID="$(op read 'op://Employee/Edmund Megatests AWS Creds/access key id')" +export AWS_SECRET_ACCESS_KEY="$(op read 'op://Employee/Edmund Megatests AWS Creds/secret access key')" + +# AWS region for bucket +export AWS_DEFAULT_REGION="eu-north-1" +``` + +### Required for Other Pulumi Projects + +Once the bucket is created, other Pulumi projects need: + +```bash +# Option 1: Set backend URL as environment variable +export PULUMI_BACKEND_URL='s3://nf-core-pulumi-state?region=eu-north-1&awssdk=v2' + +# Option 2: Use pulumi login command (recommended) +pulumi login 's3://nf-core-pulumi-state?region=eu-north-1&awssdk=v2' +``` + +**Note:** AWS credentials are still required to access the S3 bucket. Use the same 1Password credentials or configure via ESC/OIDC. + +## Importing Existing Bucket into Pulumi + +If you created the bucket manually and need to import it into Pulumi state: + +```bash +# 1. Ensure you're logged into local backend +pulumi login --local + +# 2. Select the prod stack +pulumi stack select prod + +# 3. Import all bucket resources +pulumi import aws:s3/bucket:Bucket pulumi-state-bucket nf-core-pulumi-state +pulumi import aws:s3/bucketVersioningV2:BucketVersioningV2 state-bucket-versioning nf-core-pulumi-state +pulumi import aws:s3/bucketServerSideEncryptionConfigurationV2:BucketServerSideEncryptionConfigurationV2 state-bucket-encryption nf-core-pulumi-state +pulumi import aws:s3/bucketPublicAccessBlock:BucketPublicAccessBlock state-bucket-public-access-block nf-core-pulumi-state +pulumi import aws:s3/bucketLifecycleConfigurationV2:BucketLifecycleConfigurationV2 state-bucket-lifecycle nf-core-pulumi-state +``` + +**Resources Imported:** +- Main S3 bucket +- Bucket versioning configuration +- Server-side encryption configuration +- Public access block settings +- Lifecycle configuration + +After importing, run `pulumi preview` to verify that no changes are detected. + +## Usage in Other Projects + +Once the bucket is created, other Pulumi projects can use it as their backend: + +```bash +# Login to S3 backend +pulumi login s3://nf-core-pulumi-state + +# Or with explicit region +pulumi login 's3://nf-core-pulumi-state?region=eu-north-1&awssdk=v2' +``` + +## State Location + +This bootstrap project stores its state locally at: +``` +~/.pulumi/stacks/pulumi-state/ +``` + +All other projects store their state in: +``` +s3://nf-core-pulumi-state/.pulumi/stacks//.json +``` + +## Architecture Decision + +**Why local backend for this project?** + +To avoid circular dependency: +- We need an S3 bucket to store Pulumi state +- We need Pulumi to create the S3 bucket +- Solution: Use local backend for this bootstrap project + +**Is this a problem?** + +No, because: +- This project is simple and rarely changes +- Local state is backed up in git (stack configs) +- Only bucket metadata is in state (bucket already exists after first deploy) + +## Bucket Features + +### Versioning +Keeps history of all state file versions. Useful for: +- Recovery from accidental corruption +- Auditing changes +- Rolling back if needed + +### Encryption +All state files are encrypted at rest with AES-256. + +### Lifecycle Policy +- Old versions expire after 90 days +- Incomplete multipart uploads cleaned up after 7 days + +### Public Access +All public access is blocked to protect state files. + +## Operations + +### View Stack Outputs +```bash +uv run pulumi stack output +``` + +### Update Bucket Configuration +```bash +# Edit __main__.py +uv run pulumi preview +uv run pulumi up +``` + +### Destroy (⚠️ Use with caution) +```bash +# This will delete the bucket and all state files! +uv run pulumi destroy +``` + +## Migration from Pulumi Cloud + +If migrating existing projects from Pulumi Cloud to S3: + +```bash +# 1. Export state from Pulumi Cloud +pulumi stack export --file state.json + +# 2. Login to S3 backend +pulumi login s3://nf-core-pulumi-state + +# 3. Select or create stack +pulumi stack select + +# 4. Import state +pulumi stack import --file state.json +``` + +## Team Access + +Team members need: +- AWS credentials with S3 access +- Permissions to read/write to `nf-core-pulumi-state` bucket + +IAM policy for team members: +```json +{ + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": [ + "s3:ListBucket", + "s3:GetBucketLocation", + "s3:GetBucketVersioning" + ], + "Resource": "arn:aws:s3:::nf-core-pulumi-state" + }, + { + "Effect": "Allow", + "Action": [ + "s3:GetObject", + "s3:GetObjectVersion", + "s3:PutObject", + "s3:DeleteObject" + ], + "Resource": "arn:aws:s3:::nf-core-pulumi-state/*" + } + ] +} +``` + +## Security Notes + +- State files may contain sensitive information (resource IDs, configurations) +- Use Pulumi ESC or external secrets managers for sensitive values +- Never commit state files to git +- Ensure AWS credentials are properly secured + +## Troubleshooting + +### Bucket already exists +If the bucket exists but isn't in Pulumi state: +```bash +pulumi import aws:s3/bucket:Bucket pulumi-state-bucket nf-core-pulumi-state +``` + +### State file conflicts +S3 doesn't have built-in locking. For concurrent access: +- Use DynamoDB for state locking (requires additional setup) +- Coordinate deployments manually +- Consider using Pulumi Cloud for teams + +## Related Projects + +- `pulumi/seqera_platform/awsmegatests/` - Uses this S3 backend +- `pulumi/seqera_platform/resource_optimization/` - Uses this S3 backend +- `pulumi/AWSMegatests/` - Legacy project (migrating to S3 backend) diff --git a/pulumi/pulumi_state/__main__.py b/pulumi/pulumi_state/__main__.py new file mode 100644 index 00000000..cdad6a69 --- /dev/null +++ b/pulumi/pulumi_state/__main__.py @@ -0,0 +1,100 @@ +"""Bootstrap Pulumi project to create S3 bucket for Pulumi state storage. + +This project uses a local backend to avoid circular dependency. +All other Pulumi projects will use the S3 bucket created here. +""" + +import pulumi +import pulumi_aws as aws + +# Configuration +BUCKET_NAME = "nf-core-pulumi-state" +REGION = "eu-north-1" + +# Create S3 bucket for Pulumi state storage +state_bucket = aws.s3.Bucket( + "pulumi-state-bucket", + bucket=BUCKET_NAME, + # Force destroy for cleanup (remove in production if needed) + force_destroy=False, + tags={ + "Name": BUCKET_NAME, + "project": "pulumi-state", + "managed-by": "pulumi", + "environment": "shared", + "purpose": "pulumi-state-storage", + }, +) + +# Enable versioning for state history +versioning = aws.s3.BucketVersioningV2( + "state-bucket-versioning", + bucket=state_bucket.id, + versioning_configuration=aws.s3.BucketVersioningV2VersioningConfigurationArgs( + status="Enabled", + ), +) + +# Enable server-side encryption +encryption = aws.s3.BucketServerSideEncryptionConfigurationV2( + "state-bucket-encryption", + bucket=state_bucket.id, + rules=[ + aws.s3.BucketServerSideEncryptionConfigurationV2RuleArgs( + apply_server_side_encryption_by_default=aws.s3.BucketServerSideEncryptionConfigurationV2RuleApplyServerSideEncryptionByDefaultArgs( + sse_algorithm="AES256", + ), + bucket_key_enabled=True, + ) + ], +) + +# Block all public access +public_access_block = aws.s3.BucketPublicAccessBlock( + "state-bucket-public-access-block", + bucket=state_bucket.id, + block_public_acls=True, + block_public_policy=True, + ignore_public_acls=True, + restrict_public_buckets=True, +) + +# Lifecycle policy to clean up old versions +lifecycle_configuration = aws.s3.BucketLifecycleConfigurationV2( + "state-bucket-lifecycle", + bucket=state_bucket.id, + rules=[ + aws.s3.BucketLifecycleConfigurationV2RuleArgs( + id="expire-old-versions", + status="Enabled", + noncurrent_version_expiration=aws.s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs( + noncurrent_days=90, + ), + ), + aws.s3.BucketLifecycleConfigurationV2RuleArgs( + id="abort-incomplete-multipart-uploads", + status="Enabled", + abort_incomplete_multipart_upload=aws.s3.BucketLifecycleConfigurationV2RuleAbortIncompleteMultipartUploadArgs( + days_after_initiation=7, + ), + ), + ], +) + +# Exports +pulumi.export("bucket_name", state_bucket.bucket) +pulumi.export("bucket_arn", state_bucket.arn) +pulumi.export("bucket_region", REGION) +pulumi.export( + "usage_instructions", + pulumi.Output.concat( + "To use this bucket as your Pulumi backend:\n", + " pulumi login s3://", + state_bucket.bucket, + "\n\n", + "Or with explicit region:\n", + " pulumi login 's3://", + state_bucket.bucket, + f"?region={REGION}&awssdk=v2'", + ), +) diff --git a/pulumi/pulumi_state/pyproject.toml b/pulumi/pulumi_state/pyproject.toml new file mode 100644 index 00000000..ec641abe --- /dev/null +++ b/pulumi/pulumi_state/pyproject.toml @@ -0,0 +1,10 @@ +[project] +name = "pulumi-state" +version = "0.1.0" +description = "Bootstrap project to create S3 bucket for Pulumi state storage" +readme = "README.md" +requires-python = ">=3.12" +dependencies = [ + "pulumi>=3.173.0,<4.0.0", + "pulumi-aws>=6.81.0,<7.0.0", +] diff --git a/pulumi/pulumi_state/requirements.txt b/pulumi/pulumi_state/requirements.txt new file mode 100644 index 00000000..b1b535c3 --- /dev/null +++ b/pulumi/pulumi_state/requirements.txt @@ -0,0 +1,2 @@ +pulumi>=3.173.0,<4.0.0 +pulumi-aws>=6.81.0,<7.0.0 diff --git a/pulumi/seqera_platform/README.md b/pulumi/seqera_platform/README.md new file mode 100644 index 00000000..78255ea7 --- /dev/null +++ b/pulumi/seqera_platform/README.md @@ -0,0 +1,161 @@ +# Seqera Platform Multi-Workspace Infrastructure + +This directory contains Pulumi infrastructure-as-code for managing multiple Seqera Platform workspaces for nf-core. + +## Structure + +``` +seqera_platform/ +├── shared/ # Shared Python modules +│ ├── providers/ # Provider factory functions (AWS, GitHub, Seqera) +│ ├── infrastructure/ # Reusable infrastructure modules (S3, IAM, compute envs) +│ ├── integrations/ # GitHub and Seqera integrations +│ ├── config/ # Configuration management +│ └── utils/ # Utility functions +├── awsmegatests/ # AWS Megatests workspace +│ ├── __main__.py # Main Pulumi program +│ ├── workspace_config.py # Workspace-specific configuration +│ ├── Pulumi.yaml # Pulumi project definition +│ └── pyproject.toml # Python dependencies +└── resource_optimization/ # Resource Optimization workspace + ├── __main__.py # Main Pulumi program + ├── workspace_config.py # Workspace-specific configuration + ├── Pulumi.yaml # Pulumi project definition + └── pyproject.toml # Python dependencies +``` + +## Workspaces + +### AWS Megatests (`awsmegatests/`) + +Full testing infrastructure for nf-core pipelines with: +- **Compute Environments**: CPU, GPU, and ARM +- **S3 Bucket**: `nf-core-awsmegatests` +- **GitHub Integration**: Full CI/CD integration +- **Workspace Participants**: nf-core team members + +**Usage:** +```bash +cd awsmegatests +uv sync +uv run pulumi preview +uv run pulumi up +``` + +### Resource Optimization (`resource_optimization/`) + +Dedicated workspace for resource optimization testing with: +- **Compute Environments**: CPU only (no ARM or GPU) +- **S3 Bucket**: `nf-core-resource-optimization` +- **Purpose**: Testing and analyzing pipeline resource requirements + +**Usage:** +```bash +cd resource_optimization +uv sync +uv run pulumi preview +uv run pulumi up +``` + +## Shared Modules + +The `shared/` directory contains reusable code shared across all workspaces: + +- **`providers/`**: Factory functions for creating Pulumi providers +- **`infrastructure/`**: Modules for S3, IAM, compute environments, and credentials +- **`integrations/`**: GitHub and Seqera Platform integrations +- **`config/`**: Configuration management and ESC integration +- **`utils/`**: Logging, constants, and helper functions + +## Configuration + +Each workspace has a `workspace_config.py` file that defines: +- Workspace name and organization +- Enabled compute environments (CPU, GPU, ARM) +- AWS region and S3 bucket names +- GitHub integration settings +- Workspace participant settings + +Example: +```python +def get_workspace_config(): + return { + "workspace_name": "AWSmegatests", + "compute_environments": { + "cpu": {"enabled": True, ...}, + "gpu": {"enabled": True, ...}, + "arm": {"enabled": True, ...}, + }, + ... + } +``` + +## Adding a New Workspace + +1. Create a new directory under `seqera_platform/`: + ```bash + mkdir seqera_platform/new_workspace + ``` + +2. Copy template files from an existing workspace: + ```bash + cp awsmegatests/{Pulumi.yaml,pyproject.toml,requirements.txt,.gitignore} new_workspace/ + ``` + +3. Create `workspace_config.py` with your specific configuration + +4. Create `__main__.py` that imports from `shared/` and uses your workspace config + +5. Update the Pulumi project name in `Pulumi.yaml` + +6. Initialize and deploy: + ```bash + cd new_workspace + uv sync + pulumi stack init prod + pulumi up + ``` + +## Dependencies + +- Python >= 3.12 +- uv (Python package manager) +- Pulumi >= 3.173.0 +- Pulumi AWS Provider >= 6.81.0 +- Pulumi GitHub Provider >= 6.4.0 +- Pulumi Command Provider >= 1.0.1 + +## Environment Variables + +Required for deployment: +- `TOWER_ACCESS_TOKEN`: Seqera Platform API token +- `GITHUB_TOKEN`: GitHub personal access token +- `AWS_*`: AWS credentials (usually via ESC) + +## Migration from Legacy Structure + +The legacy `pulumi/AWSMegatests/` directory is still operational. Once this new structure is validated: + +1. Test the new `awsmegatests/` workspace in a separate Pulumi stack +2. Compare outputs and resources +3. Migrate production traffic +4. Deprecate the legacy directory + +## Notes + +- Each workspace is a separate Pulumi project with independent state +- Workspaces share code via the `shared/` module +- Each workspace can have different compute environment configurations +- S3 buckets and IAM resources are workspace-specific (no sharing) + +## Troubleshooting + +**Import errors from shared module:** +```python +# Each __main__.py adds the shared path to sys.path: +shared_path = Path(__file__).parent.parent / "shared" +sys.path.insert(0, str(shared_path)) +``` + +**Different configurations per workspace:** +Modify `workspace_config.py` in each workspace to enable/disable features. diff --git a/pulumi/seqera_platform/awsmegatests/.gitignore b/pulumi/seqera_platform/awsmegatests/.gitignore new file mode 100644 index 00000000..5e8e899e --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/.gitignore @@ -0,0 +1,10 @@ +*.pyc +__pycache__/ +venv/ +.venv/ +*.egg-info/ +dist/ +build/ +.pulumi/ +Pulumi.*.yaml +!Pulumi.yaml diff --git a/pulumi/seqera_platform/awsmegatests/Pulumi.yaml b/pulumi/seqera_platform/awsmegatests/Pulumi.yaml new file mode 100644 index 00000000..738a8fa4 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/Pulumi.yaml @@ -0,0 +1,11 @@ +name: seqera-awsmegatests +runtime: + name: python + options: + virtualenv: .venv +description: Seqera Platform workspace for nf-core AWS megatests +config: + pulumi:tags: + value: + pulumi:template: seqera-platform-workspace + workspace: awsmegatests diff --git a/pulumi/seqera_platform/awsmegatests/README.md b/pulumi/seqera_platform/awsmegatests/README.md new file mode 100644 index 00000000..da743ba5 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/README.md @@ -0,0 +1,155 @@ +# AWS Megatests Workspace + +Seqera Platform workspace for nf-core AWS megatests infrastructure. + +## Overview + +This workspace provides the complete testing infrastructure for nf-core pipelines on AWS, including: + +- **Multiple Compute Environments**: CPU, GPU, and ARM instances +- **S3 Storage**: Dedicated bucket for test data and results +- **GitHub CI/CD Integration**: Automatic variable and secret management +- **Team Access**: Automated workspace participant management +- **TowerForge Credentials**: IAM user and policies for compute environment access + +## Configuration + +The workspace configuration is defined in `workspace_config.py`: + +- **Workspace Name**: AWSmegatests +- **Organization**: nf-core +- **AWS Region**: eu-west-1 +- **S3 Bucket**: nf-core-awsmegatests + +### Compute Environments + +1. **CPU Environment** + - Instance types: c6id, m6id, r6id + - Max CPUs: 500 + - Fusion v2 with NVMe storage + +2. **GPU Environment** + - Instance types: g4dn, g5 + - Max CPUs: 500 + - GPU-enabled for accelerated workloads + +3. **ARM Environment** + - Instance types: c6gd, m6gd, r6gd + - Max CPUs: 500 + - ARM64 architecture testing + +## Deployment + +### Prerequisites + +1. Python 3.12+ +2. uv package manager +3. Pulumi CLI +4. AWS credentials +5. Seqera Platform access token +6. GitHub personal access token + +### Initial Setup + +```bash +# Install dependencies +uv sync + +# Login to Pulumi +pulumi login + +# Create a new stack (if needed) +pulumi stack init prod + +# Configure ESC environment (if using) +# Edit Pulumi..yaml to reference ESC environment +``` + +### Deploy Infrastructure + +```bash +# Preview changes +uv run pulumi preview + +# Deploy +uv run pulumi up + +# View outputs +uv run pulumi stack output +``` + +## Outputs + +The stack exports: + +- `workspace`: Workspace details (name, organization, ID) +- `megatests_bucket`: S3 bucket information +- `compute_env_ids`: IDs of all compute environments +- `github_resources`: GitHub variables and secrets +- `github_credential`: Seqera Platform credential for GitHub access +- `terraform_resources`: Compute environment IDs by type +- `workspace_participants`: Team member sync status + +## Structure + +``` +awsmegatests/ +├── __main__.py # Main Pulumi program +├── workspace_config.py # Workspace-specific configuration +├── Pulumi.yaml # Pulumi project definition +├── pyproject.toml # Python dependencies +├── requirements.txt # Alternative dependency specification +└── .gitignore # Git ignore patterns +``` + +## Shared Modules + +This workspace uses shared modules from `../shared/`: +- `providers/`: AWS, GitHub, Seqera providers +- `infrastructure/`: S3, IAM, compute environments +- `integrations/`: GitHub resources, credentials +- `config/`: Configuration management +- `utils/`: Helper functions + +## Maintenance + +### Updating Compute Environments + +Edit `workspace_config.py` to modify compute environment settings: + +```python +"compute_environments": { + "cpu": { + "enabled": True, # Set to False to disable + "max_cpus": 500, # Adjust as needed + ... + } +} +``` + +Then run `pulumi up` to apply changes. + +### Adding Team Members + +Workspace participants are managed automatically via GitHub teams: +- `nf-core` team → OWNER role +- `nf-core-maintainers` team → MAINTAIN role + +Team membership updates are synced on each deployment. + +## Troubleshooting + +**Issue**: Import errors from shared modules +**Solution**: The `__main__.py` automatically adds `../shared` to the Python path. Ensure the shared directory exists. + +**Issue**: GitHub resources not creating +**Solution**: Check that `GITHUB_TOKEN` has appropriate permissions for organization variables and secrets. + +**Issue**: Compute environments not deploying +**Solution**: Verify `TOWER_ACCESS_TOKEN` and workspace ID in ESC configuration. + +## Related Documentation + +- [Main Seqera Platform README](../README.md) +- [Shared Module Documentation](../shared/README.md) +- [Legacy AWSMegatests](../../AWSMegatests/CLAUDE.md) diff --git a/pulumi/seqera_platform/awsmegatests/__init__.py b/pulumi/seqera_platform/awsmegatests/__init__.py new file mode 100644 index 00000000..6247142a --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/__init__.py @@ -0,0 +1 @@ +"""Seqera Platform AWS Megatests workspace""" diff --git a/pulumi/seqera_platform/awsmegatests/__main__.py b/pulumi/seqera_platform/awsmegatests/__main__.py new file mode 100644 index 00000000..f583fdbf --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/__main__.py @@ -0,0 +1,174 @@ +"""Pulumi program for Seqera Platform - AWS Megatests workspace""" + +import sys +from pathlib import Path + +# Add shared module to Python path +shared_path = Path(__file__).parent.parent / "shared" +sys.path.insert(0, str(shared_path)) + +# Add sdks directory to Python path for pulumi_seqera +sdks_path = Path(__file__).parent / "sdks" / "seqera" +sys.path.insert(0, str(sdks_path)) + +import pulumi + +# Import shared modules +from providers import ( + create_aws_provider, + create_github_provider, + create_seqera_provider, +) +from config import get_configuration +from infrastructure import create_s3_infrastructure, create_towerforge_credentials +from infrastructure import ( + deploy_seqera_environments_terraform, + get_compute_environment_ids_terraform, +) +from integrations import create_github_resources, create_github_credential +from integrations.workspace_participants_command import ( + create_individual_member_commands, +) + +# Import workspace-specific configuration +from workspace_config import get_workspace_config + + +def main(): + """Main Pulumi program function for AWS Megatests workspace""" + + # Get workspace-specific configuration + workspace_config = get_workspace_config() + + # Get ESC configuration + config = get_configuration() + + # Create providers + aws_provider = create_aws_provider() + github_provider = create_github_provider(config["github_token"]) + seqera_provider = create_seqera_provider(config) + + # Create GitHub credential in Seqera Platform + github_credential, github_credential_id = create_github_credential( + seqera_provider=seqera_provider, + workspace_id=int(config["tower_workspace_id"]), + github_token=config.get("platform_github_org_token", ""), + ) + + # Set up S3 infrastructure + s3_resources = create_s3_infrastructure(aws_provider) + nf_core_awsmegatests_bucket = s3_resources["bucket"] + + # Create TowerForge IAM credentials and upload to Seqera Platform + ( + towerforge_access_key_id, + towerforge_access_key_secret, + seqera_credentials_id, + seqera_credential_resource, + iam_policy_hash, + ) = create_towerforge_credentials( + aws_provider, + nf_core_awsmegatests_bucket, + seqera_provider, + float(config["tower_workspace_id"]), + ) + + # Deploy Seqera Platform compute environments + terraform_resources = deploy_seqera_environments_terraform( + config, + seqera_credentials_id, + seqera_provider, + seqera_credential_resource, + iam_policy_hash, + workspace_config=workspace_config, + ) + + # Get compute environment IDs + compute_env_ids = get_compute_environment_ids_terraform(terraform_resources) + deployment_method = "terraform-provider" + + # Create GitHub resources + github_resources = create_github_resources( + github_provider, + compute_env_ids, + config["tower_workspace_id"], + tower_access_token=config["tower_access_token"], + ) + + # Add workspace participants + setup_cmd, member_commands = create_individual_member_commands( + workspace_id=int(config["tower_workspace_id"]), + token=config["tower_access_token"], + github_token=config["github_token"], + opts=pulumi.ResourceOptions(depends_on=[seqera_credential_resource]), + ) + + # Exports + pulumi.export( + "workspace", + { + "name": workspace_config["workspace_name"], + "organization": workspace_config["organization_name"], + "workspace_id": config["tower_workspace_id"], + }, + ) + + pulumi.export( + "megatests_bucket", + { + "name": nf_core_awsmegatests_bucket.bucket, + "arn": nf_core_awsmegatests_bucket.arn, + "region": workspace_config["aws_region"], + }, + ) + + pulumi.export( + "github_resources", + { + "variables": { + k: v.id for k, v in github_resources.get("variables", {}).items() + } + if github_resources.get("variables") + else {}, + "secrets": {k: v.id for k, v in github_resources.get("secrets", {}).items()} + if github_resources.get("secrets") + else {}, + "manual_secret_commands": github_resources.get("gh_cli_commands", []), + }, + ) + + pulumi.export("compute_env_ids", compute_env_ids) + pulumi.export("deployment_method", deployment_method) + + pulumi.export( + "github_credential", + { + "credential_id": github_credential_id, + "credential_name": "nf-core-github-finegrained", + }, + ) + + pulumi.export( + "terraform_resources", + { + "cpu_env_id": terraform_resources["cpu_env"].compute_env_id, + "gpu_env_id": terraform_resources["gpu_env"].compute_env_id, + "arm_env_id": terraform_resources["arm_env"].compute_env_id, + }, + ) + + pulumi.export( + "workspace_participants", + { + "setup_command_id": setup_cmd.id, + "individual_member_commands": { + username: {"command_id": cmd.id, "github_username": username} + for username, cmd in member_commands.items() + }, + "total_tracked_members": len(member_commands), + }, + ) + + +if __name__ == "__main__": + main() diff --git a/pulumi/seqera_platform/awsmegatests/pyproject.toml b/pulumi/seqera_platform/awsmegatests/pyproject.toml new file mode 100644 index 00000000..8ae397db --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/pyproject.toml @@ -0,0 +1,12 @@ +[project] +name = "seqera-awsmegatests" +version = "0.1.0" +description = "Pulumi project for Seqera Platform - AWS Megatests workspace" +readme = "README.md" +requires-python = ">=3.12" +dependencies = [ + "pulumi>=3.173.0,<4.0.0", + "pulumi-aws>=6.81.0,<7.0.0", + "pulumi-github>=6.4.0,<7.0.0", + "pulumi-command>=1.0.1,<2.0.0", +] diff --git a/pulumi/seqera_platform/awsmegatests/requirements.txt b/pulumi/seqera_platform/awsmegatests/requirements.txt new file mode 100644 index 00000000..2adc78fa --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/requirements.txt @@ -0,0 +1,4 @@ +pulumi>=3.173.0,<4.0.0 +pulumi-aws>=6.81.0,<7.0.0 +pulumi-github>=6.4.0,<7.0.0 +pulumi-command>=1.0.1,<2.0.0 diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera-0.25.2.dist-info/direct_url.json b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera-0.25.2.dist-info/direct_url.json new file mode 100644 index 00000000..c2b07c40 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera-0.25.2.dist-info/direct_url.json @@ -0,0 +1 @@ +{"url":"file:///Users/edmundmiller/src/nf-core/ops/pulumi/AWSMegatests/sdks/seqera","dir_info":{}} \ No newline at end of file diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera-0.25.2.dist-info/uv_cache.json b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera-0.25.2.dist-info/uv_cache.json new file mode 100644 index 00000000..f65d87c2 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera-0.25.2.dist-info/uv_cache.json @@ -0,0 +1 @@ +{"timestamp":{"secs_since_epoch":1754967841,"nanos_since_epoch":642471435},"commit":null,"tags":null} \ No newline at end of file diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/__init__.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/__init__.py new file mode 100644 index 00000000..b6e2641f --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/__init__.py @@ -0,0 +1,178 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +from . import _utilities +import typing +# Export this package's modules as members: +from .action import * +from .compute_env import * +from .credential import * +from .data_link import * +from .datasets import * +from .get_action import * +from .get_compute_env import * +from .get_credential import * +from .get_data_link import * +from .get_dataset import * +from .get_labels import * +from .get_orgs import * +from .get_pipeline import * +from .get_pipeline_secret import * +from .get_studios import * +from .get_teams import * +from .get_tokens import * +from .get_user import * +from .get_user_workspaces import * +from .get_workflows import * +from .get_workspace import * +from .get_workspaces import * +from .labels import * +from .orgs import * +from .pipeline import * +from .pipeline_secret import * +from .provider import * +from .studios import * +from .teams import * +from .tokens import * +from .workflows import * +from .workspace import * +from ._inputs import * +from . import outputs + +# Make subpackages available: +if typing.TYPE_CHECKING: + import pulumi_seqera.config as __config + config = __config +else: + config = _utilities.lazy_import('pulumi_seqera.config') + +_utilities.register( + resource_modules=""" +[ + { + "pkg": "seqera", + "mod": "index/action", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/action:Action": "Action" + } + }, + { + "pkg": "seqera", + "mod": "index/computeEnv", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/computeEnv:ComputeEnv": "ComputeEnv" + } + }, + { + "pkg": "seqera", + "mod": "index/credential", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/credential:Credential": "Credential" + } + }, + { + "pkg": "seqera", + "mod": "index/dataLink", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/dataLink:DataLink": "DataLink" + } + }, + { + "pkg": "seqera", + "mod": "index/datasets", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/datasets:Datasets": "Datasets" + } + }, + { + "pkg": "seqera", + "mod": "index/labels", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/labels:Labels": "Labels" + } + }, + { + "pkg": "seqera", + "mod": "index/orgs", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/orgs:Orgs": "Orgs" + } + }, + { + "pkg": "seqera", + "mod": "index/pipeline", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/pipeline:Pipeline": "Pipeline" + } + }, + { + "pkg": "seqera", + "mod": "index/pipelineSecret", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/pipelineSecret:PipelineSecret": "PipelineSecret" + } + }, + { + "pkg": "seqera", + "mod": "index/studios", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/studios:Studios": "Studios" + } + }, + { + "pkg": "seqera", + "mod": "index/teams", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/teams:Teams": "Teams" + } + }, + { + "pkg": "seqera", + "mod": "index/tokens", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/tokens:Tokens": "Tokens" + } + }, + { + "pkg": "seqera", + "mod": "index/workflows", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/workflows:Workflows": "Workflows" + } + }, + { + "pkg": "seqera", + "mod": "index/workspace", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/workspace:Workspace": "Workspace" + } + } +] +""", + resource_packages=""" +[ + { + "pkg": "seqera", + "token": "pulumi:providers:seqera", + "fqn": "pulumi_seqera", + "class": "Provider" + } +] +""" +) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/_inputs.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/_inputs.py new file mode 100644 index 00000000..73e0319e --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/_inputs.py @@ -0,0 +1,21335 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'ActionConfigArgs', + 'ActionConfigArgsDict', + 'ActionConfigGithubArgs', + 'ActionConfigGithubArgsDict', + 'ActionConfigTowerArgs', + 'ActionConfigTowerArgsDict', + 'ActionEventArgs', + 'ActionEventArgsDict', + 'ActionEventGithubArgs', + 'ActionEventGithubArgsDict', + 'ActionEventTowerArgs', + 'ActionEventTowerArgsDict', + 'ActionLabelArgs', + 'ActionLabelArgsDict', + 'ActionLaunchArgs', + 'ActionLaunchArgsDict', + 'ActionLaunchComputeEnvArgs', + 'ActionLaunchComputeEnvArgsDict', + 'ActionLaunchComputeEnvConfigArgs', + 'ActionLaunchComputeEnvConfigArgsDict', + 'ActionLaunchComputeEnvConfigAltairPlatformArgs', + 'ActionLaunchComputeEnvConfigAltairPlatformArgsDict', + 'ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigAwsBatchArgs', + 'ActionLaunchComputeEnvConfigAwsBatchArgsDict', + 'ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs', + 'ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigAwsBatchForgeArgs', + 'ActionLaunchComputeEnvConfigAwsBatchForgeArgsDict', + 'ActionLaunchComputeEnvConfigAwsCloudArgs', + 'ActionLaunchComputeEnvConfigAwsCloudArgsDict', + 'ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs', + 'ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigAzureBatchArgs', + 'ActionLaunchComputeEnvConfigAzureBatchArgsDict', + 'ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs', + 'ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigAzureBatchForgeArgs', + 'ActionLaunchComputeEnvConfigAzureBatchForgeArgsDict', + 'ActionLaunchComputeEnvConfigEksPlatformArgs', + 'ActionLaunchComputeEnvConfigEksPlatformArgsDict', + 'ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigGkePlatformArgs', + 'ActionLaunchComputeEnvConfigGkePlatformArgsDict', + 'ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigGoogleBatchArgs', + 'ActionLaunchComputeEnvConfigGoogleBatchArgsDict', + 'ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs', + 'ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesArgs', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesArgsDict', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigK8sPlatformArgs', + 'ActionLaunchComputeEnvConfigK8sPlatformArgsDict', + 'ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigLsfPlatformArgs', + 'ActionLaunchComputeEnvConfigLsfPlatformArgsDict', + 'ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigMoabPlatformArgs', + 'ActionLaunchComputeEnvConfigMoabPlatformArgsDict', + 'ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformArgsDict', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgsDict', + 'ActionLaunchComputeEnvConfigSlurmPlatformArgs', + 'ActionLaunchComputeEnvConfigSlurmPlatformArgsDict', + 'ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigUgePlatformArgs', + 'ActionLaunchComputeEnvConfigUgePlatformArgsDict', + 'ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvArgs', + 'ComputeEnvComputeEnvArgsDict', + 'ComputeEnvComputeEnvConfigArgs', + 'ComputeEnvComputeEnvConfigArgsDict', + 'ComputeEnvComputeEnvConfigAltairPlatformArgs', + 'ComputeEnvComputeEnvConfigAltairPlatformArgsDict', + 'ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigAwsBatchArgs', + 'ComputeEnvComputeEnvConfigAwsBatchArgsDict', + 'ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs', + 'ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigAwsBatchForgeArgs', + 'ComputeEnvComputeEnvConfigAwsBatchForgeArgsDict', + 'ComputeEnvComputeEnvConfigAwsCloudArgs', + 'ComputeEnvComputeEnvConfigAwsCloudArgsDict', + 'ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs', + 'ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigAzureBatchArgs', + 'ComputeEnvComputeEnvConfigAzureBatchArgsDict', + 'ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs', + 'ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigAzureBatchForgeArgs', + 'ComputeEnvComputeEnvConfigAzureBatchForgeArgsDict', + 'ComputeEnvComputeEnvConfigEksPlatformArgs', + 'ComputeEnvComputeEnvConfigEksPlatformArgsDict', + 'ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigGkePlatformArgs', + 'ComputeEnvComputeEnvConfigGkePlatformArgsDict', + 'ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigGoogleBatchArgs', + 'ComputeEnvComputeEnvConfigGoogleBatchArgsDict', + 'ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs', + 'ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesArgs', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesArgsDict', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigK8sPlatformArgs', + 'ComputeEnvComputeEnvConfigK8sPlatformArgsDict', + 'ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigLsfPlatformArgs', + 'ComputeEnvComputeEnvConfigLsfPlatformArgsDict', + 'ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigMoabPlatformArgs', + 'ComputeEnvComputeEnvConfigMoabPlatformArgsDict', + 'ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformArgsDict', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgsDict', + 'ComputeEnvComputeEnvConfigSlurmPlatformArgs', + 'ComputeEnvComputeEnvConfigSlurmPlatformArgsDict', + 'ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigUgePlatformArgs', + 'ComputeEnvComputeEnvConfigUgePlatformArgsDict', + 'ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvLabelArgs', + 'ComputeEnvComputeEnvLabelArgsDict', + 'CredentialKeysArgs', + 'CredentialKeysArgsDict', + 'CredentialKeysAwsArgs', + 'CredentialKeysAwsArgsDict', + 'CredentialKeysAzureArgs', + 'CredentialKeysAzureArgsDict', + 'CredentialKeysAzureEntraArgs', + 'CredentialKeysAzureEntraArgsDict', + 'CredentialKeysAzurereposArgs', + 'CredentialKeysAzurereposArgsDict', + 'CredentialKeysBitbucketArgs', + 'CredentialKeysBitbucketArgsDict', + 'CredentialKeysCodecommitArgs', + 'CredentialKeysCodecommitArgsDict', + 'CredentialKeysContainerRegArgs', + 'CredentialKeysContainerRegArgsDict', + 'CredentialKeysGiteaArgs', + 'CredentialKeysGiteaArgsDict', + 'CredentialKeysGithubArgs', + 'CredentialKeysGithubArgsDict', + 'CredentialKeysGitlabArgs', + 'CredentialKeysGitlabArgsDict', + 'CredentialKeysGoogleArgs', + 'CredentialKeysGoogleArgsDict', + 'CredentialKeysK8sArgs', + 'CredentialKeysK8sArgsDict', + 'CredentialKeysSeqeracomputeArgs', + 'CredentialKeysSeqeracomputeArgsDict', + 'CredentialKeysSshArgs', + 'CredentialKeysSshArgsDict', + 'CredentialKeysTwAgentArgs', + 'CredentialKeysTwAgentArgsDict', + 'DataLinkCredentialArgs', + 'DataLinkCredentialArgsDict', + 'LabelsLabelArgs', + 'LabelsLabelArgsDict', + 'PipelineComputeEnvArgs', + 'PipelineComputeEnvArgsDict', + 'PipelineLabelArgs', + 'PipelineLabelArgsDict', + 'PipelineLaunchArgs', + 'PipelineLaunchArgsDict', + 'StudiosActiveConnectionArgs', + 'StudiosActiveConnectionArgsDict', + 'StudiosComputeEnvArgs', + 'StudiosComputeEnvArgsDict', + 'StudiosConfigurationArgs', + 'StudiosConfigurationArgsDict', + 'StudiosLabelArgs', + 'StudiosLabelArgsDict', + 'StudiosMountedDataLinkArgs', + 'StudiosMountedDataLinkArgsDict', + 'StudiosMountedDataLinkCredentialArgs', + 'StudiosMountedDataLinkCredentialArgsDict', + 'StudiosParentCheckpointArgs', + 'StudiosParentCheckpointArgsDict', + 'StudiosProgressArgs', + 'StudiosProgressArgsDict', + 'StudiosStatusInfoArgs', + 'StudiosStatusInfoArgsDict', + 'StudiosTemplateArgs', + 'StudiosTemplateArgsDict', + 'StudiosUserArgs', + 'StudiosUserArgsDict', + 'TokensTokenArgs', + 'TokensTokenArgsDict', + 'WorkflowsJobInfoArgs', + 'WorkflowsJobInfoArgsDict', + 'WorkflowsLabelArgs', + 'WorkflowsLabelArgsDict', + 'WorkflowsPlatformArgs', + 'WorkflowsPlatformArgsDict', + 'WorkflowsProgressArgs', + 'WorkflowsProgressArgsDict', + 'WorkflowsProgressProcessesProgressArgs', + 'WorkflowsProgressProcessesProgressArgsDict', + 'WorkflowsProgressWorkflowProgressArgs', + 'WorkflowsProgressWorkflowProgressArgsDict', + 'WorkflowsWorkflowArgs', + 'WorkflowsWorkflowArgsDict', + 'WorkflowsWorkflowManifestArgs', + 'WorkflowsWorkflowManifestArgsDict', + 'WorkflowsWorkflowNextflowArgs', + 'WorkflowsWorkflowNextflowArgsDict', + 'WorkflowsWorkflowStatsArgs', + 'WorkflowsWorkflowStatsArgsDict', +] + +MYPY = False + +if not MYPY: + class ActionConfigArgsDict(TypedDict): + github: NotRequired[pulumi.Input['ActionConfigGithubArgsDict']] + tower: NotRequired[pulumi.Input['ActionConfigTowerArgsDict']] +elif False: + ActionConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionConfigArgs: + def __init__(__self__, *, + github: Optional[pulumi.Input['ActionConfigGithubArgs']] = None, + tower: Optional[pulumi.Input['ActionConfigTowerArgs']] = None): + if github is not None: + pulumi.set(__self__, "github", github) + if tower is not None: + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional[pulumi.Input['ActionConfigGithubArgs']]: + return pulumi.get(self, "github") + + @github.setter + def github(self, value: Optional[pulumi.Input['ActionConfigGithubArgs']]): + pulumi.set(self, "github", value) + + @_builtins.property + @pulumi.getter + def tower(self) -> Optional[pulumi.Input['ActionConfigTowerArgs']]: + return pulumi.get(self, "tower") + + @tower.setter + def tower(self, value: Optional[pulumi.Input['ActionConfigTowerArgs']]): + pulumi.set(self, "tower", value) + + +if not MYPY: + class ActionConfigGithubArgsDict(TypedDict): + discriminator: NotRequired[pulumi.Input[_builtins.str]] + events: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] +elif False: + ActionConfigGithubArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionConfigGithubArgs: + def __init__(__self__, *, + discriminator: Optional[pulumi.Input[_builtins.str]] = None, + events: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if events is not None: + pulumi.set(__self__, "events", events) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "discriminator") + + @discriminator.setter + def discriminator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "discriminator", value) + + @_builtins.property + @pulumi.getter + def events(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "events") + + @events.setter + def events(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "events", value) + + +if not MYPY: + class ActionConfigTowerArgsDict(TypedDict): + discriminator: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionConfigTowerArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionConfigTowerArgs: + def __init__(__self__, *, + discriminator: Optional[pulumi.Input[_builtins.str]] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "discriminator") + + @discriminator.setter + def discriminator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "discriminator", value) + + +if not MYPY: + class ActionEventArgsDict(TypedDict): + github: NotRequired[pulumi.Input['ActionEventGithubArgsDict']] + tower: NotRequired[pulumi.Input['ActionEventTowerArgsDict']] +elif False: + ActionEventArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionEventArgs: + def __init__(__self__, *, + github: Optional[pulumi.Input['ActionEventGithubArgs']] = None, + tower: Optional[pulumi.Input['ActionEventTowerArgs']] = None): + if github is not None: + pulumi.set(__self__, "github", github) + if tower is not None: + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional[pulumi.Input['ActionEventGithubArgs']]: + return pulumi.get(self, "github") + + @github.setter + def github(self, value: Optional[pulumi.Input['ActionEventGithubArgs']]): + pulumi.set(self, "github", value) + + @_builtins.property + @pulumi.getter + def tower(self) -> Optional[pulumi.Input['ActionEventTowerArgs']]: + return pulumi.get(self, "tower") + + @tower.setter + def tower(self, value: Optional[pulumi.Input['ActionEventTowerArgs']]): + pulumi.set(self, "tower", value) + + +if not MYPY: + class ActionEventGithubArgsDict(TypedDict): + commit_id: NotRequired[pulumi.Input[_builtins.str]] + commit_message: NotRequired[pulumi.Input[_builtins.str]] + discriminator: NotRequired[pulumi.Input[_builtins.str]] + pusher_email: NotRequired[pulumi.Input[_builtins.str]] + pusher_name: NotRequired[pulumi.Input[_builtins.str]] + ref: NotRequired[pulumi.Input[_builtins.str]] + timestamp: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionEventGithubArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionEventGithubArgs: + def __init__(__self__, *, + commit_id: Optional[pulumi.Input[_builtins.str]] = None, + commit_message: Optional[pulumi.Input[_builtins.str]] = None, + discriminator: Optional[pulumi.Input[_builtins.str]] = None, + pusher_email: Optional[pulumi.Input[_builtins.str]] = None, + pusher_name: Optional[pulumi.Input[_builtins.str]] = None, + ref: Optional[pulumi.Input[_builtins.str]] = None, + timestamp: Optional[pulumi.Input[_builtins.str]] = None): + if commit_id is not None: + pulumi.set(__self__, "commit_id", commit_id) + if commit_message is not None: + pulumi.set(__self__, "commit_message", commit_message) + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if pusher_email is not None: + pulumi.set(__self__, "pusher_email", pusher_email) + if pusher_name is not None: + pulumi.set(__self__, "pusher_name", pusher_name) + if ref is not None: + pulumi.set(__self__, "ref", ref) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "commit_id") + + @commit_id.setter + def commit_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "commit_id", value) + + @_builtins.property + @pulumi.getter(name="commitMessage") + def commit_message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "commit_message") + + @commit_message.setter + def commit_message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "commit_message", value) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "discriminator") + + @discriminator.setter + def discriminator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "discriminator", value) + + @_builtins.property + @pulumi.getter(name="pusherEmail") + def pusher_email(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "pusher_email") + + @pusher_email.setter + def pusher_email(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pusher_email", value) + + @_builtins.property + @pulumi.getter(name="pusherName") + def pusher_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "pusher_name") + + @pusher_name.setter + def pusher_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pusher_name", value) + + @_builtins.property + @pulumi.getter + def ref(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ref") + + @ref.setter + def ref(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ref", value) + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "timestamp") + + @timestamp.setter + def timestamp(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "timestamp", value) + + +if not MYPY: + class ActionEventTowerArgsDict(TypedDict): + discriminator: NotRequired[pulumi.Input[_builtins.str]] + timestamp: NotRequired[pulumi.Input[_builtins.str]] + workflow_id: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionEventTowerArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionEventTowerArgs: + def __init__(__self__, *, + discriminator: Optional[pulumi.Input[_builtins.str]] = None, + timestamp: Optional[pulumi.Input[_builtins.str]] = None, + workflow_id: Optional[pulumi.Input[_builtins.str]] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + if workflow_id is not None: + pulumi.set(__self__, "workflow_id", workflow_id) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "discriminator") + + @discriminator.setter + def discriminator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "discriminator", value) + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "timestamp") + + @timestamp.setter + def timestamp(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "timestamp", value) + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "workflow_id") + + @workflow_id.setter + def workflow_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "workflow_id", value) + + +if not MYPY: + class ActionLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + ActionLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchArgsDict(TypedDict): + compute_env_id: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + pipeline: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + work_dir: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + compute_env: NotRequired[pulumi.Input['ActionLaunchComputeEnvArgsDict']] + config_profiles: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + config_text: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + entry_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + id: NotRequired[pulumi.Input[_builtins.str]] + label_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] + """ + Requires replacement if changed. + """ + last_updated: NotRequired[pulumi.Input[_builtins.str]] + launch_container: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + main_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + optimization_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + optimization_targets: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + params_text: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + pull_latest: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + resume: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + resume_launch_id: NotRequired[pulumi.Input[_builtins.str]] + revision: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + run_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + schema_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + session_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + stub_run: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + tower_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + user_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + workspace_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ +elif False: + ActionLaunchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchArgs: + def __init__(__self__, *, + compute_env_id: pulumi.Input[_builtins.str], + pipeline: pulumi.Input[_builtins.str], + work_dir: pulumi.Input[_builtins.str], + compute_env: Optional[pulumi.Input['ActionLaunchComputeEnvArgs']] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + id: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + resume_launch_id: Optional[pulumi.Input[_builtins.str]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if id is not None: + pulumi.set(__self__, "id", id) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if resume_launch_id is not None: + pulumi.set(__self__, "resume_launch_id", resume_launch_id) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def pipeline(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @pipeline.setter + def pipeline(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "pipeline", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvArgs']]: + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvArgs']]): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @config_profiles.setter + def config_profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_profiles", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @entry_name.setter + def entry_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "entry_name", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @launch_container.setter + def launch_container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_container", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @params_text.setter + def params_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "params_text", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @pull_latest.setter + def pull_latest(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "pull_latest", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter(name="resumeLaunchId") + def resume_launch_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "resume_launch_id") + + @resume_launch_id.setter + def resume_launch_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "resume_launch_id", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @schema_name.setter + def schema_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "schema_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @stub_run.setter + def stub_run(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "stub_run", value) + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @tower_config.setter + def tower_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tower_config", value) + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @user_secrets.setter + def user_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "user_secrets", value) + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + + @workspace_secrets.setter + def workspace_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "workspace_secrets", value) + + +if not MYPY: + class ActionLaunchComputeEnvArgsDict(TypedDict): + compute_env_id: NotRequired[pulumi.Input[_builtins.str]] + config: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigArgsDict']] + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + credentials_id: NotRequired[pulumi.Input[_builtins.str]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + deleted: NotRequired[pulumi.Input[_builtins.bool]] + description: NotRequired[pulumi.Input[_builtins.str]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + last_used: NotRequired[pulumi.Input[_builtins.str]] + message: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + org_id: NotRequired[pulumi.Input[_builtins.float]] + platform: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + """ + primary: NotRequired[pulumi.Input[_builtins.bool]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + workspace_id: NotRequired[pulumi.Input[_builtins.float]] +elif False: + ActionLaunchComputeEnvArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvArgs: + def __init__(__self__, *, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config: Optional[pulumi.Input['ActionLaunchComputeEnvConfigArgs']] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + platform: Optional[pulumi.Input[_builtins.str]] = None, + primary: Optional[pulumi.Input[_builtins.bool]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + :param pulumi.Input['ActionLaunchComputeEnvConfigArgs'] config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + :param pulumi.Input[_builtins.str] platform: must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + :param pulumi.Input[_builtins.str] status: must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if config is not None: + pulumi.set(__self__, "config", config) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if primary is not None: + pulumi.set(__self__, "primary", primary) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def config(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigArgs']]: + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + return pulumi.get(self, "config") + + @config.setter + def config(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigArgs']]): + pulumi.set(self, "config", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + """ + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter + def primary(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "primary") + + @primary.setter + def primary(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "primary", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigArgsDict(TypedDict): + altair_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformArgsDict']] + aws_batch: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchArgsDict']] + aws_cloud: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudArgsDict']] + azure_batch: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchArgsDict']] + eks_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformArgsDict']] + gke_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformArgsDict']] + google_batch: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchArgsDict']] + google_lifesciences: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesArgsDict']] + k8s_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformArgsDict']] + lsf_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformArgsDict']] + moab_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformArgsDict']] + seqeracompute_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformArgsDict']] + slurm_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformArgsDict']] + uge_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformArgsDict']] +elif False: + ActionLaunchComputeEnvConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigArgs: + def __init__(__self__, *, + altair_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformArgs']] = None, + aws_batch: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchArgs']] = None, + aws_cloud: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudArgs']] = None, + azure_batch: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchArgs']] = None, + eks_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformArgs']] = None, + gke_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformArgs']] = None, + google_batch: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchArgs']] = None, + google_lifesciences: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesArgs']] = None, + k8s_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformArgs']] = None, + lsf_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformArgs']] = None, + moab_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformArgs']] = None, + seqeracompute_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs']] = None, + slurm_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformArgs']] = None, + uge_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformArgs']] = None): + if altair_platform is not None: + pulumi.set(__self__, "altair_platform", altair_platform) + if aws_batch is not None: + pulumi.set(__self__, "aws_batch", aws_batch) + if aws_cloud is not None: + pulumi.set(__self__, "aws_cloud", aws_cloud) + if azure_batch is not None: + pulumi.set(__self__, "azure_batch", azure_batch) + if eks_platform is not None: + pulumi.set(__self__, "eks_platform", eks_platform) + if gke_platform is not None: + pulumi.set(__self__, "gke_platform", gke_platform) + if google_batch is not None: + pulumi.set(__self__, "google_batch", google_batch) + if google_lifesciences is not None: + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + if k8s_platform is not None: + pulumi.set(__self__, "k8s_platform", k8s_platform) + if lsf_platform is not None: + pulumi.set(__self__, "lsf_platform", lsf_platform) + if moab_platform is not None: + pulumi.set(__self__, "moab_platform", moab_platform) + if seqeracompute_platform is not None: + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + if slurm_platform is not None: + pulumi.set(__self__, "slurm_platform", slurm_platform) + if uge_platform is not None: + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformArgs']]: + return pulumi.get(self, "altair_platform") + + @altair_platform.setter + def altair_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformArgs']]): + pulumi.set(self, "altair_platform", value) + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchArgs']]: + return pulumi.get(self, "aws_batch") + + @aws_batch.setter + def aws_batch(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchArgs']]): + pulumi.set(self, "aws_batch", value) + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudArgs']]: + return pulumi.get(self, "aws_cloud") + + @aws_cloud.setter + def aws_cloud(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudArgs']]): + pulumi.set(self, "aws_cloud", value) + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchArgs']]: + return pulumi.get(self, "azure_batch") + + @azure_batch.setter + def azure_batch(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchArgs']]): + pulumi.set(self, "azure_batch", value) + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformArgs']]: + return pulumi.get(self, "eks_platform") + + @eks_platform.setter + def eks_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformArgs']]): + pulumi.set(self, "eks_platform", value) + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformArgs']]: + return pulumi.get(self, "gke_platform") + + @gke_platform.setter + def gke_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformArgs']]): + pulumi.set(self, "gke_platform", value) + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchArgs']]: + return pulumi.get(self, "google_batch") + + @google_batch.setter + def google_batch(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchArgs']]): + pulumi.set(self, "google_batch", value) + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesArgs']]: + return pulumi.get(self, "google_lifesciences") + + @google_lifesciences.setter + def google_lifesciences(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesArgs']]): + pulumi.set(self, "google_lifesciences", value) + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformArgs']]: + return pulumi.get(self, "k8s_platform") + + @k8s_platform.setter + def k8s_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformArgs']]): + pulumi.set(self, "k8s_platform", value) + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformArgs']]: + return pulumi.get(self, "lsf_platform") + + @lsf_platform.setter + def lsf_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformArgs']]): + pulumi.set(self, "lsf_platform", value) + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformArgs']]: + return pulumi.get(self, "moab_platform") + + @moab_platform.setter + def moab_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformArgs']]): + pulumi.set(self, "moab_platform", value) + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs']]: + return pulumi.get(self, "seqeracompute_platform") + + @seqeracompute_platform.setter + def seqeracompute_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs']]): + pulumi.set(self, "seqeracompute_platform", value) + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformArgs']]: + return pulumi.get(self, "slurm_platform") + + @slurm_platform.setter + def slurm_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformArgs']]): + pulumi.set(self, "slurm_platform", value) + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformArgs']]: + return pulumi.get(self, "uge_platform") + + @uge_platform.setter + def uge_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformArgs']]): + pulumi.set(self, "uge_platform", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAltairPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigAltairPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAltairPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsBatchArgsDict(TypedDict): + cli_path: NotRequired[pulumi.Input[_builtins.str]] + compute_job_role: NotRequired[pulumi.Input[_builtins.str]] + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + dragen_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + execution_role: NotRequired[pulumi.Input[_builtins.str]] + forge: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchForgeArgsDict']] + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + fusion_snapshots: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_job_role: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + log_group: NotRequired[pulumi.Input[_builtins.str]] + lustre_id: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + nvnme_storage_enabled: NotRequired[pulumi.Input[_builtins.bool]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + storage_type: NotRequired[pulumi.Input[_builtins.str]] + volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigAwsBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsBatchArgs: + def __init__(__self__, *, + cli_path: Optional[pulumi.Input[_builtins.str]] = None, + compute_job_role: Optional[pulumi.Input[_builtins.str]] = None, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + dragen_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs']]]] = None, + execution_role: Optional[pulumi.Input[_builtins.str]] = None, + forge: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fusion_snapshots: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_job_role: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + lustre_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nvnme_storage_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + storage_type: Optional[pulumi.Input[_builtins.str]] = None, + volumes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""lustre_id is deprecated: Deprecated""") + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""storage_type is deprecated: Deprecated""") + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "cli_path") + + @cli_path.setter + def cli_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cli_path", value) + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_job_role") + + @compute_job_role.setter + def compute_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_job_role", value) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_queue") + + @dragen_queue.setter + def dragen_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "execution_role") + + @execution_role.setter + def execution_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "execution_role", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchForgeArgs']]: + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion_snapshots") + + @fusion_snapshots.setter + def fusion_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_snapshots", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_role") + + @head_job_role.setter + def head_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_role", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "lustre_id") + + @lustre_id.setter + def lustre_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "lustre_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "nvnme_storage_enabled") + + @nvnme_storage_enabled.setter + def nvnme_storage_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "nvnme_storage_enabled", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_type") + + @storage_type.setter + def storage_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_type", value) + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "volumes") + + @volumes.setter + def volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "volumes", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsBatchForgeArgsDict(TypedDict): + alloc_strategy: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + bid_percentage: NotRequired[pulumi.Input[_builtins.float]] + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + dragen_ami_id: NotRequired[pulumi.Input[_builtins.str]] + dragen_enabled: NotRequired[pulumi.Input[_builtins.bool]] + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + ebs_auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + ebs_block_size: NotRequired[pulumi.Input[_builtins.float]] + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + ecs_config: NotRequired[pulumi.Input[_builtins.str]] + efs_create: NotRequired[pulumi.Input[_builtins.bool]] + efs_id: NotRequired[pulumi.Input[_builtins.str]] + efs_mount: NotRequired[pulumi.Input[_builtins.str]] + fargate_head_enabled: NotRequired[pulumi.Input[_builtins.bool]] + fsx_mount: NotRequired[pulumi.Input[_builtins.str]] + fsx_name: NotRequired[pulumi.Input[_builtins.str]] + fsx_size: NotRequired[pulumi.Input[_builtins.float]] + fusion_enabled: NotRequired[pulumi.Input[_builtins.bool]] + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + image_id: NotRequired[pulumi.Input[_builtins.str]] + instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + max_cpus: NotRequired[pulumi.Input[_builtins.float]] + min_cpus: NotRequired[pulumi.Input[_builtins.float]] + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["SPOT", "EC2"] + """ + vpc_id: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAwsBatchForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsBatchForgeArgs: + def __init__(__self__, *, + alloc_strategy: Optional[pulumi.Input[_builtins.str]] = None, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + bid_percentage: Optional[pulumi.Input[_builtins.float]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_ami_id: Optional[pulumi.Input[_builtins.str]] = None, + dragen_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + ebs_auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_block_size: Optional[pulumi.Input[_builtins.float]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + ecs_config: Optional[pulumi.Input[_builtins.str]] = None, + efs_create: Optional[pulumi.Input[_builtins.bool]] = None, + efs_id: Optional[pulumi.Input[_builtins.str]] = None, + efs_mount: Optional[pulumi.Input[_builtins.str]] = None, + fargate_head_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fsx_mount: Optional[pulumi.Input[_builtins.str]] = None, + fsx_name: Optional[pulumi.Input[_builtins.str]] = None, + fsx_size: Optional[pulumi.Input[_builtins.float]] = None, + fusion_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + max_cpus: Optional[pulumi.Input[_builtins.float]] = None, + min_cpus: Optional[pulumi.Input[_builtins.float]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + vpc_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + :param pulumi.Input[_builtins.str] type: must be one of ["SPOT", "EC2"] + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + return pulumi.get(self, "alloc_strategy") + + @alloc_strategy.setter + def alloc_strategy(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alloc_strategy", value) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "bid_percentage") + + @bid_percentage.setter + def bid_percentage(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "bid_percentage", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_ami_id") + + @dragen_ami_id.setter + def dragen_ami_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_ami_id", value) + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dragen_enabled") + + @dragen_enabled.setter + def dragen_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dragen_enabled", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "ebs_auto_scale") + + @ebs_auto_scale.setter + def ebs_auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ebs_auto_scale", value) + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_block_size") + + @ebs_block_size.setter + def ebs_block_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_block_size", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ecs_config") + + @ecs_config.setter + def ecs_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ecs_config", value) + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "efs_create") + + @efs_create.setter + def efs_create(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "efs_create", value) + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "efs_id") + + @efs_id.setter + def efs_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_id", value) + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "efs_mount") + + @efs_mount.setter + def efs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_mount", value) + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fargate_head_enabled") + + @fargate_head_enabled.setter + def fargate_head_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fargate_head_enabled", value) + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "fsx_mount") + + @fsx_mount.setter + def fsx_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_mount", value) + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "fsx_name") + + @fsx_name.setter + def fsx_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_name", value) + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "fsx_size") + + @fsx_size.setter + def fsx_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "fsx_size", value) + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion_enabled") + + @fusion_enabled.setter + def fusion_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "instance_types") + + @instance_types.setter + def instance_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "instance_types", value) + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_cpus") + + @max_cpus.setter + def max_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_cpus", value) + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "min_cpus") + + @min_cpus.setter + def min_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "min_cpus", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "subnets") + + @subnets.setter + def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "subnets", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["SPOT", "EC2"] + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "vpc_id") + + @vpc_id.setter + def vpc_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vpc_id", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsCloudArgsDict(TypedDict): + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + image_id: NotRequired[pulumi.Input[_builtins.str]] + instance_profile_arn: NotRequired[pulumi.Input[_builtins.str]] + instance_type: NotRequired[pulumi.Input[_builtins.str]] + log_group: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + subnet_id: NotRequired[pulumi.Input[_builtins.str]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigAwsCloudArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsCloudArgs: + def __init__(__self__, *, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_profile_arn: Optional[pulumi.Input[_builtins.str]] = None, + instance_type: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnet_id: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_profile_arn is not None: + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + if instance_type is not None: + pulumi.set(__self__, "instance_type", instance_type) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnet_id is not None: + pulumi.set(__self__, "subnet_id", subnet_id) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "instance_profile_arn") + + @instance_profile_arn.setter + def instance_profile_arn(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_profile_arn", value) + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "instance_type") + + @instance_type.setter + def instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_type", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "subnet_id") + + @subnet_id.setter + def subnet_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "subnet_id", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAzureBatchArgsDict(TypedDict): + auto_pool_mode: NotRequired[pulumi.Input[_builtins.bool]] + delete_jobs_on_completion: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"] + """ + delete_pools_on_completion: NotRequired[pulumi.Input[_builtins.bool]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + forge: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchForgeArgsDict']] + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + head_pool: NotRequired[pulumi.Input[_builtins.str]] + managed_identity_client_id: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + token_duration: NotRequired[pulumi.Input[_builtins.str]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigAzureBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAzureBatchArgs: + def __init__(__self__, *, + auto_pool_mode: Optional[pulumi.Input[_builtins.bool]] = None, + delete_jobs_on_completion: Optional[pulumi.Input[_builtins.str]] = None, + delete_pools_on_completion: Optional[pulumi.Input[_builtins.bool]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs']]]] = None, + forge: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_pool: Optional[pulumi.Input[_builtins.str]] = None, + managed_identity_client_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + token_duration: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] delete_jobs_on_completion: must be one of ["on_success", "always", "never"] + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if auto_pool_mode is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""auto_pool_mode is deprecated: Deprecated""") + if auto_pool_mode is not None: + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + if delete_jobs_on_completion is not None: + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + if delete_pools_on_completion is not None: + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_pool is not None: + pulumi.set(__self__, "head_pool", head_pool) + if managed_identity_client_id is not None: + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if token_duration is not None: + pulumi.set(__self__, "token_duration", token_duration) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "auto_pool_mode") + + @auto_pool_mode.setter + def auto_pool_mode(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_pool_mode", value) + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "delete_jobs_on_completion") + + @delete_jobs_on_completion.setter + def delete_jobs_on_completion(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "delete_jobs_on_completion", value) + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "delete_pools_on_completion") + + @delete_pools_on_completion.setter + def delete_pools_on_completion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "delete_pools_on_completion", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchForgeArgs']]: + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_pool") + + @head_pool.setter + def head_pool(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pool", value) + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "managed_identity_client_id") + + @managed_identity_client_id.setter + def managed_identity_client_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "managed_identity_client_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "token_duration") + + @token_duration.setter + def token_duration(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "token_duration", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAzureBatchForgeArgsDict(TypedDict): + auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + container_reg_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + vm_count: NotRequired[pulumi.Input[_builtins.float]] + vm_type: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAzureBatchForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAzureBatchForgeArgs: + def __init__(__self__, *, + auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + container_reg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + vm_count: Optional[pulumi.Input[_builtins.float]] = None, + vm_type: Optional[pulumi.Input[_builtins.str]] = None): + if auto_scale is not None: + pulumi.set(__self__, "auto_scale", auto_scale) + if container_reg_ids is not None: + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if vm_count is not None: + pulumi.set(__self__, "vm_count", vm_count) + if vm_type is not None: + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "auto_scale") + + @auto_scale.setter + def auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_scale", value) + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "container_reg_ids") + + @container_reg_ids.setter + def container_reg_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "container_reg_ids", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "vm_count") + + @vm_count.setter + def vm_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "vm_count", value) + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "vm_type") + + @vm_type.setter + def vm_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vm_type", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigEksPlatformArgsDict(TypedDict): + cluster_name: NotRequired[pulumi.Input[_builtins.str]] + """ + The AWS EKS cluster name + """ + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + namespace: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"] + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + AWS region + """ + server: NotRequired[pulumi.Input[_builtins.str]] + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigEksPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigEksPlatformArgs: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[_builtins.str]] = None, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cluster_name: The AWS EKS cluster name + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"] + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] region: AWS region + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The AWS EKS cluster name + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + AWS region + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGkePlatformArgsDict(TypedDict): + cluster_name: NotRequired[pulumi.Input[_builtins.str]] + """ + The GKE cluster name + """ + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + namespace: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"] + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + The GKE cluster region - or - zone + """ + server: NotRequired[pulumi.Input[_builtins.str]] + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigGkePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGkePlatformArgs: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[_builtins.str]] = None, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cluster_name: The GKE cluster name + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"] + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] region: The GKE cluster region - or - zone + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The GKE cluster name + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The GKE cluster region - or - zone + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGoogleBatchArgsDict(TypedDict): + boot_disk_size_gb: NotRequired[pulumi.Input[_builtins.float]] + compute_jobs_instance_template: NotRequired[pulumi.Input[_builtins.str]] + copy_image: NotRequired[pulumi.Input[_builtins.str]] + cpu_platform: NotRequired[pulumi.Input[_builtins.str]] + debug_mode: NotRequired[pulumi.Input[_builtins.float]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_instance_template: NotRequired[pulumi.Input[_builtins.str]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + location: NotRequired[pulumi.Input[_builtins.str]] + machine_type: NotRequired[pulumi.Input[_builtins.str]] + network: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + nfs_mount: NotRequired[pulumi.Input[_builtins.str]] + nfs_target: NotRequired[pulumi.Input[_builtins.str]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + project_id: NotRequired[pulumi.Input[_builtins.str]] + service_account: NotRequired[pulumi.Input[_builtins.str]] + spot: NotRequired[pulumi.Input[_builtins.bool]] + ssh_daemon: NotRequired[pulumi.Input[_builtins.bool]] + ssh_image: NotRequired[pulumi.Input[_builtins.str]] + subnetwork: NotRequired[pulumi.Input[_builtins.str]] + use_private_address: NotRequired[pulumi.Input[_builtins.bool]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigGoogleBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGoogleBatchArgs: + def __init__(__self__, *, + boot_disk_size_gb: Optional[pulumi.Input[_builtins.float]] = None, + compute_jobs_instance_template: Optional[pulumi.Input[_builtins.str]] = None, + copy_image: Optional[pulumi.Input[_builtins.str]] = None, + cpu_platform: Optional[pulumi.Input[_builtins.str]] = None, + debug_mode: Optional[pulumi.Input[_builtins.float]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_instance_template: Optional[pulumi.Input[_builtins.str]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + machine_type: Optional[pulumi.Input[_builtins.str]] = None, + network: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nfs_mount: Optional[pulumi.Input[_builtins.str]] = None, + nfs_target: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + project_id: Optional[pulumi.Input[_builtins.str]] = None, + service_account: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_daemon: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_image: Optional[pulumi.Input[_builtins.str]] = None, + subnetwork: Optional[pulumi.Input[_builtins.str]] = None, + use_private_address: Optional[pulumi.Input[_builtins.bool]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if compute_jobs_instance_template is not None: + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if cpu_platform is not None: + pulumi.set(__self__, "cpu_platform", cpu_platform) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_instance_template is not None: + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if network is not None: + pulumi.set(__self__, "network", network) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if subnetwork is not None: + pulumi.set(__self__, "subnetwork", subnetwork) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "boot_disk_size_gb") + + @boot_disk_size_gb.setter + def boot_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "boot_disk_size_gb", value) + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_jobs_instance_template") + + @compute_jobs_instance_template.setter + def compute_jobs_instance_template(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_jobs_instance_template", value) + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "copy_image") + + @copy_image.setter + def copy_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "copy_image", value) + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "cpu_platform") + + @cpu_platform.setter + def cpu_platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cpu_platform", value) + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "debug_mode") + + @debug_mode.setter + def debug_mode(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "debug_mode", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_instance_template") + + @head_job_instance_template.setter + def head_job_instance_template(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_instance_template", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "machine_type") + + @machine_type.setter + def machine_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "machine_type", value) + + @_builtins.property + @pulumi.getter + def network(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "network") + + @network.setter + def network(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "network", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nfs_mount") + + @nfs_mount.setter + def nfs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_mount", value) + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nfs_target") + + @nfs_target.setter + def nfs_target(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_target", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_id", value) + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "service_account") + + @service_account.setter + def service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_account", value) + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "spot") + + @spot.setter + def spot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "spot", value) + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "ssh_daemon") + + @ssh_daemon.setter + def ssh_daemon(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ssh_daemon", value) + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssh_image") + + @ssh_image.setter + def ssh_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssh_image", value) + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "subnetwork") + + @subnetwork.setter + def subnetwork(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "subnetwork", value) + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "use_private_address") + + @use_private_address.setter + def use_private_address(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_private_address", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGoogleLifesciencesArgsDict(TypedDict): + boot_disk_size_gb: NotRequired[pulumi.Input[_builtins.float]] + copy_image: NotRequired[pulumi.Input[_builtins.str]] + debug_mode: NotRequired[pulumi.Input[_builtins.float]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + location: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + nfs_mount: NotRequired[pulumi.Input[_builtins.str]] + nfs_target: NotRequired[pulumi.Input[_builtins.str]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + preemptible: NotRequired[pulumi.Input[_builtins.bool]] + project_id: NotRequired[pulumi.Input[_builtins.str]] + region: NotRequired[pulumi.Input[_builtins.str]] + ssh_daemon: NotRequired[pulumi.Input[_builtins.bool]] + ssh_image: NotRequired[pulumi.Input[_builtins.str]] + use_private_address: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ + zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] +elif False: + ActionLaunchComputeEnvConfigGoogleLifesciencesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGoogleLifesciencesArgs: + def __init__(__self__, *, + boot_disk_size_gb: Optional[pulumi.Input[_builtins.float]] = None, + copy_image: Optional[pulumi.Input[_builtins.str]] = None, + debug_mode: Optional[pulumi.Input[_builtins.float]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nfs_mount: Optional[pulumi.Input[_builtins.str]] = None, + nfs_target: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + preemptible: Optional[pulumi.Input[_builtins.bool]] = None, + project_id: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + ssh_daemon: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_image: Optional[pulumi.Input[_builtins.str]] = None, + use_private_address: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if preemptible is not None: + pulumi.set(__self__, "preemptible", preemptible) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "boot_disk_size_gb") + + @boot_disk_size_gb.setter + def boot_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "boot_disk_size_gb", value) + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "copy_image") + + @copy_image.setter + def copy_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "copy_image", value) + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "debug_mode") + + @debug_mode.setter + def debug_mode(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "debug_mode", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nfs_mount") + + @nfs_mount.setter + def nfs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_mount", value) + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nfs_target") + + @nfs_target.setter + def nfs_target(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_target", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def preemptible(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "preemptible") + + @preemptible.setter + def preemptible(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "preemptible", value) + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_id", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "ssh_daemon") + + @ssh_daemon.setter + def ssh_daemon(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ssh_daemon", value) + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssh_image") + + @ssh_image.setter + def ssh_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssh_image", value) + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "use_private_address") + + @use_private_address.setter + def use_private_address(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_private_address", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter + def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "zones") + + @zones.setter + def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "zones", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigK8sPlatformArgsDict(TypedDict): + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + namespace: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"] + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + server: NotRequired[pulumi.Input[_builtins.str]] + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigK8sPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigK8sPlatformArgs: + def __init__(__self__, *, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs']]]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"] + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigLsfPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + per_job_mem_limit: NotRequired[pulumi.Input[_builtins.bool]] + per_task_reserve: NotRequired[pulumi.Input[_builtins.bool]] + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + unit_for_limits: NotRequired[pulumi.Input[_builtins.str]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigLsfPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigLsfPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + per_job_mem_limit: Optional[pulumi.Input[_builtins.bool]] = None, + per_task_reserve: Optional[pulumi.Input[_builtins.bool]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + unit_for_limits: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if per_job_mem_limit is not None: + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + if per_task_reserve is not None: + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if unit_for_limits is not None: + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "per_job_mem_limit") + + @per_job_mem_limit.setter + def per_job_mem_limit(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "per_job_mem_limit", value) + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "per_task_reserve") + + @per_task_reserve.setter + def per_task_reserve(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "per_task_reserve", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "unit_for_limits") + + @unit_for_limits.setter + def unit_for_limits(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "unit_for_limits", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigMoabPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigMoabPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigMoabPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSeqeracomputePlatformArgsDict(TypedDict): + cli_path: NotRequired[pulumi.Input[_builtins.str]] + compute_job_role: NotRequired[pulumi.Input[_builtins.str]] + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + dragen_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + execution_role: NotRequired[pulumi.Input[_builtins.str]] + forge: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgsDict']] + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + fusion_snapshots: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_job_role: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + log_group: NotRequired[pulumi.Input[_builtins.str]] + lustre_id: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + nvnme_storage_enabled: NotRequired[pulumi.Input[_builtins.bool]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + storage_type: NotRequired[pulumi.Input[_builtins.str]] + volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigSeqeracomputePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs: + def __init__(__self__, *, + cli_path: Optional[pulumi.Input[_builtins.str]] = None, + compute_job_role: Optional[pulumi.Input[_builtins.str]] = None, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + dragen_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]] = None, + execution_role: Optional[pulumi.Input[_builtins.str]] = None, + forge: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fusion_snapshots: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_job_role: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + lustre_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nvnme_storage_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + storage_type: Optional[pulumi.Input[_builtins.str]] = None, + volumes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""lustre_id is deprecated: Deprecated""") + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""storage_type is deprecated: Deprecated""") + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "cli_path") + + @cli_path.setter + def cli_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cli_path", value) + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_job_role") + + @compute_job_role.setter + def compute_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_job_role", value) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_queue") + + @dragen_queue.setter + def dragen_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "execution_role") + + @execution_role.setter + def execution_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "execution_role", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs']]: + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion_snapshots") + + @fusion_snapshots.setter + def fusion_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_snapshots", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_role") + + @head_job_role.setter + def head_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_role", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "lustre_id") + + @lustre_id.setter + def lustre_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "lustre_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "nvnme_storage_enabled") + + @nvnme_storage_enabled.setter + def nvnme_storage_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "nvnme_storage_enabled", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_type") + + @storage_type.setter + def storage_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_type", value) + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "volumes") + + @volumes.setter + def volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "volumes", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgsDict(TypedDict): + alloc_strategy: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + bid_percentage: NotRequired[pulumi.Input[_builtins.float]] + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + dragen_ami_id: NotRequired[pulumi.Input[_builtins.str]] + dragen_enabled: NotRequired[pulumi.Input[_builtins.bool]] + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + ebs_auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + ebs_block_size: NotRequired[pulumi.Input[_builtins.float]] + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + ecs_config: NotRequired[pulumi.Input[_builtins.str]] + efs_create: NotRequired[pulumi.Input[_builtins.bool]] + efs_id: NotRequired[pulumi.Input[_builtins.str]] + efs_mount: NotRequired[pulumi.Input[_builtins.str]] + fargate_head_enabled: NotRequired[pulumi.Input[_builtins.bool]] + fsx_mount: NotRequired[pulumi.Input[_builtins.str]] + fsx_name: NotRequired[pulumi.Input[_builtins.str]] + fsx_size: NotRequired[pulumi.Input[_builtins.float]] + fusion_enabled: NotRequired[pulumi.Input[_builtins.bool]] + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + image_id: NotRequired[pulumi.Input[_builtins.str]] + instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + max_cpus: NotRequired[pulumi.Input[_builtins.float]] + min_cpus: NotRequired[pulumi.Input[_builtins.float]] + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["SPOT", "EC2"] + """ + vpc_id: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs: + def __init__(__self__, *, + alloc_strategy: Optional[pulumi.Input[_builtins.str]] = None, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + bid_percentage: Optional[pulumi.Input[_builtins.float]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_ami_id: Optional[pulumi.Input[_builtins.str]] = None, + dragen_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + ebs_auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_block_size: Optional[pulumi.Input[_builtins.float]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + ecs_config: Optional[pulumi.Input[_builtins.str]] = None, + efs_create: Optional[pulumi.Input[_builtins.bool]] = None, + efs_id: Optional[pulumi.Input[_builtins.str]] = None, + efs_mount: Optional[pulumi.Input[_builtins.str]] = None, + fargate_head_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fsx_mount: Optional[pulumi.Input[_builtins.str]] = None, + fsx_name: Optional[pulumi.Input[_builtins.str]] = None, + fsx_size: Optional[pulumi.Input[_builtins.float]] = None, + fusion_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + max_cpus: Optional[pulumi.Input[_builtins.float]] = None, + min_cpus: Optional[pulumi.Input[_builtins.float]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + vpc_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + :param pulumi.Input[_builtins.str] type: must be one of ["SPOT", "EC2"] + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + return pulumi.get(self, "alloc_strategy") + + @alloc_strategy.setter + def alloc_strategy(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alloc_strategy", value) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "bid_percentage") + + @bid_percentage.setter + def bid_percentage(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "bid_percentage", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_ami_id") + + @dragen_ami_id.setter + def dragen_ami_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_ami_id", value) + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dragen_enabled") + + @dragen_enabled.setter + def dragen_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dragen_enabled", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "ebs_auto_scale") + + @ebs_auto_scale.setter + def ebs_auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ebs_auto_scale", value) + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_block_size") + + @ebs_block_size.setter + def ebs_block_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_block_size", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ecs_config") + + @ecs_config.setter + def ecs_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ecs_config", value) + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "efs_create") + + @efs_create.setter + def efs_create(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "efs_create", value) + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "efs_id") + + @efs_id.setter + def efs_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_id", value) + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "efs_mount") + + @efs_mount.setter + def efs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_mount", value) + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fargate_head_enabled") + + @fargate_head_enabled.setter + def fargate_head_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fargate_head_enabled", value) + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "fsx_mount") + + @fsx_mount.setter + def fsx_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_mount", value) + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "fsx_name") + + @fsx_name.setter + def fsx_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_name", value) + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "fsx_size") + + @fsx_size.setter + def fsx_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "fsx_size", value) + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion_enabled") + + @fusion_enabled.setter + def fusion_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "instance_types") + + @instance_types.setter + def instance_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "instance_types", value) + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_cpus") + + @max_cpus.setter + def max_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_cpus", value) + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "min_cpus") + + @min_cpus.setter + def min_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "min_cpus", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "subnets") + + @subnets.setter + def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "subnets", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["SPOT", "EC2"] + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "vpc_id") + + @vpc_id.setter + def vpc_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vpc_id", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSlurmPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigSlurmPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSlurmPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigUgePlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigUgePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigUgePlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvArgsDict(TypedDict): + config: pulumi.Input['ComputeEnvComputeEnvConfigArgsDict'] + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + """ + credentials_id: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + name: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + platform: pulumi.Input[_builtins.str] + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + """ + compute_env_id: NotRequired[pulumi.Input[_builtins.str]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + deleted: NotRequired[pulumi.Input[_builtins.bool]] + description: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvLabelArgsDict']]]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + last_used: NotRequired[pulumi.Input[_builtins.str]] + managed_identity_id: NotRequired[pulumi.Input[_builtins.str]] + message: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + org_id: NotRequired[pulumi.Input[_builtins.float]] + primary: NotRequired[pulumi.Input[_builtins.bool]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + workspace_id: NotRequired[pulumi.Input[_builtins.float]] +elif False: + ComputeEnvComputeEnvArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvArgs: + def __init__(__self__, *, + config: pulumi.Input['ComputeEnvComputeEnvConfigArgs'], + credentials_id: pulumi.Input[_builtins.str], + name: pulumi.Input[_builtins.str], + platform: pulumi.Input[_builtins.str], + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvLabelArgs']]]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + managed_identity_id: Optional[pulumi.Input[_builtins.str]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + primary: Optional[pulumi.Input[_builtins.bool]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + :param pulumi.Input['ComputeEnvComputeEnvConfigArgs'] config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + :param pulumi.Input[_builtins.str] credentials_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] platform: must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] message: Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "platform", platform) + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if managed_identity_id is not None: + pulumi.set(__self__, "managed_identity_id", managed_identity_id) + if message is not None: + pulumi.set(__self__, "message", message) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if primary is not None: + pulumi.set(__self__, "primary", primary) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def config(self) -> pulumi.Input['ComputeEnvComputeEnvConfigArgs']: + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + """ + return pulumi.get(self, "config") + + @config.setter + def config(self, value: pulumi.Input['ComputeEnvComputeEnvConfigArgs']): + pulumi.set(self, "config", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> pulumi.Input[_builtins.str]: + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + """ + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter(name="managedIdentityId") + def managed_identity_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "managed_identity_id") + + @managed_identity_id.setter + def managed_identity_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "managed_identity_id", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + def primary(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "primary") + + @primary.setter + def primary(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "primary", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigArgsDict(TypedDict): + altair_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgsDict']] + """ + Requires replacement if changed. + """ + aws_batch: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgsDict']] + """ + Requires replacement if changed. + """ + aws_cloud: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgsDict']] + """ + Requires replacement if changed. + """ + azure_batch: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgsDict']] + """ + Requires replacement if changed. + """ + eks_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgsDict']] + """ + Requires replacement if changed. + """ + gke_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgsDict']] + """ + Requires replacement if changed. + """ + google_batch: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgsDict']] + """ + Requires replacement if changed. + """ + google_lifesciences: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgsDict']] + """ + Requires replacement if changed. + """ + k8s_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgsDict']] + """ + Requires replacement if changed. + """ + lsf_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgsDict']] + """ + Requires replacement if changed. + """ + moab_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgsDict']] + """ + Requires replacement if changed. + """ + seqeracompute_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgsDict']] + """ + Requires replacement if changed. + """ + slurm_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgsDict']] + """ + Requires replacement if changed. + """ + uge_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgsDict']] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigArgs: + def __init__(__self__, *, + altair_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgs']] = None, + aws_batch: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgs']] = None, + aws_cloud: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgs']] = None, + azure_batch: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgs']] = None, + eks_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgs']] = None, + gke_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgs']] = None, + google_batch: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgs']] = None, + google_lifesciences: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgs']] = None, + k8s_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgs']] = None, + lsf_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgs']] = None, + moab_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgs']] = None, + seqeracompute_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs']] = None, + slurm_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgs']] = None, + uge_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgs']] = None): + """ + :param pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgs'] altair_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgs'] aws_batch: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgs'] aws_cloud: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgs'] azure_batch: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgs'] eks_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgs'] gke_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgs'] google_batch: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgs'] google_lifesciences: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgs'] k8s_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgs'] lsf_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgs'] moab_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs'] seqeracompute_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgs'] slurm_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgs'] uge_platform: Requires replacement if changed. + """ + if altair_platform is not None: + pulumi.set(__self__, "altair_platform", altair_platform) + if aws_batch is not None: + pulumi.set(__self__, "aws_batch", aws_batch) + if aws_cloud is not None: + pulumi.set(__self__, "aws_cloud", aws_cloud) + if azure_batch is not None: + pulumi.set(__self__, "azure_batch", azure_batch) + if eks_platform is not None: + pulumi.set(__self__, "eks_platform", eks_platform) + if gke_platform is not None: + pulumi.set(__self__, "gke_platform", gke_platform) + if google_batch is not None: + pulumi.set(__self__, "google_batch", google_batch) + if google_lifesciences is not None: + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + if k8s_platform is not None: + pulumi.set(__self__, "k8s_platform", k8s_platform) + if lsf_platform is not None: + pulumi.set(__self__, "lsf_platform", lsf_platform) + if moab_platform is not None: + pulumi.set(__self__, "moab_platform", moab_platform) + if seqeracompute_platform is not None: + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + if slurm_platform is not None: + pulumi.set(__self__, "slurm_platform", slurm_platform) + if uge_platform is not None: + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "altair_platform") + + @altair_platform.setter + def altair_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgs']]): + pulumi.set(self, "altair_platform", value) + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "aws_batch") + + @aws_batch.setter + def aws_batch(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgs']]): + pulumi.set(self, "aws_batch", value) + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "aws_cloud") + + @aws_cloud.setter + def aws_cloud(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgs']]): + pulumi.set(self, "aws_cloud", value) + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "azure_batch") + + @azure_batch.setter + def azure_batch(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgs']]): + pulumi.set(self, "azure_batch", value) + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "eks_platform") + + @eks_platform.setter + def eks_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgs']]): + pulumi.set(self, "eks_platform", value) + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gke_platform") + + @gke_platform.setter + def gke_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgs']]): + pulumi.set(self, "gke_platform", value) + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "google_batch") + + @google_batch.setter + def google_batch(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgs']]): + pulumi.set(self, "google_batch", value) + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "google_lifesciences") + + @google_lifesciences.setter + def google_lifesciences(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgs']]): + pulumi.set(self, "google_lifesciences", value) + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "k8s_platform") + + @k8s_platform.setter + def k8s_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgs']]): + pulumi.set(self, "k8s_platform", value) + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lsf_platform") + + @lsf_platform.setter + def lsf_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgs']]): + pulumi.set(self, "lsf_platform", value) + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "moab_platform") + + @moab_platform.setter + def moab_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgs']]): + pulumi.set(self, "moab_platform", value) + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "seqeracompute_platform") + + @seqeracompute_platform.setter + def seqeracompute_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs']]): + pulumi.set(self, "seqeracompute_platform", value) + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "slurm_platform") + + @slurm_platform.setter + def slurm_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgs']]): + pulumi.set(self, "slurm_platform", value) + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "uge_platform") + + @uge_platform.setter + def uge_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgs']]): + pulumi.set(self, "uge_platform", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAltairPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAltairPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAltairPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsBatchArgsDict(TypedDict): + cli_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + compute_job_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + execution_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + forge: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgsDict']] + """ + Not Null; Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + fusion_snapshots: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + log_group: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + lustre_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + nvnme_storage_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsBatchArgs: + def __init__(__self__, *, + cli_path: Optional[pulumi.Input[_builtins.str]] = None, + compute_job_role: Optional[pulumi.Input[_builtins.str]] = None, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + dragen_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs']]]] = None, + execution_role: Optional[pulumi.Input[_builtins.str]] = None, + forge: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fusion_snapshots: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_job_role: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + lustre_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nvnme_storage_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + storage_type: Optional[pulumi.Input[_builtins.str]] = None, + volumes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cli_path: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_job_role: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] execution_role: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgs'] forge: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion_snapshots: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_role: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] log_group: Requires replacement if changed. + :param pulumi.Input[_builtins.str] lustre_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] nvnme_storage_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_type: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] volumes: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""lustre_id is deprecated: Deprecated""") + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""storage_type is deprecated: Deprecated""") + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cli_path") + + @cli_path.setter + def cli_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cli_path", value) + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_job_role") + + @compute_job_role.setter + def compute_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_job_role", value) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_queue") + + @dragen_queue.setter + def dragen_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "execution_role") + + @execution_role.setter + def execution_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "execution_role", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgs']]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_snapshots") + + @fusion_snapshots.setter + def fusion_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_snapshots", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_role") + + @head_job_role.setter + def head_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_role", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lustre_id") + + @lustre_id.setter + def lustre_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "lustre_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nvnme_storage_enabled") + + @nvnme_storage_enabled.setter + def nvnme_storage_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "nvnme_storage_enabled", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_type") + + @storage_type.setter + def storage_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_type", value) + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "volumes") + + @volumes.setter + def volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "volumes", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsBatchForgeArgsDict(TypedDict): + alloc_strategy: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + bid_percentage: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + dragen_ami_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ebs_auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ebs_block_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ecs_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + efs_create: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + efs_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + efs_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fargate_head_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + fsx_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fsx_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fsx_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + fusion_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + image_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + max_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + min_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + type: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + vpc_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsBatchForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsBatchForgeArgs: + def __init__(__self__, *, + alloc_strategy: Optional[pulumi.Input[_builtins.str]] = None, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + bid_percentage: Optional[pulumi.Input[_builtins.float]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_ami_id: Optional[pulumi.Input[_builtins.str]] = None, + dragen_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + ebs_auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_block_size: Optional[pulumi.Input[_builtins.float]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + ecs_config: Optional[pulumi.Input[_builtins.str]] = None, + efs_create: Optional[pulumi.Input[_builtins.bool]] = None, + efs_id: Optional[pulumi.Input[_builtins.str]] = None, + efs_mount: Optional[pulumi.Input[_builtins.str]] = None, + fargate_head_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fsx_mount: Optional[pulumi.Input[_builtins.str]] = None, + fsx_name: Optional[pulumi.Input[_builtins.str]] = None, + fsx_size: Optional[pulumi.Input[_builtins.float]] = None, + fusion_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + max_cpus: Optional[pulumi.Input[_builtins.float]] = None, + min_cpus: Optional[pulumi.Input[_builtins.float]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + vpc_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_buckets: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] arm64_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] bid_percentage: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dispose_on_deletion: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_ami_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dragen_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] ebs_auto_scale: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_block_size: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_boot_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ec2_key_pair: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ecs_config: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] efs_create: Requires replacement if changed. + :param pulumi.Input[_builtins.str] efs_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] efs_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fargate_head_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] fsx_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.str] fsx_name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] fsx_size: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] gpu_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] image_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_cpus: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.float] min_cpus: Not Null; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] type: Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] vpc_id: Requires replacement if changed. + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + return pulumi.get(self, "alloc_strategy") + + @alloc_strategy.setter + def alloc_strategy(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alloc_strategy", value) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "bid_percentage") + + @bid_percentage.setter + def bid_percentage(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "bid_percentage", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_ami_id") + + @dragen_ami_id.setter + def dragen_ami_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_ami_id", value) + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_enabled") + + @dragen_enabled.setter + def dragen_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dragen_enabled", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_auto_scale") + + @ebs_auto_scale.setter + def ebs_auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ebs_auto_scale", value) + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_block_size") + + @ebs_block_size.setter + def ebs_block_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_block_size", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ecs_config") + + @ecs_config.setter + def ecs_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ecs_config", value) + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_create") + + @efs_create.setter + def efs_create(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "efs_create", value) + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_id") + + @efs_id.setter + def efs_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_id", value) + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_mount") + + @efs_mount.setter + def efs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_mount", value) + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fargate_head_enabled") + + @fargate_head_enabled.setter + def fargate_head_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fargate_head_enabled", value) + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_mount") + + @fsx_mount.setter + def fsx_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_mount", value) + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_name") + + @fsx_name.setter + def fsx_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_name", value) + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_size") + + @fsx_size.setter + def fsx_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "fsx_size", value) + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_enabled") + + @fusion_enabled.setter + def fusion_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_types") + + @instance_types.setter + def instance_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "instance_types", value) + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "max_cpus") + + @max_cpus.setter + def max_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_cpus", value) + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "min_cpus") + + @min_cpus.setter + def min_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "min_cpus", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnets") + + @subnets.setter + def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "subnets", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vpc_id") + + @vpc_id.setter + def vpc_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vpc_id", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsCloudArgsDict(TypedDict): + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + image_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + instance_profile_arn: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + log_group: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + subnet_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsCloudArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsCloudArgs: + def __init__(__self__, *, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_profile_arn: Optional[pulumi.Input[_builtins.str]] = None, + instance_type: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnet_id: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_buckets: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] arm64_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_boot_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ec2_key_pair: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] gpu_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] image_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] instance_profile_arn: Requires replacement if changed. + :param pulumi.Input[_builtins.str] instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.str] log_group: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Not Null; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: Requires replacement if changed. + :param pulumi.Input[_builtins.str] subnet_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_profile_arn is not None: + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + if instance_type is not None: + pulumi.set(__self__, "instance_type", instance_type) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnet_id is not None: + pulumi.set(__self__, "subnet_id", subnet_id) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_profile_arn") + + @instance_profile_arn.setter + def instance_profile_arn(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_profile_arn", value) + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_type") + + @instance_type.setter + def instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_type", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnet_id") + + @subnet_id.setter + def subnet_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "subnet_id", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAzureBatchArgsDict(TypedDict): + auto_pool_mode: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + delete_jobs_on_completion: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + delete_pools_on_completion: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + forge: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgsDict']] + """ + Not Null; Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_pool: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + managed_identity_client_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + token_duration: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAzureBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAzureBatchArgs: + def __init__(__self__, *, + auto_pool_mode: Optional[pulumi.Input[_builtins.bool]] = None, + delete_jobs_on_completion: Optional[pulumi.Input[_builtins.str]] = None, + delete_pools_on_completion: Optional[pulumi.Input[_builtins.bool]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs']]]] = None, + forge: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_pool: Optional[pulumi.Input[_builtins.str]] = None, + managed_identity_client_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + token_duration: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] auto_pool_mode: Requires replacement if changed. + :param pulumi.Input[_builtins.str] delete_jobs_on_completion: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] delete_pools_on_completion: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgs'] forge: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_pool: Requires replacement if changed. + :param pulumi.Input[_builtins.str] managed_identity_client_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] token_duration: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if auto_pool_mode is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""auto_pool_mode is deprecated: Deprecated""") + if auto_pool_mode is not None: + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + if delete_jobs_on_completion is not None: + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + if delete_pools_on_completion is not None: + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_pool is not None: + pulumi.set(__self__, "head_pool", head_pool) + if managed_identity_client_id is not None: + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if token_duration is not None: + pulumi.set(__self__, "token_duration", token_duration) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "auto_pool_mode") + + @auto_pool_mode.setter + def auto_pool_mode(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_pool_mode", value) + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "delete_jobs_on_completion") + + @delete_jobs_on_completion.setter + def delete_jobs_on_completion(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "delete_jobs_on_completion", value) + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "delete_pools_on_completion") + + @delete_pools_on_completion.setter + def delete_pools_on_completion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "delete_pools_on_completion", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgs']]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pool") + + @head_pool.setter + def head_pool(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pool", value) + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "managed_identity_client_id") + + @managed_identity_client_id.setter + def managed_identity_client_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "managed_identity_client_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "token_duration") + + @token_duration.setter + def token_duration(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "token_duration", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAzureBatchForgeArgsDict(TypedDict): + auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + container_reg_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + vm_count: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + vm_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAzureBatchForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAzureBatchForgeArgs: + def __init__(__self__, *, + auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + container_reg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + vm_count: Optional[pulumi.Input[_builtins.float]] = None, + vm_type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] auto_scale: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] container_reg_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dispose_on_deletion: Requires replacement if changed. + :param pulumi.Input[_builtins.float] vm_count: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] vm_type: Requires replacement if changed. + """ + if auto_scale is not None: + pulumi.set(__self__, "auto_scale", auto_scale) + if container_reg_ids is not None: + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if vm_count is not None: + pulumi.set(__self__, "vm_count", vm_count) + if vm_type is not None: + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "auto_scale") + + @auto_scale.setter + def auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_scale", value) + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "container_reg_ids") + + @container_reg_ids.setter + def container_reg_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "container_reg_ids", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "vm_count") + + @vm_count.setter + def vm_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "vm_count", value) + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vm_type") + + @vm_type.setter + def vm_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vm_type", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigEksPlatformArgsDict(TypedDict): + cluster_name: NotRequired[pulumi.Input[_builtins.str]] + """ + The AWS EKS cluster name. Not Null; Requires replacement if changed. + """ + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + namespace: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + AWS region. Not Null; Requires replacement if changed. + """ + server: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigEksPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigEksPlatformArgs: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[_builtins.str]] = None, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cluster_name: The AWS EKS cluster name. Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_service_account: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_service_account: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] namespace: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: AWS region. Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] server: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] service_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssl_cert: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_claim_name: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_mount_path: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The AWS EKS cluster name. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + AWS region. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGkePlatformArgsDict(TypedDict): + cluster_name: NotRequired[pulumi.Input[_builtins.str]] + """ + The GKE cluster name. Not Null; Requires replacement if changed. + """ + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + namespace: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + """ + server: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGkePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGkePlatformArgs: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[_builtins.str]] = None, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cluster_name: The GKE cluster name. Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_service_account: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_service_account: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] namespace: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] server: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] service_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssl_cert: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_claim_name: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_mount_path: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The GKE cluster name. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGoogleBatchArgsDict(TypedDict): + boot_disk_size_gb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + compute_jobs_instance_template: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + copy_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + cpu_platform: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + debug_mode: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_instance_template: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + location: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + machine_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + network: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + nfs_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nfs_target: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + project_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + spot: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ssh_daemon: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ssh_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + subnetwork: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + use_private_address: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGoogleBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGoogleBatchArgs: + def __init__(__self__, *, + boot_disk_size_gb: Optional[pulumi.Input[_builtins.float]] = None, + compute_jobs_instance_template: Optional[pulumi.Input[_builtins.str]] = None, + copy_image: Optional[pulumi.Input[_builtins.str]] = None, + cpu_platform: Optional[pulumi.Input[_builtins.str]] = None, + debug_mode: Optional[pulumi.Input[_builtins.float]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_instance_template: Optional[pulumi.Input[_builtins.str]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + machine_type: Optional[pulumi.Input[_builtins.str]] = None, + network: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nfs_mount: Optional[pulumi.Input[_builtins.str]] = None, + nfs_target: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + project_id: Optional[pulumi.Input[_builtins.str]] = None, + service_account: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_daemon: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_image: Optional[pulumi.Input[_builtins.str]] = None, + subnetwork: Optional[pulumi.Input[_builtins.str]] = None, + use_private_address: Optional[pulumi.Input[_builtins.bool]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.float] boot_disk_size_gb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_jobs_instance_template: Requires replacement if changed. + :param pulumi.Input[_builtins.str] copy_image: Requires replacement if changed. + :param pulumi.Input[_builtins.str] cpu_platform: Requires replacement if changed. + :param pulumi.Input[_builtins.float] debug_mode: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_instance_template: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: Requires replacement if changed. + :param pulumi.Input[_builtins.str] location: Requires replacement if changed. + :param pulumi.Input[_builtins.str] machine_type: Requires replacement if changed. + :param pulumi.Input[_builtins.str] network: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] nfs_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nfs_target: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] project_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] service_account: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] ssh_daemon: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssh_image: Requires replacement if changed. + :param pulumi.Input[_builtins.str] subnetwork: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] use_private_address: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if compute_jobs_instance_template is not None: + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if cpu_platform is not None: + pulumi.set(__self__, "cpu_platform", cpu_platform) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_instance_template is not None: + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if network is not None: + pulumi.set(__self__, "network", network) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if subnetwork is not None: + pulumi.set(__self__, "subnetwork", subnetwork) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "boot_disk_size_gb") + + @boot_disk_size_gb.setter + def boot_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "boot_disk_size_gb", value) + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_jobs_instance_template") + + @compute_jobs_instance_template.setter + def compute_jobs_instance_template(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_jobs_instance_template", value) + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "copy_image") + + @copy_image.setter + def copy_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "copy_image", value) + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cpu_platform") + + @cpu_platform.setter + def cpu_platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cpu_platform", value) + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "debug_mode") + + @debug_mode.setter + def debug_mode(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "debug_mode", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_instance_template") + + @head_job_instance_template.setter + def head_job_instance_template(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_instance_template", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "machine_type") + + @machine_type.setter + def machine_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "machine_type", value) + + @_builtins.property + @pulumi.getter + def network(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "network") + + @network.setter + def network(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "network", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_mount") + + @nfs_mount.setter + def nfs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_mount", value) + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_target") + + @nfs_target.setter + def nfs_target(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_target", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_id", value) + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_account") + + @service_account.setter + def service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_account", value) + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @spot.setter + def spot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "spot", value) + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_daemon") + + @ssh_daemon.setter + def ssh_daemon(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ssh_daemon", value) + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_image") + + @ssh_image.setter + def ssh_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssh_image", value) + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnetwork") + + @subnetwork.setter + def subnetwork(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "subnetwork", value) + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "use_private_address") + + @use_private_address.setter + def use_private_address(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_private_address", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGoogleLifesciencesArgsDict(TypedDict): + boot_disk_size_gb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + copy_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + debug_mode: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + location: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + nfs_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nfs_target: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + preemptible: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + project_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ssh_daemon: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ssh_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + use_private_address: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGoogleLifesciencesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGoogleLifesciencesArgs: + def __init__(__self__, *, + boot_disk_size_gb: Optional[pulumi.Input[_builtins.float]] = None, + copy_image: Optional[pulumi.Input[_builtins.str]] = None, + debug_mode: Optional[pulumi.Input[_builtins.float]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nfs_mount: Optional[pulumi.Input[_builtins.str]] = None, + nfs_target: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + preemptible: Optional[pulumi.Input[_builtins.bool]] = None, + project_id: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + ssh_daemon: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_image: Optional[pulumi.Input[_builtins.str]] = None, + use_private_address: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.float] boot_disk_size_gb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] copy_image: Requires replacement if changed. + :param pulumi.Input[_builtins.float] debug_mode: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: Requires replacement if changed. + :param pulumi.Input[_builtins.str] location: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] nfs_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nfs_target: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] preemptible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] project_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] ssh_daemon: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssh_image: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] use_private_address: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] zones: Requires replacement if changed. + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if preemptible is not None: + pulumi.set(__self__, "preemptible", preemptible) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "boot_disk_size_gb") + + @boot_disk_size_gb.setter + def boot_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "boot_disk_size_gb", value) + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "copy_image") + + @copy_image.setter + def copy_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "copy_image", value) + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "debug_mode") + + @debug_mode.setter + def debug_mode(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "debug_mode", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_mount") + + @nfs_mount.setter + def nfs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_mount", value) + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_target") + + @nfs_target.setter + def nfs_target(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_target", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def preemptible(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "preemptible") + + @preemptible.setter + def preemptible(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "preemptible", value) + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_id", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_daemon") + + @ssh_daemon.setter + def ssh_daemon(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ssh_daemon", value) + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_image") + + @ssh_image.setter + def ssh_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssh_image", value) + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "use_private_address") + + @use_private_address.setter + def use_private_address(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_private_address", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter + def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "zones") + + @zones.setter + def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "zones", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigK8sPlatformArgsDict(TypedDict): + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + namespace: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + server: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigK8sPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigK8sPlatformArgs: + def __init__(__self__, *, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs']]]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_service_account: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_service_account: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] namespace: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] server: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] service_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssl_cert: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_claim_name: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_mount_path: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigLsfPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + per_job_mem_limit: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + per_task_reserve: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + unit_for_limits: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigLsfPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigLsfPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + per_job_mem_limit: Optional[pulumi.Input[_builtins.bool]] = None, + per_task_reserve: Optional[pulumi.Input[_builtins.bool]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + unit_for_limits: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] per_job_mem_limit: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] per_task_reserve: Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] unit_for_limits: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if per_job_mem_limit is not None: + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + if per_task_reserve is not None: + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if unit_for_limits is not None: + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "per_job_mem_limit") + + @per_job_mem_limit.setter + def per_job_mem_limit(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "per_job_mem_limit", value) + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "per_task_reserve") + + @per_task_reserve.setter + def per_task_reserve(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "per_task_reserve", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "unit_for_limits") + + @unit_for_limits.setter + def unit_for_limits(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "unit_for_limits", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigMoabPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigMoabPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigMoabPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSeqeracomputePlatformArgsDict(TypedDict): + cli_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + compute_job_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + execution_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + forge: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgsDict']] + """ + Not Null; Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + fusion_snapshots: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + log_group: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + lustre_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + nvnme_storage_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSeqeracomputePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs: + def __init__(__self__, *, + cli_path: Optional[pulumi.Input[_builtins.str]] = None, + compute_job_role: Optional[pulumi.Input[_builtins.str]] = None, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + dragen_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]] = None, + execution_role: Optional[pulumi.Input[_builtins.str]] = None, + forge: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fusion_snapshots: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_job_role: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + lustre_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nvnme_storage_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + storage_type: Optional[pulumi.Input[_builtins.str]] = None, + volumes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cli_path: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_job_role: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] execution_role: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs'] forge: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion_snapshots: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_role: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] log_group: Requires replacement if changed. + :param pulumi.Input[_builtins.str] lustre_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] nvnme_storage_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_type: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] volumes: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""lustre_id is deprecated: Deprecated""") + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""storage_type is deprecated: Deprecated""") + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cli_path") + + @cli_path.setter + def cli_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cli_path", value) + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_job_role") + + @compute_job_role.setter + def compute_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_job_role", value) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_queue") + + @dragen_queue.setter + def dragen_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "execution_role") + + @execution_role.setter + def execution_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "execution_role", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs']]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_snapshots") + + @fusion_snapshots.setter + def fusion_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_snapshots", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_role") + + @head_job_role.setter + def head_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_role", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lustre_id") + + @lustre_id.setter + def lustre_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "lustre_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nvnme_storage_enabled") + + @nvnme_storage_enabled.setter + def nvnme_storage_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "nvnme_storage_enabled", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_type") + + @storage_type.setter + def storage_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_type", value) + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "volumes") + + @volumes.setter + def volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "volumes", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgsDict(TypedDict): + alloc_strategy: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + bid_percentage: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + dragen_ami_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ebs_auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ebs_block_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ecs_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + efs_create: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + efs_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + efs_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fargate_head_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + fsx_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fsx_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fsx_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + fusion_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + image_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + max_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + min_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + type: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + vpc_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs: + def __init__(__self__, *, + alloc_strategy: Optional[pulumi.Input[_builtins.str]] = None, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + bid_percentage: Optional[pulumi.Input[_builtins.float]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_ami_id: Optional[pulumi.Input[_builtins.str]] = None, + dragen_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + ebs_auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_block_size: Optional[pulumi.Input[_builtins.float]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + ecs_config: Optional[pulumi.Input[_builtins.str]] = None, + efs_create: Optional[pulumi.Input[_builtins.bool]] = None, + efs_id: Optional[pulumi.Input[_builtins.str]] = None, + efs_mount: Optional[pulumi.Input[_builtins.str]] = None, + fargate_head_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fsx_mount: Optional[pulumi.Input[_builtins.str]] = None, + fsx_name: Optional[pulumi.Input[_builtins.str]] = None, + fsx_size: Optional[pulumi.Input[_builtins.float]] = None, + fusion_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + max_cpus: Optional[pulumi.Input[_builtins.float]] = None, + min_cpus: Optional[pulumi.Input[_builtins.float]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + vpc_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_buckets: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] arm64_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] bid_percentage: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dispose_on_deletion: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_ami_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dragen_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] ebs_auto_scale: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_block_size: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_boot_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ec2_key_pair: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ecs_config: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] efs_create: Requires replacement if changed. + :param pulumi.Input[_builtins.str] efs_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] efs_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fargate_head_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] fsx_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.str] fsx_name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] fsx_size: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] gpu_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] image_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_cpus: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.float] min_cpus: Not Null; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] type: Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] vpc_id: Requires replacement if changed. + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + return pulumi.get(self, "alloc_strategy") + + @alloc_strategy.setter + def alloc_strategy(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alloc_strategy", value) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "bid_percentage") + + @bid_percentage.setter + def bid_percentage(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "bid_percentage", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_ami_id") + + @dragen_ami_id.setter + def dragen_ami_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_ami_id", value) + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_enabled") + + @dragen_enabled.setter + def dragen_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dragen_enabled", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_auto_scale") + + @ebs_auto_scale.setter + def ebs_auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ebs_auto_scale", value) + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_block_size") + + @ebs_block_size.setter + def ebs_block_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_block_size", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ecs_config") + + @ecs_config.setter + def ecs_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ecs_config", value) + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_create") + + @efs_create.setter + def efs_create(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "efs_create", value) + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_id") + + @efs_id.setter + def efs_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_id", value) + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_mount") + + @efs_mount.setter + def efs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_mount", value) + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fargate_head_enabled") + + @fargate_head_enabled.setter + def fargate_head_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fargate_head_enabled", value) + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_mount") + + @fsx_mount.setter + def fsx_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_mount", value) + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_name") + + @fsx_name.setter + def fsx_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_name", value) + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_size") + + @fsx_size.setter + def fsx_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "fsx_size", value) + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_enabled") + + @fusion_enabled.setter + def fusion_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_types") + + @instance_types.setter + def instance_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "instance_types", value) + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "max_cpus") + + @max_cpus.setter + def max_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_cpus", value) + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "min_cpus") + + @min_cpus.setter + def min_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "min_cpus", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnets") + + @subnets.setter + def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "subnets", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vpc_id") + + @vpc_id.setter + def vpc_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vpc_id", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSlurmPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSlurmPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSlurmPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigUgePlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigUgePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigUgePlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + ComputeEnvComputeEnvLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class CredentialKeysArgsDict(TypedDict): + aws: NotRequired[pulumi.Input['CredentialKeysAwsArgsDict']] + azure: NotRequired[pulumi.Input['CredentialKeysAzureArgsDict']] + azure_entra: NotRequired[pulumi.Input['CredentialKeysAzureEntraArgsDict']] + azurerepos: NotRequired[pulumi.Input['CredentialKeysAzurereposArgsDict']] + bitbucket: NotRequired[pulumi.Input['CredentialKeysBitbucketArgsDict']] + codecommit: NotRequired[pulumi.Input['CredentialKeysCodecommitArgsDict']] + container_reg: NotRequired[pulumi.Input['CredentialKeysContainerRegArgsDict']] + gitea: NotRequired[pulumi.Input['CredentialKeysGiteaArgsDict']] + github: NotRequired[pulumi.Input['CredentialKeysGithubArgsDict']] + gitlab: NotRequired[pulumi.Input['CredentialKeysGitlabArgsDict']] + google: NotRequired[pulumi.Input['CredentialKeysGoogleArgsDict']] + k8s: NotRequired[pulumi.Input['CredentialKeysK8sArgsDict']] + seqeracompute: NotRequired[pulumi.Input['CredentialKeysSeqeracomputeArgsDict']] + ssh: NotRequired[pulumi.Input['CredentialKeysSshArgsDict']] + tw_agent: NotRequired[pulumi.Input['CredentialKeysTwAgentArgsDict']] +elif False: + CredentialKeysArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysArgs: + def __init__(__self__, *, + aws: Optional[pulumi.Input['CredentialKeysAwsArgs']] = None, + azure: Optional[pulumi.Input['CredentialKeysAzureArgs']] = None, + azure_entra: Optional[pulumi.Input['CredentialKeysAzureEntraArgs']] = None, + azurerepos: Optional[pulumi.Input['CredentialKeysAzurereposArgs']] = None, + bitbucket: Optional[pulumi.Input['CredentialKeysBitbucketArgs']] = None, + codecommit: Optional[pulumi.Input['CredentialKeysCodecommitArgs']] = None, + container_reg: Optional[pulumi.Input['CredentialKeysContainerRegArgs']] = None, + gitea: Optional[pulumi.Input['CredentialKeysGiteaArgs']] = None, + github: Optional[pulumi.Input['CredentialKeysGithubArgs']] = None, + gitlab: Optional[pulumi.Input['CredentialKeysGitlabArgs']] = None, + google: Optional[pulumi.Input['CredentialKeysGoogleArgs']] = None, + k8s: Optional[pulumi.Input['CredentialKeysK8sArgs']] = None, + seqeracompute: Optional[pulumi.Input['CredentialKeysSeqeracomputeArgs']] = None, + ssh: Optional[pulumi.Input['CredentialKeysSshArgs']] = None, + tw_agent: Optional[pulumi.Input['CredentialKeysTwAgentArgs']] = None): + if aws is not None: + pulumi.set(__self__, "aws", aws) + if azure is not None: + pulumi.set(__self__, "azure", azure) + if azure_entra is not None: + pulumi.set(__self__, "azure_entra", azure_entra) + if azurerepos is not None: + pulumi.set(__self__, "azurerepos", azurerepos) + if bitbucket is not None: + pulumi.set(__self__, "bitbucket", bitbucket) + if codecommit is not None: + pulumi.set(__self__, "codecommit", codecommit) + if container_reg is not None: + pulumi.set(__self__, "container_reg", container_reg) + if gitea is not None: + pulumi.set(__self__, "gitea", gitea) + if github is not None: + pulumi.set(__self__, "github", github) + if gitlab is not None: + pulumi.set(__self__, "gitlab", gitlab) + if google is not None: + pulumi.set(__self__, "google", google) + if k8s is not None: + pulumi.set(__self__, "k8s", k8s) + if seqeracompute is not None: + pulumi.set(__self__, "seqeracompute", seqeracompute) + if ssh is not None: + pulumi.set(__self__, "ssh", ssh) + if tw_agent is not None: + pulumi.set(__self__, "tw_agent", tw_agent) + + @_builtins.property + @pulumi.getter + def aws(self) -> Optional[pulumi.Input['CredentialKeysAwsArgs']]: + return pulumi.get(self, "aws") + + @aws.setter + def aws(self, value: Optional[pulumi.Input['CredentialKeysAwsArgs']]): + pulumi.set(self, "aws", value) + + @_builtins.property + @pulumi.getter + def azure(self) -> Optional[pulumi.Input['CredentialKeysAzureArgs']]: + return pulumi.get(self, "azure") + + @azure.setter + def azure(self, value: Optional[pulumi.Input['CredentialKeysAzureArgs']]): + pulumi.set(self, "azure", value) + + @_builtins.property + @pulumi.getter(name="azureEntra") + def azure_entra(self) -> Optional[pulumi.Input['CredentialKeysAzureEntraArgs']]: + return pulumi.get(self, "azure_entra") + + @azure_entra.setter + def azure_entra(self, value: Optional[pulumi.Input['CredentialKeysAzureEntraArgs']]): + pulumi.set(self, "azure_entra", value) + + @_builtins.property + @pulumi.getter + def azurerepos(self) -> Optional[pulumi.Input['CredentialKeysAzurereposArgs']]: + return pulumi.get(self, "azurerepos") + + @azurerepos.setter + def azurerepos(self, value: Optional[pulumi.Input['CredentialKeysAzurereposArgs']]): + pulumi.set(self, "azurerepos", value) + + @_builtins.property + @pulumi.getter + def bitbucket(self) -> Optional[pulumi.Input['CredentialKeysBitbucketArgs']]: + return pulumi.get(self, "bitbucket") + + @bitbucket.setter + def bitbucket(self, value: Optional[pulumi.Input['CredentialKeysBitbucketArgs']]): + pulumi.set(self, "bitbucket", value) + + @_builtins.property + @pulumi.getter + def codecommit(self) -> Optional[pulumi.Input['CredentialKeysCodecommitArgs']]: + return pulumi.get(self, "codecommit") + + @codecommit.setter + def codecommit(self, value: Optional[pulumi.Input['CredentialKeysCodecommitArgs']]): + pulumi.set(self, "codecommit", value) + + @_builtins.property + @pulumi.getter(name="containerReg") + def container_reg(self) -> Optional[pulumi.Input['CredentialKeysContainerRegArgs']]: + return pulumi.get(self, "container_reg") + + @container_reg.setter + def container_reg(self, value: Optional[pulumi.Input['CredentialKeysContainerRegArgs']]): + pulumi.set(self, "container_reg", value) + + @_builtins.property + @pulumi.getter + def gitea(self) -> Optional[pulumi.Input['CredentialKeysGiteaArgs']]: + return pulumi.get(self, "gitea") + + @gitea.setter + def gitea(self, value: Optional[pulumi.Input['CredentialKeysGiteaArgs']]): + pulumi.set(self, "gitea", value) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional[pulumi.Input['CredentialKeysGithubArgs']]: + return pulumi.get(self, "github") + + @github.setter + def github(self, value: Optional[pulumi.Input['CredentialKeysGithubArgs']]): + pulumi.set(self, "github", value) + + @_builtins.property + @pulumi.getter + def gitlab(self) -> Optional[pulumi.Input['CredentialKeysGitlabArgs']]: + return pulumi.get(self, "gitlab") + + @gitlab.setter + def gitlab(self, value: Optional[pulumi.Input['CredentialKeysGitlabArgs']]): + pulumi.set(self, "gitlab", value) + + @_builtins.property + @pulumi.getter + def google(self) -> Optional[pulumi.Input['CredentialKeysGoogleArgs']]: + return pulumi.get(self, "google") + + @google.setter + def google(self, value: Optional[pulumi.Input['CredentialKeysGoogleArgs']]): + pulumi.set(self, "google", value) + + @_builtins.property + @pulumi.getter + def k8s(self) -> Optional[pulumi.Input['CredentialKeysK8sArgs']]: + return pulumi.get(self, "k8s") + + @k8s.setter + def k8s(self, value: Optional[pulumi.Input['CredentialKeysK8sArgs']]): + pulumi.set(self, "k8s", value) + + @_builtins.property + @pulumi.getter + def seqeracompute(self) -> Optional[pulumi.Input['CredentialKeysSeqeracomputeArgs']]: + return pulumi.get(self, "seqeracompute") + + @seqeracompute.setter + def seqeracompute(self, value: Optional[pulumi.Input['CredentialKeysSeqeracomputeArgs']]): + pulumi.set(self, "seqeracompute", value) + + @_builtins.property + @pulumi.getter + def ssh(self) -> Optional[pulumi.Input['CredentialKeysSshArgs']]: + return pulumi.get(self, "ssh") + + @ssh.setter + def ssh(self, value: Optional[pulumi.Input['CredentialKeysSshArgs']]): + pulumi.set(self, "ssh", value) + + @_builtins.property + @pulumi.getter(name="twAgent") + def tw_agent(self) -> Optional[pulumi.Input['CredentialKeysTwAgentArgs']]: + return pulumi.get(self, "tw_agent") + + @tw_agent.setter + def tw_agent(self, value: Optional[pulumi.Input['CredentialKeysTwAgentArgs']]): + pulumi.set(self, "tw_agent", value) + + +if not MYPY: + class CredentialKeysAwsArgsDict(TypedDict): + access_key: NotRequired[pulumi.Input[_builtins.str]] + assume_role_arn: NotRequired[pulumi.Input[_builtins.str]] + secret_key: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysAwsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysAwsArgs: + def __init__(__self__, *, + access_key: Optional[pulumi.Input[_builtins.str]] = None, + assume_role_arn: Optional[pulumi.Input[_builtins.str]] = None, + secret_key: Optional[pulumi.Input[_builtins.str]] = None): + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if assume_role_arn is not None: + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "access_key") + + @access_key.setter + def access_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "access_key", value) + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "assume_role_arn") + + @assume_role_arn.setter + def assume_role_arn(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "assume_role_arn", value) + + @_builtins.property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "secret_key") + + @secret_key.setter + def secret_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "secret_key", value) + + +if not MYPY: + class CredentialKeysAzureArgsDict(TypedDict): + batch_key: NotRequired[pulumi.Input[_builtins.str]] + batch_name: NotRequired[pulumi.Input[_builtins.str]] + storage_key: NotRequired[pulumi.Input[_builtins.str]] + storage_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysAzureArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysAzureArgs: + def __init__(__self__, *, + batch_key: Optional[pulumi.Input[_builtins.str]] = None, + batch_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_key: Optional[pulumi.Input[_builtins.str]] = None, + storage_name: Optional[pulumi.Input[_builtins.str]] = None): + if batch_key is not None: + pulumi.set(__self__, "batch_key", batch_key) + if batch_name is not None: + pulumi.set(__self__, "batch_name", batch_name) + if storage_key is not None: + pulumi.set(__self__, "storage_key", storage_key) + if storage_name is not None: + pulumi.set(__self__, "storage_name", storage_name) + + @_builtins.property + @pulumi.getter(name="batchKey") + def batch_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "batch_key") + + @batch_key.setter + def batch_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "batch_key", value) + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "batch_name") + + @batch_name.setter + def batch_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "batch_name", value) + + @_builtins.property + @pulumi.getter(name="storageKey") + def storage_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_key") + + @storage_key.setter + def storage_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_key", value) + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_name") + + @storage_name.setter + def storage_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_name", value) + + +if not MYPY: + class CredentialKeysAzureEntraArgsDict(TypedDict): + batch_key: NotRequired[pulumi.Input[_builtins.str]] + batch_name: NotRequired[pulumi.Input[_builtins.str]] + client_id: NotRequired[pulumi.Input[_builtins.str]] + client_secret: NotRequired[pulumi.Input[_builtins.str]] + storage_key: NotRequired[pulumi.Input[_builtins.str]] + storage_name: NotRequired[pulumi.Input[_builtins.str]] + tenant_id: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysAzureEntraArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysAzureEntraArgs: + def __init__(__self__, *, + batch_key: Optional[pulumi.Input[_builtins.str]] = None, + batch_name: Optional[pulumi.Input[_builtins.str]] = None, + client_id: Optional[pulumi.Input[_builtins.str]] = None, + client_secret: Optional[pulumi.Input[_builtins.str]] = None, + storage_key: Optional[pulumi.Input[_builtins.str]] = None, + storage_name: Optional[pulumi.Input[_builtins.str]] = None, + tenant_id: Optional[pulumi.Input[_builtins.str]] = None): + if batch_key is not None: + pulumi.set(__self__, "batch_key", batch_key) + if batch_name is not None: + pulumi.set(__self__, "batch_name", batch_name) + if client_id is not None: + pulumi.set(__self__, "client_id", client_id) + if client_secret is not None: + pulumi.set(__self__, "client_secret", client_secret) + if storage_key is not None: + pulumi.set(__self__, "storage_key", storage_key) + if storage_name is not None: + pulumi.set(__self__, "storage_name", storage_name) + if tenant_id is not None: + pulumi.set(__self__, "tenant_id", tenant_id) + + @_builtins.property + @pulumi.getter(name="batchKey") + def batch_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "batch_key") + + @batch_key.setter + def batch_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "batch_key", value) + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "batch_name") + + @batch_name.setter + def batch_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "batch_name", value) + + @_builtins.property + @pulumi.getter(name="clientId") + def client_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "client_id") + + @client_id.setter + def client_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "client_id", value) + + @_builtins.property + @pulumi.getter(name="clientSecret") + def client_secret(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "client_secret") + + @client_secret.setter + def client_secret(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "client_secret", value) + + @_builtins.property + @pulumi.getter(name="storageKey") + def storage_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_key") + + @storage_key.setter + def storage_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_key", value) + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_name") + + @storage_name.setter + def storage_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_name", value) + + @_builtins.property + @pulumi.getter(name="tenantId") + def tenant_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "tenant_id") + + @tenant_id.setter + def tenant_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tenant_id", value) + + +if not MYPY: + class CredentialKeysAzurereposArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysAzurereposArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysAzurereposArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysBitbucketArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysBitbucketArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysBitbucketArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysCodecommitArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysCodecommitArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysCodecommitArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysContainerRegArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + registry: NotRequired[pulumi.Input[_builtins.str]] + user_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysContainerRegArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysContainerRegArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + registry: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if registry is not None: + pulumi.set(__self__, "registry", registry) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def registry(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "registry") + + @registry.setter + def registry(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "registry", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + +if not MYPY: + class CredentialKeysGiteaArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysGiteaArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysGiteaArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysGithubArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysGithubArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysGithubArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysGitlabArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + token: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysGitlabArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysGitlabArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + token: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if token is not None: + pulumi.set(__self__, "token", token) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "token", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysGoogleArgsDict(TypedDict): + data: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysGoogleArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysGoogleArgs: + def __init__(__self__, *, + data: Optional[pulumi.Input[_builtins.str]] = None): + if data is not None: + pulumi.set(__self__, "data", data) + + @_builtins.property + @pulumi.getter + def data(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "data") + + @data.setter + def data(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "data", value) + + +if not MYPY: + class CredentialKeysK8sArgsDict(TypedDict): + certificate: NotRequired[pulumi.Input[_builtins.str]] + private_key: NotRequired[pulumi.Input[_builtins.str]] + token: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysK8sArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysK8sArgs: + def __init__(__self__, *, + certificate: Optional[pulumi.Input[_builtins.str]] = None, + private_key: Optional[pulumi.Input[_builtins.str]] = None, + token: Optional[pulumi.Input[_builtins.str]] = None): + if certificate is not None: + pulumi.set(__self__, "certificate", certificate) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + if token is not None: + pulumi.set(__self__, "token", token) + + @_builtins.property + @pulumi.getter + def certificate(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "certificate") + + @certificate.setter + def certificate(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "certificate", value) + + @_builtins.property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "private_key") + + @private_key.setter + def private_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "private_key", value) + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "token", value) + + +if not MYPY: + class CredentialKeysSeqeracomputeArgsDict(TypedDict): + access_key: NotRequired[pulumi.Input[_builtins.str]] + assume_role_arn: NotRequired[pulumi.Input[_builtins.str]] + secret_key: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysSeqeracomputeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysSeqeracomputeArgs: + def __init__(__self__, *, + access_key: Optional[pulumi.Input[_builtins.str]] = None, + assume_role_arn: Optional[pulumi.Input[_builtins.str]] = None, + secret_key: Optional[pulumi.Input[_builtins.str]] = None): + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if assume_role_arn is not None: + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "access_key") + + @access_key.setter + def access_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "access_key", value) + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "assume_role_arn") + + @assume_role_arn.setter + def assume_role_arn(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "assume_role_arn", value) + + @_builtins.property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "secret_key") + + @secret_key.setter + def secret_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "secret_key", value) + + +if not MYPY: + class CredentialKeysSshArgsDict(TypedDict): + passphrase: NotRequired[pulumi.Input[_builtins.str]] + private_key: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysSshArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysSshArgs: + def __init__(__self__, *, + passphrase: Optional[pulumi.Input[_builtins.str]] = None, + private_key: Optional[pulumi.Input[_builtins.str]] = None): + if passphrase is not None: + pulumi.set(__self__, "passphrase", passphrase) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + + @_builtins.property + @pulumi.getter + def passphrase(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "passphrase") + + @passphrase.setter + def passphrase(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "passphrase", value) + + @_builtins.property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "private_key") + + @private_key.setter + def private_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "private_key", value) + + +if not MYPY: + class CredentialKeysTwAgentArgsDict(TypedDict): + connection_id: NotRequired[pulumi.Input[_builtins.str]] + shared: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysTwAgentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysTwAgentArgs: + def __init__(__self__, *, + connection_id: Optional[pulumi.Input[_builtins.str]] = None, + shared: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + if connection_id is not None: + pulumi.set(__self__, "connection_id", connection_id) + if shared is not None: + pulumi.set(__self__, "shared", shared) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="connectionId") + def connection_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "connection_id") + + @connection_id.setter + def connection_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "connection_id", value) + + @_builtins.property + @pulumi.getter + def shared(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "shared") + + @shared.setter + def shared(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "shared", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class DataLinkCredentialArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + provider_type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ +elif False: + DataLinkCredentialArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class DataLinkCredentialArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + +if not MYPY: + class LabelsLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + LabelsLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LabelsLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class PipelineComputeEnvArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + platform: NotRequired[pulumi.Input[_builtins.str]] + region: NotRequired[pulumi.Input[_builtins.str]] +elif False: + PipelineComputeEnvArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class PipelineComputeEnvArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + platform: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None): + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if region is not None: + pulumi.set(__self__, "region", region) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + +if not MYPY: + class PipelineLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + PipelineLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class PipelineLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class PipelineLaunchArgsDict(TypedDict): + compute_env_id: pulumi.Input[_builtins.str] + pipeline: pulumi.Input[_builtins.str] + work_dir: pulumi.Input[_builtins.str] + config_profiles: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + config_text: NotRequired[pulumi.Input[_builtins.str]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + entry_name: NotRequired[pulumi.Input[_builtins.str]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + label_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] + launch_container: NotRequired[pulumi.Input[_builtins.str]] + main_script: NotRequired[pulumi.Input[_builtins.str]] + optimization_id: NotRequired[pulumi.Input[_builtins.str]] + optimization_targets: NotRequired[pulumi.Input[_builtins.str]] + params_text: NotRequired[pulumi.Input[_builtins.str]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pull_latest: NotRequired[pulumi.Input[_builtins.bool]] + resume: NotRequired[pulumi.Input[_builtins.bool]] + revision: NotRequired[pulumi.Input[_builtins.str]] + run_name: NotRequired[pulumi.Input[_builtins.str]] + schema_name: NotRequired[pulumi.Input[_builtins.str]] + session_id: NotRequired[pulumi.Input[_builtins.str]] + stub_run: NotRequired[pulumi.Input[_builtins.bool]] + tower_config: NotRequired[pulumi.Input[_builtins.str]] + user_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + workspace_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] +elif False: + PipelineLaunchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class PipelineLaunchArgs: + def __init__(__self__, *, + compute_env_id: pulumi.Input[_builtins.str], + pipeline: pulumi.Input[_builtins.str], + work_dir: pulumi.Input[_builtins.str], + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def pipeline(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "pipeline") + + @pipeline.setter + def pipeline(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "pipeline", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "config_profiles") + + @config_profiles.setter + def config_profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_profiles", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "entry_name") + + @entry_name.setter + def entry_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "entry_name", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_container") + + @launch_container.setter + def launch_container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_container", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "params_text") + + @params_text.setter + def params_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "params_text", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "pull_latest") + + @pull_latest.setter + def pull_latest(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "pull_latest", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "schema_name") + + @schema_name.setter + def schema_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "schema_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "stub_run") + + @stub_run.setter + def stub_run(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "stub_run", value) + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "tower_config") + + @tower_config.setter + def tower_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tower_config", value) + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "user_secrets") + + @user_secrets.setter + def user_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "user_secrets", value) + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "workspace_secrets") + + @workspace_secrets.setter + def workspace_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "workspace_secrets", value) + + +if not MYPY: + class StudiosActiveConnectionArgsDict(TypedDict): + avatar: NotRequired[pulumi.Input[_builtins.str]] + email: NotRequired[pulumi.Input[_builtins.str]] + id: NotRequired[pulumi.Input[_builtins.float]] + last_active: NotRequired[pulumi.Input[_builtins.str]] + user_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosActiveConnectionArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosActiveConnectionArgs: + def __init__(__self__, *, + avatar: Optional[pulumi.Input[_builtins.str]] = None, + email: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + last_active: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None): + if avatar is not None: + pulumi.set(__self__, "avatar", avatar) + if email is not None: + pulumi.set(__self__, "email", email) + if id is not None: + pulumi.set(__self__, "id", id) + if last_active is not None: + pulumi.set(__self__, "last_active", last_active) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "avatar") + + @avatar.setter + def avatar(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar", value) + + @_builtins.property + @pulumi.getter + def email(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "email") + + @email.setter + def email(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "email", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="lastActive") + def last_active(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_active") + + @last_active.setter + def last_active(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_active", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + +if not MYPY: + class StudiosComputeEnvArgsDict(TypedDict): + credentials_id: NotRequired[pulumi.Input[_builtins.str]] + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + platform: NotRequired[pulumi.Input[_builtins.str]] + region: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosComputeEnvArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosComputeEnvArgs: + def __init__(__self__, *, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + platform: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if region is not None: + pulumi.set(__self__, "region", region) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class StudiosConfigurationArgsDict(TypedDict): + conda_environment: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + cpu: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + gpu: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + lifespan_hours: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + memory: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + mount_datas: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ +elif False: + StudiosConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosConfigurationArgs: + def __init__(__self__, *, + conda_environment: Optional[pulumi.Input[_builtins.str]] = None, + cpu: Optional[pulumi.Input[_builtins.float]] = None, + gpu: Optional[pulumi.Input[_builtins.float]] = None, + lifespan_hours: Optional[pulumi.Input[_builtins.float]] = None, + memory: Optional[pulumi.Input[_builtins.float]] = None, + mount_datas: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] conda_environment: Requires replacement if changed. + :param pulumi.Input[_builtins.float] cpu: Requires replacement if changed. + :param pulumi.Input[_builtins.float] gpu: Requires replacement if changed. + :param pulumi.Input[_builtins.float] lifespan_hours: Requires replacement if changed. + :param pulumi.Input[_builtins.float] memory: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] mount_datas: Requires replacement if changed. + """ + if conda_environment is not None: + pulumi.set(__self__, "conda_environment", conda_environment) + if cpu is not None: + pulumi.set(__self__, "cpu", cpu) + if gpu is not None: + pulumi.set(__self__, "gpu", gpu) + if lifespan_hours is not None: + pulumi.set(__self__, "lifespan_hours", lifespan_hours) + if memory is not None: + pulumi.set(__self__, "memory", memory) + if mount_datas is not None: + pulumi.set(__self__, "mount_datas", mount_datas) + + @_builtins.property + @pulumi.getter(name="condaEnvironment") + def conda_environment(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "conda_environment") + + @conda_environment.setter + def conda_environment(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "conda_environment", value) + + @_builtins.property + @pulumi.getter + def cpu(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cpu") + + @cpu.setter + def cpu(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu", value) + + @_builtins.property + @pulumi.getter + def gpu(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu") + + @gpu.setter + def gpu(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "gpu", value) + + @_builtins.property + @pulumi.getter(name="lifespanHours") + def lifespan_hours(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lifespan_hours") + + @lifespan_hours.setter + def lifespan_hours(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "lifespan_hours", value) + + @_builtins.property + @pulumi.getter + def memory(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "memory") + + @memory.setter + def memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory", value) + + @_builtins.property + @pulumi.getter(name="mountDatas") + def mount_datas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "mount_datas") + + @mount_datas.setter + def mount_datas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "mount_datas", value) + + +if not MYPY: + class StudiosLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + StudiosLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class StudiosMountedDataLinkArgsDict(TypedDict): + credentials: NotRequired[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgsDict']]]] + """ + Array of credentials required to access the data link + """ + data_link_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Unique identifier for the data link + """ + description: NotRequired[pulumi.Input[_builtins.str]] + """ + Description of the data link's purpose and contents + """ + hidden: NotRequired[pulumi.Input[_builtins.bool]] + message: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Display name for the data link connection + """ + provider_type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + public_accessible: NotRequired[pulumi.Input[_builtins.bool]] + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Geographic region where the data link is hosted + """ + resource_ref: NotRequired[pulumi.Input[_builtins.str]] + """ + Reference identifier for the external resource + """ + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["VALID", "INVALID"] + """ + type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be "bucket" + """ +elif False: + StudiosMountedDataLinkArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosMountedDataLinkArgs: + def __init__(__self__, *, + credentials: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgs']]]] = None, + data_link_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + hidden: Optional[pulumi.Input[_builtins.bool]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgs']]] credentials: Array of credentials required to access the data link + :param pulumi.Input[_builtins.str] data_link_id: Unique identifier for the data link + :param pulumi.Input[_builtins.str] description: Description of the data link's purpose and contents + :param pulumi.Input[_builtins.str] name: Display name for the data link connection + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + :param pulumi.Input[_builtins.str] region: Geographic region where the data link is hosted + :param pulumi.Input[_builtins.str] resource_ref: Reference identifier for the external resource + :param pulumi.Input[_builtins.str] status: must be one of ["VALID", "INVALID"] + :param pulumi.Input[_builtins.str] type: must be "bucket" + """ + if credentials is not None: + pulumi.set(__self__, "credentials", credentials) + if data_link_id is not None: + pulumi.set(__self__, "data_link_id", data_link_id) + if description is not None: + pulumi.set(__self__, "description", description) + if hidden is not None: + pulumi.set(__self__, "hidden", hidden) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + if public_accessible is not None: + pulumi.set(__self__, "public_accessible", public_accessible) + if region is not None: + pulumi.set(__self__, "region", region) + if resource_ref is not None: + pulumi.set(__self__, "resource_ref", resource_ref) + if status is not None: + pulumi.set(__self__, "status", status) + if type is not None: + pulumi.set(__self__, "type", type) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgs']]]]: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @credentials.setter + def credentials(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgs']]]]): + pulumi.set(self, "credentials", value) + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @data_link_id.setter + def data_link_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "data_link_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Description of the data link's purpose and contents + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def hidden(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "hidden") + + @hidden.setter + def hidden(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "hidden", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Display name for the data link connection + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "public_accessible") + + @public_accessible.setter + def public_accessible(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "public_accessible", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Reference identifier for the external resource + """ + return pulumi.get(self, "resource_ref") + + @resource_ref.setter + def resource_ref(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "resource_ref", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["VALID", "INVALID"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be "bucket" + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + +if not MYPY: + class StudiosMountedDataLinkCredentialArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + provider_type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ +elif False: + StudiosMountedDataLinkCredentialArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosMountedDataLinkCredentialArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + +if not MYPY: + class StudiosParentCheckpointArgsDict(TypedDict): + checkpoint_id: NotRequired[pulumi.Input[_builtins.float]] + checkpoint_name: NotRequired[pulumi.Input[_builtins.str]] + session_id: NotRequired[pulumi.Input[_builtins.str]] + studio_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosParentCheckpointArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosParentCheckpointArgs: + def __init__(__self__, *, + checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + checkpoint_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + studio_name: Optional[pulumi.Input[_builtins.str]] = None): + if checkpoint_id is not None: + pulumi.set(__self__, "checkpoint_id", checkpoint_id) + if checkpoint_name is not None: + pulumi.set(__self__, "checkpoint_name", checkpoint_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if studio_name is not None: + pulumi.set(__self__, "studio_name", studio_name) + + @_builtins.property + @pulumi.getter(name="checkpointId") + def checkpoint_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "checkpoint_id") + + @checkpoint_id.setter + def checkpoint_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "checkpoint_id", value) + + @_builtins.property + @pulumi.getter(name="checkpointName") + def checkpoint_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "checkpoint_name") + + @checkpoint_name.setter + def checkpoint_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "checkpoint_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="studioName") + def studio_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "studio_name") + + @studio_name.setter + def studio_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "studio_name", value) + + +if not MYPY: + class StudiosProgressArgsDict(TypedDict): + message: NotRequired[pulumi.Input[_builtins.str]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + warnings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] +elif False: + StudiosProgressArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosProgressArgs: + def __init__(__self__, *, + message: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + warnings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] status: must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + if message is not None: + pulumi.set(__self__, "message", message) + if status is not None: + pulumi.set(__self__, "status", status) + if warnings is not None: + pulumi.set(__self__, "warnings", warnings) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def warnings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "warnings") + + @warnings.setter + def warnings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "warnings", value) + + +if not MYPY: + class StudiosStatusInfoArgsDict(TypedDict): + last_update: NotRequired[pulumi.Input[_builtins.str]] + message: NotRequired[pulumi.Input[_builtins.str]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ +elif False: + StudiosStatusInfoArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosStatusInfoArgs: + def __init__(__self__, *, + last_update: Optional[pulumi.Input[_builtins.str]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] status: must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ + if last_update is not None: + pulumi.set(__self__, "last_update", last_update) + if message is not None: + pulumi.set(__self__, "message", message) + if status is not None: + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="lastUpdate") + def last_update(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_update") + + @last_update.setter + def last_update(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_update", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + +if not MYPY: + class StudiosTemplateArgsDict(TypedDict): + icon: NotRequired[pulumi.Input[_builtins.str]] + repository: NotRequired[pulumi.Input[_builtins.str]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + tool: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosTemplateArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosTemplateArgs: + def __init__(__self__, *, + icon: Optional[pulumi.Input[_builtins.str]] = None, + repository: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + tool: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] status: must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + if icon is not None: + pulumi.set(__self__, "icon", icon) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if status is not None: + pulumi.set(__self__, "status", status) + if tool is not None: + pulumi.set(__self__, "tool", tool) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "icon") + + @icon.setter + def icon(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "icon", value) + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "repository") + + @repository.setter + def repository(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "repository", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def tool(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "tool") + + @tool.setter + def tool(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tool", value) + + +if not MYPY: + class StudiosUserArgsDict(TypedDict): + avatar: NotRequired[pulumi.Input[_builtins.str]] + email: NotRequired[pulumi.Input[_builtins.str]] + id: NotRequired[pulumi.Input[_builtins.float]] + user_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosUserArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosUserArgs: + def __init__(__self__, *, + avatar: Optional[pulumi.Input[_builtins.str]] = None, + email: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None): + if avatar is not None: + pulumi.set(__self__, "avatar", avatar) + if email is not None: + pulumi.set(__self__, "email", email) + if id is not None: + pulumi.set(__self__, "id", id) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "avatar") + + @avatar.setter + def avatar(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar", value) + + @_builtins.property + @pulumi.getter + def email(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "email") + + @email.setter + def email(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "email", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + +if not MYPY: + class TokensTokenArgsDict(TypedDict): + basic_auth: NotRequired[pulumi.Input[_builtins.str]] + """ + Deprecated basic authentication string + """ + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the token was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the access token (nullable) + """ + last_used: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the token was last used for authentication + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Display name for the token (1-50 characters) + """ +elif False: + TokensTokenArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class TokensTokenArgs: + def __init__(__self__, *, + basic_auth: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] basic_auth: Deprecated basic authentication string + :param pulumi.Input[_builtins.str] date_created: Timestamp when the token was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the access token (nullable) + :param pulumi.Input[_builtins.str] last_used: Timestamp when the token was last used for authentication + :param pulumi.Input[_builtins.str] name: Display name for the token (1-50 characters) + """ + if basic_auth is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""basic_auth is deprecated: Deprecated""") + if basic_auth is not None: + pulumi.set(__self__, "basic_auth", basic_auth) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Deprecated basic authentication string + """ + return pulumi.get(self, "basic_auth") + + @basic_auth.setter + def basic_auth(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "basic_auth", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the token was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the access token (nullable) + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the token was last used for authentication + """ + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Display name for the token (1-50 characters) + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +if not MYPY: + class WorkflowsJobInfoArgsDict(TypedDict): + exit_code: NotRequired[pulumi.Input[_builtins.float]] + id: NotRequired[pulumi.Input[_builtins.float]] + message: NotRequired[pulumi.Input[_builtins.str]] + operation_id: NotRequired[pulumi.Input[_builtins.str]] + status: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsJobInfoArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsJobInfoArgs: + def __init__(__self__, *, + exit_code: Optional[pulumi.Input[_builtins.float]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + operation_id: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None): + if exit_code is not None: + pulumi.set(__self__, "exit_code", exit_code) + if id is not None: + pulumi.set(__self__, "id", id) + if message is not None: + pulumi.set(__self__, "message", message) + if operation_id is not None: + pulumi.set(__self__, "operation_id", operation_id) + if status is not None: + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="exitCode") + def exit_code(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "exit_code") + + @exit_code.setter + def exit_code(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "exit_code", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "operation_id") + + @operation_id.setter + def operation_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "operation_id", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + +if not MYPY: + class WorkflowsLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + WorkflowsLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class WorkflowsPlatformArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsPlatformArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +if not MYPY: + class WorkflowsProgressArgsDict(TypedDict): + processes_progresses: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowsProgressProcessesProgressArgsDict']]]] + total_processes: NotRequired[pulumi.Input[_builtins.float]] + workflow_progress: NotRequired[pulumi.Input['WorkflowsProgressWorkflowProgressArgsDict']] +elif False: + WorkflowsProgressArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsProgressArgs: + def __init__(__self__, *, + processes_progresses: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsProgressProcessesProgressArgs']]]] = None, + total_processes: Optional[pulumi.Input[_builtins.float]] = None, + workflow_progress: Optional[pulumi.Input['WorkflowsProgressWorkflowProgressArgs']] = None): + if processes_progresses is not None: + pulumi.set(__self__, "processes_progresses", processes_progresses) + if total_processes is not None: + pulumi.set(__self__, "total_processes", total_processes) + if workflow_progress is not None: + pulumi.set(__self__, "workflow_progress", workflow_progress) + + @_builtins.property + @pulumi.getter(name="processesProgresses") + def processes_progresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsProgressProcessesProgressArgs']]]]: + return pulumi.get(self, "processes_progresses") + + @processes_progresses.setter + def processes_progresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsProgressProcessesProgressArgs']]]]): + pulumi.set(self, "processes_progresses", value) + + @_builtins.property + @pulumi.getter(name="totalProcesses") + def total_processes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "total_processes") + + @total_processes.setter + def total_processes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "total_processes", value) + + @_builtins.property + @pulumi.getter(name="workflowProgress") + def workflow_progress(self) -> Optional[pulumi.Input['WorkflowsProgressWorkflowProgressArgs']]: + return pulumi.get(self, "workflow_progress") + + @workflow_progress.setter + def workflow_progress(self, value: Optional[pulumi.Input['WorkflowsProgressWorkflowProgressArgs']]): + pulumi.set(self, "workflow_progress", value) + + +if not MYPY: + class WorkflowsProgressProcessesProgressArgsDict(TypedDict): + aborted: NotRequired[pulumi.Input[_builtins.float]] + cached: NotRequired[pulumi.Input[_builtins.float]] + cpu_efficiency: NotRequired[pulumi.Input[_builtins.float]] + cpu_load: NotRequired[pulumi.Input[_builtins.float]] + cpu_time: NotRequired[pulumi.Input[_builtins.float]] + cpus: NotRequired[pulumi.Input[_builtins.float]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + failed: NotRequired[pulumi.Input[_builtins.float]] + inv_ctx_switch: NotRequired[pulumi.Input[_builtins.float]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + load_cpus: NotRequired[pulumi.Input[_builtins.float]] + load_memory: NotRequired[pulumi.Input[_builtins.float]] + load_tasks: NotRequired[pulumi.Input[_builtins.float]] + memory_efficiency: NotRequired[pulumi.Input[_builtins.float]] + memory_req: NotRequired[pulumi.Input[_builtins.float]] + memory_rss: NotRequired[pulumi.Input[_builtins.float]] + peak_cpus: NotRequired[pulumi.Input[_builtins.float]] + peak_memory: NotRequired[pulumi.Input[_builtins.float]] + peak_tasks: NotRequired[pulumi.Input[_builtins.float]] + pending: NotRequired[pulumi.Input[_builtins.float]] + process: NotRequired[pulumi.Input[_builtins.str]] + read_bytes: NotRequired[pulumi.Input[_builtins.float]] + running: NotRequired[pulumi.Input[_builtins.float]] + submitted: NotRequired[pulumi.Input[_builtins.float]] + succeeded: NotRequired[pulumi.Input[_builtins.float]] + vol_ctx_switch: NotRequired[pulumi.Input[_builtins.float]] + write_bytes: NotRequired[pulumi.Input[_builtins.float]] +elif False: + WorkflowsProgressProcessesProgressArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsProgressProcessesProgressArgs: + def __init__(__self__, *, + aborted: Optional[pulumi.Input[_builtins.float]] = None, + cached: Optional[pulumi.Input[_builtins.float]] = None, + cpu_efficiency: Optional[pulumi.Input[_builtins.float]] = None, + cpu_load: Optional[pulumi.Input[_builtins.float]] = None, + cpu_time: Optional[pulumi.Input[_builtins.float]] = None, + cpus: Optional[pulumi.Input[_builtins.float]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + failed: Optional[pulumi.Input[_builtins.float]] = None, + inv_ctx_switch: Optional[pulumi.Input[_builtins.float]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + load_cpus: Optional[pulumi.Input[_builtins.float]] = None, + load_memory: Optional[pulumi.Input[_builtins.float]] = None, + load_tasks: Optional[pulumi.Input[_builtins.float]] = None, + memory_efficiency: Optional[pulumi.Input[_builtins.float]] = None, + memory_req: Optional[pulumi.Input[_builtins.float]] = None, + memory_rss: Optional[pulumi.Input[_builtins.float]] = None, + peak_cpus: Optional[pulumi.Input[_builtins.float]] = None, + peak_memory: Optional[pulumi.Input[_builtins.float]] = None, + peak_tasks: Optional[pulumi.Input[_builtins.float]] = None, + pending: Optional[pulumi.Input[_builtins.float]] = None, + process: Optional[pulumi.Input[_builtins.str]] = None, + read_bytes: Optional[pulumi.Input[_builtins.float]] = None, + running: Optional[pulumi.Input[_builtins.float]] = None, + submitted: Optional[pulumi.Input[_builtins.float]] = None, + succeeded: Optional[pulumi.Input[_builtins.float]] = None, + vol_ctx_switch: Optional[pulumi.Input[_builtins.float]] = None, + write_bytes: Optional[pulumi.Input[_builtins.float]] = None): + if aborted is not None: + pulumi.set(__self__, "aborted", aborted) + if cached is not None: + pulumi.set(__self__, "cached", cached) + if cpu_efficiency is not None: + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + if cpu_load is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""cpu_load is deprecated: Deprecated""") + if cpu_load is not None: + pulumi.set(__self__, "cpu_load", cpu_load) + if cpu_time is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""cpu_time is deprecated: Deprecated""") + if cpu_time is not None: + pulumi.set(__self__, "cpu_time", cpu_time) + if cpus is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""cpus is deprecated: Deprecated""") + if cpus is not None: + pulumi.set(__self__, "cpus", cpus) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if failed is not None: + pulumi.set(__self__, "failed", failed) + if inv_ctx_switch is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""inv_ctx_switch is deprecated: Deprecated""") + if inv_ctx_switch is not None: + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if load_cpus is not None: + pulumi.set(__self__, "load_cpus", load_cpus) + if load_memory is not None: + pulumi.set(__self__, "load_memory", load_memory) + if load_tasks is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""load_tasks is deprecated: Deprecated""") + if load_tasks is not None: + pulumi.set(__self__, "load_tasks", load_tasks) + if memory_efficiency is not None: + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + if memory_req is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""memory_req is deprecated: Deprecated""") + if memory_req is not None: + pulumi.set(__self__, "memory_req", memory_req) + if memory_rss is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""memory_rss is deprecated: Deprecated""") + if memory_rss is not None: + pulumi.set(__self__, "memory_rss", memory_rss) + if peak_cpus is not None: + pulumi.set(__self__, "peak_cpus", peak_cpus) + if peak_memory is not None: + pulumi.set(__self__, "peak_memory", peak_memory) + if peak_tasks is not None: + pulumi.set(__self__, "peak_tasks", peak_tasks) + if pending is not None: + pulumi.set(__self__, "pending", pending) + if process is not None: + pulumi.set(__self__, "process", process) + if read_bytes is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""read_bytes is deprecated: Deprecated""") + if read_bytes is not None: + pulumi.set(__self__, "read_bytes", read_bytes) + if running is not None: + pulumi.set(__self__, "running", running) + if submitted is not None: + pulumi.set(__self__, "submitted", submitted) + if succeeded is not None: + pulumi.set(__self__, "succeeded", succeeded) + if vol_ctx_switch is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""vol_ctx_switch is deprecated: Deprecated""") + if vol_ctx_switch is not None: + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + if write_bytes is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""write_bytes is deprecated: Deprecated""") + if write_bytes is not None: + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "aborted") + + @aborted.setter + def aborted(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "aborted", value) + + @_builtins.property + @pulumi.getter + def cached(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached") + + @cached.setter + def cached(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached", value) + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_efficiency") + + @cpu_efficiency.setter + def cpu_efficiency(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_efficiency", value) + + @_builtins.property + @pulumi.getter(name="cpuLoad") + @_utilities.deprecated("""Deprecated""") + def cpu_load(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_load") + + @cpu_load.setter + def cpu_load(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_load", value) + + @_builtins.property + @pulumi.getter(name="cpuTime") + @_utilities.deprecated("""Deprecated""") + def cpu_time(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_time") + + @cpu_time.setter + def cpu_time(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_time", value) + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpus") + + @cpus.setter + def cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpus", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def failed(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed") + + @failed.setter + def failed(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed", value) + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def inv_ctx_switch(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "inv_ctx_switch") + + @inv_ctx_switch.setter + def inv_ctx_switch(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "inv_ctx_switch", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_cpus") + + @load_cpus.setter + def load_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_cpus", value) + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_memory") + + @load_memory.setter + def load_memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_memory", value) + + @_builtins.property + @pulumi.getter(name="loadTasks") + @_utilities.deprecated("""Deprecated""") + def load_tasks(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_tasks") + + @load_tasks.setter + def load_tasks(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_tasks", value) + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_efficiency") + + @memory_efficiency.setter + def memory_efficiency(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_efficiency", value) + + @_builtins.property + @pulumi.getter(name="memoryReq") + @_utilities.deprecated("""Deprecated""") + def memory_req(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_req") + + @memory_req.setter + def memory_req(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_req", value) + + @_builtins.property + @pulumi.getter(name="memoryRss") + @_utilities.deprecated("""Deprecated""") + def memory_rss(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_rss") + + @memory_rss.setter + def memory_rss(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_rss", value) + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_cpus") + + @peak_cpus.setter + def peak_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_cpus", value) + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_memory") + + @peak_memory.setter + def peak_memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_memory", value) + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_tasks") + + @peak_tasks.setter + def peak_tasks(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_tasks", value) + + @_builtins.property + @pulumi.getter + def pending(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "pending") + + @pending.setter + def pending(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "pending", value) + + @_builtins.property + @pulumi.getter + def process(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "process") + + @process.setter + def process(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "process", value) + + @_builtins.property + @pulumi.getter(name="readBytes") + @_utilities.deprecated("""Deprecated""") + def read_bytes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "read_bytes") + + @read_bytes.setter + def read_bytes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "read_bytes", value) + + @_builtins.property + @pulumi.getter + def running(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "running") + + @running.setter + def running(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "running", value) + + @_builtins.property + @pulumi.getter + def submitted(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "submitted") + + @submitted.setter + def submitted(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "submitted", value) + + @_builtins.property + @pulumi.getter + def succeeded(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeeded") + + @succeeded.setter + def succeeded(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeeded", value) + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def vol_ctx_switch(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "vol_ctx_switch") + + @vol_ctx_switch.setter + def vol_ctx_switch(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "vol_ctx_switch", value) + + @_builtins.property + @pulumi.getter(name="writeBytes") + @_utilities.deprecated("""Deprecated""") + def write_bytes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "write_bytes") + + @write_bytes.setter + def write_bytes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "write_bytes", value) + + +if not MYPY: + class WorkflowsProgressWorkflowProgressArgsDict(TypedDict): + aborted: NotRequired[pulumi.Input[_builtins.float]] + cached: NotRequired[pulumi.Input[_builtins.float]] + cost: NotRequired[pulumi.Input[_builtins.float]] + cpu_efficiency: NotRequired[pulumi.Input[_builtins.float]] + cpu_load: NotRequired[pulumi.Input[_builtins.float]] + cpu_time: NotRequired[pulumi.Input[_builtins.float]] + cpus: NotRequired[pulumi.Input[_builtins.float]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + executors: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + failed: NotRequired[pulumi.Input[_builtins.float]] + inv_ctx_switch: NotRequired[pulumi.Input[_builtins.float]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + load_cpus: NotRequired[pulumi.Input[_builtins.float]] + load_memory: NotRequired[pulumi.Input[_builtins.float]] + load_tasks: NotRequired[pulumi.Input[_builtins.float]] + memory_efficiency: NotRequired[pulumi.Input[_builtins.float]] + memory_req: NotRequired[pulumi.Input[_builtins.float]] + memory_rss: NotRequired[pulumi.Input[_builtins.float]] + peak_cpus: NotRequired[pulumi.Input[_builtins.float]] + peak_memory: NotRequired[pulumi.Input[_builtins.float]] + peak_tasks: NotRequired[pulumi.Input[_builtins.float]] + pending: NotRequired[pulumi.Input[_builtins.float]] + read_bytes: NotRequired[pulumi.Input[_builtins.float]] + running: NotRequired[pulumi.Input[_builtins.float]] + submitted: NotRequired[pulumi.Input[_builtins.float]] + succeeded: NotRequired[pulumi.Input[_builtins.float]] + vol_ctx_switch: NotRequired[pulumi.Input[_builtins.float]] + write_bytes: NotRequired[pulumi.Input[_builtins.float]] +elif False: + WorkflowsProgressWorkflowProgressArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsProgressWorkflowProgressArgs: + def __init__(__self__, *, + aborted: Optional[pulumi.Input[_builtins.float]] = None, + cached: Optional[pulumi.Input[_builtins.float]] = None, + cost: Optional[pulumi.Input[_builtins.float]] = None, + cpu_efficiency: Optional[pulumi.Input[_builtins.float]] = None, + cpu_load: Optional[pulumi.Input[_builtins.float]] = None, + cpu_time: Optional[pulumi.Input[_builtins.float]] = None, + cpus: Optional[pulumi.Input[_builtins.float]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + executors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + failed: Optional[pulumi.Input[_builtins.float]] = None, + inv_ctx_switch: Optional[pulumi.Input[_builtins.float]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + load_cpus: Optional[pulumi.Input[_builtins.float]] = None, + load_memory: Optional[pulumi.Input[_builtins.float]] = None, + load_tasks: Optional[pulumi.Input[_builtins.float]] = None, + memory_efficiency: Optional[pulumi.Input[_builtins.float]] = None, + memory_req: Optional[pulumi.Input[_builtins.float]] = None, + memory_rss: Optional[pulumi.Input[_builtins.float]] = None, + peak_cpus: Optional[pulumi.Input[_builtins.float]] = None, + peak_memory: Optional[pulumi.Input[_builtins.float]] = None, + peak_tasks: Optional[pulumi.Input[_builtins.float]] = None, + pending: Optional[pulumi.Input[_builtins.float]] = None, + read_bytes: Optional[pulumi.Input[_builtins.float]] = None, + running: Optional[pulumi.Input[_builtins.float]] = None, + submitted: Optional[pulumi.Input[_builtins.float]] = None, + succeeded: Optional[pulumi.Input[_builtins.float]] = None, + vol_ctx_switch: Optional[pulumi.Input[_builtins.float]] = None, + write_bytes: Optional[pulumi.Input[_builtins.float]] = None): + if aborted is not None: + pulumi.set(__self__, "aborted", aborted) + if cached is not None: + pulumi.set(__self__, "cached", cached) + if cost is not None: + pulumi.set(__self__, "cost", cost) + if cpu_efficiency is not None: + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + if cpu_load is not None: + pulumi.set(__self__, "cpu_load", cpu_load) + if cpu_time is not None: + pulumi.set(__self__, "cpu_time", cpu_time) + if cpus is not None: + pulumi.set(__self__, "cpus", cpus) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if executors is not None: + pulumi.set(__self__, "executors", executors) + if failed is not None: + pulumi.set(__self__, "failed", failed) + if inv_ctx_switch is not None: + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if load_cpus is not None: + pulumi.set(__self__, "load_cpus", load_cpus) + if load_memory is not None: + pulumi.set(__self__, "load_memory", load_memory) + if load_tasks is not None: + pulumi.set(__self__, "load_tasks", load_tasks) + if memory_efficiency is not None: + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + if memory_req is not None: + pulumi.set(__self__, "memory_req", memory_req) + if memory_rss is not None: + pulumi.set(__self__, "memory_rss", memory_rss) + if peak_cpus is not None: + pulumi.set(__self__, "peak_cpus", peak_cpus) + if peak_memory is not None: + pulumi.set(__self__, "peak_memory", peak_memory) + if peak_tasks is not None: + pulumi.set(__self__, "peak_tasks", peak_tasks) + if pending is not None: + pulumi.set(__self__, "pending", pending) + if read_bytes is not None: + pulumi.set(__self__, "read_bytes", read_bytes) + if running is not None: + pulumi.set(__self__, "running", running) + if submitted is not None: + pulumi.set(__self__, "submitted", submitted) + if succeeded is not None: + pulumi.set(__self__, "succeeded", succeeded) + if vol_ctx_switch is not None: + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + if write_bytes is not None: + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "aborted") + + @aborted.setter + def aborted(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "aborted", value) + + @_builtins.property + @pulumi.getter + def cached(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached") + + @cached.setter + def cached(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached", value) + + @_builtins.property + @pulumi.getter + def cost(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cost") + + @cost.setter + def cost(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cost", value) + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_efficiency") + + @cpu_efficiency.setter + def cpu_efficiency(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_efficiency", value) + + @_builtins.property + @pulumi.getter(name="cpuLoad") + def cpu_load(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_load") + + @cpu_load.setter + def cpu_load(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_load", value) + + @_builtins.property + @pulumi.getter(name="cpuTime") + def cpu_time(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_time") + + @cpu_time.setter + def cpu_time(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_time", value) + + @_builtins.property + @pulumi.getter + def cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpus") + + @cpus.setter + def cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpus", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def executors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "executors") + + @executors.setter + def executors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "executors", value) + + @_builtins.property + @pulumi.getter + def failed(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed") + + @failed.setter + def failed(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed", value) + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + def inv_ctx_switch(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "inv_ctx_switch") + + @inv_ctx_switch.setter + def inv_ctx_switch(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "inv_ctx_switch", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_cpus") + + @load_cpus.setter + def load_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_cpus", value) + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_memory") + + @load_memory.setter + def load_memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_memory", value) + + @_builtins.property + @pulumi.getter(name="loadTasks") + def load_tasks(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_tasks") + + @load_tasks.setter + def load_tasks(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_tasks", value) + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_efficiency") + + @memory_efficiency.setter + def memory_efficiency(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_efficiency", value) + + @_builtins.property + @pulumi.getter(name="memoryReq") + def memory_req(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_req") + + @memory_req.setter + def memory_req(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_req", value) + + @_builtins.property + @pulumi.getter(name="memoryRss") + def memory_rss(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_rss") + + @memory_rss.setter + def memory_rss(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_rss", value) + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_cpus") + + @peak_cpus.setter + def peak_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_cpus", value) + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_memory") + + @peak_memory.setter + def peak_memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_memory", value) + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_tasks") + + @peak_tasks.setter + def peak_tasks(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_tasks", value) + + @_builtins.property + @pulumi.getter + def pending(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "pending") + + @pending.setter + def pending(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "pending", value) + + @_builtins.property + @pulumi.getter(name="readBytes") + def read_bytes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "read_bytes") + + @read_bytes.setter + def read_bytes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "read_bytes", value) + + @_builtins.property + @pulumi.getter + def running(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "running") + + @running.setter + def running(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "running", value) + + @_builtins.property + @pulumi.getter + def submitted(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "submitted") + + @submitted.setter + def submitted(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "submitted", value) + + @_builtins.property + @pulumi.getter + def succeeded(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeeded") + + @succeeded.setter + def succeeded(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeeded", value) + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + def vol_ctx_switch(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "vol_ctx_switch") + + @vol_ctx_switch.setter + def vol_ctx_switch(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "vol_ctx_switch", value) + + @_builtins.property + @pulumi.getter(name="writeBytes") + def write_bytes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "write_bytes") + + @write_bytes.setter + def write_bytes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "write_bytes", value) + + +if not MYPY: + class WorkflowsWorkflowArgsDict(TypedDict): + command_line: NotRequired[pulumi.Input[_builtins.str]] + commit_id: NotRequired[pulumi.Input[_builtins.str]] + complete: NotRequired[pulumi.Input[_builtins.str]] + config_files: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + config_text: NotRequired[pulumi.Input[_builtins.str]] + container: NotRequired[pulumi.Input[_builtins.str]] + container_engine: NotRequired[pulumi.Input[_builtins.str]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + deleted: NotRequired[pulumi.Input[_builtins.bool]] + duration: NotRequired[pulumi.Input[_builtins.float]] + error_message: NotRequired[pulumi.Input[_builtins.str]] + error_report: NotRequired[pulumi.Input[_builtins.str]] + exit_status: NotRequired[pulumi.Input[_builtins.float]] + home_dir: NotRequired[pulumi.Input[_builtins.str]] + id: NotRequired[pulumi.Input[_builtins.str]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + launch_id: NotRequired[pulumi.Input[_builtins.str]] + log_file: NotRequired[pulumi.Input[_builtins.str]] + manifest: NotRequired[pulumi.Input['WorkflowsWorkflowManifestArgsDict']] + nextflow: NotRequired[pulumi.Input['WorkflowsWorkflowNextflowArgsDict']] + operation_id: NotRequired[pulumi.Input[_builtins.str]] + out_file: NotRequired[pulumi.Input[_builtins.str]] + owner_id: NotRequired[pulumi.Input[_builtins.float]] + params: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + profile: NotRequired[pulumi.Input[_builtins.str]] + project_dir: NotRequired[pulumi.Input[_builtins.str]] + project_name: NotRequired[pulumi.Input[_builtins.str]] + repository: NotRequired[pulumi.Input[_builtins.str]] + requires_attention: NotRequired[pulumi.Input[_builtins.bool]] + resume: NotRequired[pulumi.Input[_builtins.bool]] + revision: NotRequired[pulumi.Input[_builtins.str]] + run_name: NotRequired[pulumi.Input[_builtins.str]] + script_file: NotRequired[pulumi.Input[_builtins.str]] + script_id: NotRequired[pulumi.Input[_builtins.str]] + script_name: NotRequired[pulumi.Input[_builtins.str]] + session_id: NotRequired[pulumi.Input[_builtins.str]] + start: NotRequired[pulumi.Input[_builtins.str]] + stats: NotRequired[pulumi.Input['WorkflowsWorkflowStatsArgsDict']] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + submit: NotRequired[pulumi.Input[_builtins.str]] + success: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsWorkflowArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsWorkflowArgs: + def __init__(__self__, *, + command_line: Optional[pulumi.Input[_builtins.str]] = None, + commit_id: Optional[pulumi.Input[_builtins.str]] = None, + complete: Optional[pulumi.Input[_builtins.str]] = None, + config_files: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + container: Optional[pulumi.Input[_builtins.str]] = None, + container_engine: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + duration: Optional[pulumi.Input[_builtins.float]] = None, + error_message: Optional[pulumi.Input[_builtins.str]] = None, + error_report: Optional[pulumi.Input[_builtins.str]] = None, + exit_status: Optional[pulumi.Input[_builtins.float]] = None, + home_dir: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + launch_id: Optional[pulumi.Input[_builtins.str]] = None, + log_file: Optional[pulumi.Input[_builtins.str]] = None, + manifest: Optional[pulumi.Input['WorkflowsWorkflowManifestArgs']] = None, + nextflow: Optional[pulumi.Input['WorkflowsWorkflowNextflowArgs']] = None, + operation_id: Optional[pulumi.Input[_builtins.str]] = None, + out_file: Optional[pulumi.Input[_builtins.str]] = None, + owner_id: Optional[pulumi.Input[_builtins.float]] = None, + params: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + profile: Optional[pulumi.Input[_builtins.str]] = None, + project_dir: Optional[pulumi.Input[_builtins.str]] = None, + project_name: Optional[pulumi.Input[_builtins.str]] = None, + repository: Optional[pulumi.Input[_builtins.str]] = None, + requires_attention: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + script_file: Optional[pulumi.Input[_builtins.str]] = None, + script_id: Optional[pulumi.Input[_builtins.str]] = None, + script_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + start: Optional[pulumi.Input[_builtins.str]] = None, + stats: Optional[pulumi.Input['WorkflowsWorkflowStatsArgs']] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + submit: Optional[pulumi.Input[_builtins.str]] = None, + success: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] status: must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + if command_line is not None: + pulumi.set(__self__, "command_line", command_line) + if commit_id is not None: + pulumi.set(__self__, "commit_id", commit_id) + if complete is not None: + pulumi.set(__self__, "complete", complete) + if config_files is not None: + pulumi.set(__self__, "config_files", config_files) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if container is not None: + pulumi.set(__self__, "container", container) + if container_engine is not None: + pulumi.set(__self__, "container_engine", container_engine) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error_message is not None: + pulumi.set(__self__, "error_message", error_message) + if error_report is not None: + pulumi.set(__self__, "error_report", error_report) + if exit_status is not None: + pulumi.set(__self__, "exit_status", exit_status) + if home_dir is not None: + pulumi.set(__self__, "home_dir", home_dir) + if id is not None: + pulumi.set(__self__, "id", id) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if launch_id is not None: + pulumi.set(__self__, "launch_id", launch_id) + if log_file is not None: + pulumi.set(__self__, "log_file", log_file) + if manifest is not None: + pulumi.set(__self__, "manifest", manifest) + if nextflow is not None: + pulumi.set(__self__, "nextflow", nextflow) + if operation_id is not None: + pulumi.set(__self__, "operation_id", operation_id) + if out_file is not None: + pulumi.set(__self__, "out_file", out_file) + if owner_id is not None: + pulumi.set(__self__, "owner_id", owner_id) + if params is not None: + pulumi.set(__self__, "params", params) + if profile is not None: + pulumi.set(__self__, "profile", profile) + if project_dir is not None: + pulumi.set(__self__, "project_dir", project_dir) + if project_name is not None: + pulumi.set(__self__, "project_name", project_name) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if requires_attention is not None: + pulumi.set(__self__, "requires_attention", requires_attention) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if script_file is not None: + pulumi.set(__self__, "script_file", script_file) + if script_id is not None: + pulumi.set(__self__, "script_id", script_id) + if script_name is not None: + pulumi.set(__self__, "script_name", script_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if start is not None: + pulumi.set(__self__, "start", start) + if stats is not None: + pulumi.set(__self__, "stats", stats) + if status is not None: + pulumi.set(__self__, "status", status) + if submit is not None: + pulumi.set(__self__, "submit", submit) + if success is not None: + pulumi.set(__self__, "success", success) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="commandLine") + def command_line(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "command_line") + + @command_line.setter + def command_line(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "command_line", value) + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "commit_id") + + @commit_id.setter + def commit_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "commit_id", value) + + @_builtins.property + @pulumi.getter + def complete(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "complete") + + @complete.setter + def complete(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "complete", value) + + @_builtins.property + @pulumi.getter(name="configFiles") + def config_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "config_files") + + @config_files.setter + def config_files(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_files", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter + def container(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "container") + + @container.setter + def container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "container", value) + + @_builtins.property + @pulumi.getter(name="containerEngine") + def container_engine(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "container_engine") + + @container_engine.setter + def container_engine(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "container_engine", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def duration(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "duration") + + @duration.setter + def duration(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "duration", value) + + @_builtins.property + @pulumi.getter(name="errorMessage") + def error_message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "error_message") + + @error_message.setter + def error_message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "error_message", value) + + @_builtins.property + @pulumi.getter(name="errorReport") + def error_report(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "error_report") + + @error_report.setter + def error_report(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "error_report", value) + + @_builtins.property + @pulumi.getter(name="exitStatus") + def exit_status(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "exit_status") + + @exit_status.setter + def exit_status(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "exit_status", value) + + @_builtins.property + @pulumi.getter(name="homeDir") + def home_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "home_dir") + + @home_dir.setter + def home_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "home_dir", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="launchId") + def launch_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_id") + + @launch_id.setter + def launch_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_id", value) + + @_builtins.property + @pulumi.getter(name="logFile") + def log_file(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "log_file") + + @log_file.setter + def log_file(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_file", value) + + @_builtins.property + @pulumi.getter + def manifest(self) -> Optional[pulumi.Input['WorkflowsWorkflowManifestArgs']]: + return pulumi.get(self, "manifest") + + @manifest.setter + def manifest(self, value: Optional[pulumi.Input['WorkflowsWorkflowManifestArgs']]): + pulumi.set(self, "manifest", value) + + @_builtins.property + @pulumi.getter + def nextflow(self) -> Optional[pulumi.Input['WorkflowsWorkflowNextflowArgs']]: + return pulumi.get(self, "nextflow") + + @nextflow.setter + def nextflow(self, value: Optional[pulumi.Input['WorkflowsWorkflowNextflowArgs']]): + pulumi.set(self, "nextflow", value) + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "operation_id") + + @operation_id.setter + def operation_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "operation_id", value) + + @_builtins.property + @pulumi.getter(name="outFile") + def out_file(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "out_file") + + @out_file.setter + def out_file(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "out_file", value) + + @_builtins.property + @pulumi.getter(name="ownerId") + def owner_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "owner_id") + + @owner_id.setter + def owner_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "owner_id", value) + + @_builtins.property + @pulumi.getter + def params(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "params") + + @params.setter + def params(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "params", value) + + @_builtins.property + @pulumi.getter + def profile(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "profile") + + @profile.setter + def profile(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "profile", value) + + @_builtins.property + @pulumi.getter(name="projectDir") + def project_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "project_dir") + + @project_dir.setter + def project_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_dir", value) + + @_builtins.property + @pulumi.getter(name="projectName") + def project_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "project_name") + + @project_name.setter + def project_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_name", value) + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "repository") + + @repository.setter + def repository(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "repository", value) + + @_builtins.property + @pulumi.getter(name="requiresAttention") + def requires_attention(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "requires_attention") + + @requires_attention.setter + def requires_attention(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "requires_attention", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="scriptFile") + def script_file(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "script_file") + + @script_file.setter + def script_file(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "script_file", value) + + @_builtins.property + @pulumi.getter(name="scriptId") + def script_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "script_id") + + @script_id.setter + def script_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "script_id", value) + + @_builtins.property + @pulumi.getter(name="scriptName") + def script_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "script_name") + + @script_name.setter + def script_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "script_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter + def start(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "start") + + @start.setter + def start(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "start", value) + + @_builtins.property + @pulumi.getter + def stats(self) -> Optional[pulumi.Input['WorkflowsWorkflowStatsArgs']]: + return pulumi.get(self, "stats") + + @stats.setter + def stats(self, value: Optional[pulumi.Input['WorkflowsWorkflowStatsArgs']]): + pulumi.set(self, "stats", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def submit(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "submit") + + @submit.setter + def submit(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "submit", value) + + @_builtins.property + @pulumi.getter + def success(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "success") + + @success.setter + def success(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "success", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class WorkflowsWorkflowManifestArgsDict(TypedDict): + author: NotRequired[pulumi.Input[_builtins.str]] + default_branch: NotRequired[pulumi.Input[_builtins.str]] + description: NotRequired[pulumi.Input[_builtins.str]] + gitmodules: NotRequired[pulumi.Input[_builtins.str]] + home_page: NotRequired[pulumi.Input[_builtins.str]] + icon: NotRequired[pulumi.Input[_builtins.str]] + main_script: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + nextflow_version: NotRequired[pulumi.Input[_builtins.str]] + version: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsWorkflowManifestArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsWorkflowManifestArgs: + def __init__(__self__, *, + author: Optional[pulumi.Input[_builtins.str]] = None, + default_branch: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + gitmodules: Optional[pulumi.Input[_builtins.str]] = None, + home_page: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_version: Optional[pulumi.Input[_builtins.str]] = None, + version: Optional[pulumi.Input[_builtins.str]] = None): + if author is not None: + pulumi.set(__self__, "author", author) + if default_branch is not None: + pulumi.set(__self__, "default_branch", default_branch) + if description is not None: + pulumi.set(__self__, "description", description) + if gitmodules is not None: + pulumi.set(__self__, "gitmodules", gitmodules) + if home_page is not None: + pulumi.set(__self__, "home_page", home_page) + if icon is not None: + pulumi.set(__self__, "icon", icon) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if name is not None: + pulumi.set(__self__, "name", name) + if nextflow_version is not None: + pulumi.set(__self__, "nextflow_version", nextflow_version) + if version is not None: + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def author(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "author") + + @author.setter + def author(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "author", value) + + @_builtins.property + @pulumi.getter(name="defaultBranch") + def default_branch(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "default_branch") + + @default_branch.setter + def default_branch(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "default_branch", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def gitmodules(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "gitmodules") + + @gitmodules.setter + def gitmodules(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "gitmodules", value) + + @_builtins.property + @pulumi.getter(name="homePage") + def home_page(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "home_page") + + @home_page.setter + def home_page(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "home_page", value) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "icon") + + @icon.setter + def icon(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "icon", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="nextflowVersion") + def nextflow_version(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nextflow_version") + + @nextflow_version.setter + def nextflow_version(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_version", value) + + @_builtins.property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "version", value) + + +if not MYPY: + class WorkflowsWorkflowNextflowArgsDict(TypedDict): + build: NotRequired[pulumi.Input[_builtins.str]] + timestamp: NotRequired[pulumi.Input[_builtins.str]] + version: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsWorkflowNextflowArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsWorkflowNextflowArgs: + def __init__(__self__, *, + build: Optional[pulumi.Input[_builtins.str]] = None, + timestamp: Optional[pulumi.Input[_builtins.str]] = None, + version: Optional[pulumi.Input[_builtins.str]] = None): + if build is not None: + pulumi.set(__self__, "build", build) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + if version is not None: + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def build(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "build") + + @build.setter + def build(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "build", value) + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "timestamp") + + @timestamp.setter + def timestamp(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "timestamp", value) + + @_builtins.property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "version", value) + + +if not MYPY: + class WorkflowsWorkflowStatsArgsDict(TypedDict): + cached_count: NotRequired[pulumi.Input[_builtins.float]] + cached_count_fmt: NotRequired[pulumi.Input[_builtins.str]] + cached_duration: NotRequired[pulumi.Input[_builtins.float]] + cached_pct: NotRequired[pulumi.Input[_builtins.float]] + compute_time_fmt: NotRequired[pulumi.Input[_builtins.str]] + failed_count: NotRequired[pulumi.Input[_builtins.float]] + failed_count_fmt: NotRequired[pulumi.Input[_builtins.str]] + failed_duration: NotRequired[pulumi.Input[_builtins.float]] + failed_pct: NotRequired[pulumi.Input[_builtins.float]] + ignored_count: NotRequired[pulumi.Input[_builtins.float]] + ignored_count_fmt: NotRequired[pulumi.Input[_builtins.str]] + ignored_pct: NotRequired[pulumi.Input[_builtins.float]] + succeed_count: NotRequired[pulumi.Input[_builtins.float]] + succeed_count_fmt: NotRequired[pulumi.Input[_builtins.str]] + succeed_duration: NotRequired[pulumi.Input[_builtins.float]] + succeed_pct: NotRequired[pulumi.Input[_builtins.float]] +elif False: + WorkflowsWorkflowStatsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsWorkflowStatsArgs: + def __init__(__self__, *, + cached_count: Optional[pulumi.Input[_builtins.float]] = None, + cached_count_fmt: Optional[pulumi.Input[_builtins.str]] = None, + cached_duration: Optional[pulumi.Input[_builtins.float]] = None, + cached_pct: Optional[pulumi.Input[_builtins.float]] = None, + compute_time_fmt: Optional[pulumi.Input[_builtins.str]] = None, + failed_count: Optional[pulumi.Input[_builtins.float]] = None, + failed_count_fmt: Optional[pulumi.Input[_builtins.str]] = None, + failed_duration: Optional[pulumi.Input[_builtins.float]] = None, + failed_pct: Optional[pulumi.Input[_builtins.float]] = None, + ignored_count: Optional[pulumi.Input[_builtins.float]] = None, + ignored_count_fmt: Optional[pulumi.Input[_builtins.str]] = None, + ignored_pct: Optional[pulumi.Input[_builtins.float]] = None, + succeed_count: Optional[pulumi.Input[_builtins.float]] = None, + succeed_count_fmt: Optional[pulumi.Input[_builtins.str]] = None, + succeed_duration: Optional[pulumi.Input[_builtins.float]] = None, + succeed_pct: Optional[pulumi.Input[_builtins.float]] = None): + if cached_count is not None: + pulumi.set(__self__, "cached_count", cached_count) + if cached_count_fmt is not None: + pulumi.set(__self__, "cached_count_fmt", cached_count_fmt) + if cached_duration is not None: + pulumi.set(__self__, "cached_duration", cached_duration) + if cached_pct is not None: + pulumi.set(__self__, "cached_pct", cached_pct) + if compute_time_fmt is not None: + pulumi.set(__self__, "compute_time_fmt", compute_time_fmt) + if failed_count is not None: + pulumi.set(__self__, "failed_count", failed_count) + if failed_count_fmt is not None: + pulumi.set(__self__, "failed_count_fmt", failed_count_fmt) + if failed_duration is not None: + pulumi.set(__self__, "failed_duration", failed_duration) + if failed_pct is not None: + pulumi.set(__self__, "failed_pct", failed_pct) + if ignored_count is not None: + pulumi.set(__self__, "ignored_count", ignored_count) + if ignored_count_fmt is not None: + pulumi.set(__self__, "ignored_count_fmt", ignored_count_fmt) + if ignored_pct is not None: + pulumi.set(__self__, "ignored_pct", ignored_pct) + if succeed_count is not None: + pulumi.set(__self__, "succeed_count", succeed_count) + if succeed_count_fmt is not None: + pulumi.set(__self__, "succeed_count_fmt", succeed_count_fmt) + if succeed_duration is not None: + pulumi.set(__self__, "succeed_duration", succeed_duration) + if succeed_pct is not None: + pulumi.set(__self__, "succeed_pct", succeed_pct) + + @_builtins.property + @pulumi.getter(name="cachedCount") + def cached_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached_count") + + @cached_count.setter + def cached_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached_count", value) + + @_builtins.property + @pulumi.getter(name="cachedCountFmt") + def cached_count_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "cached_count_fmt") + + @cached_count_fmt.setter + def cached_count_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cached_count_fmt", value) + + @_builtins.property + @pulumi.getter(name="cachedDuration") + def cached_duration(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached_duration") + + @cached_duration.setter + def cached_duration(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached_duration", value) + + @_builtins.property + @pulumi.getter(name="cachedPct") + def cached_pct(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached_pct") + + @cached_pct.setter + def cached_pct(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached_pct", value) + + @_builtins.property + @pulumi.getter(name="computeTimeFmt") + def compute_time_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_time_fmt") + + @compute_time_fmt.setter + def compute_time_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_time_fmt", value) + + @_builtins.property + @pulumi.getter(name="failedCount") + def failed_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed_count") + + @failed_count.setter + def failed_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed_count", value) + + @_builtins.property + @pulumi.getter(name="failedCountFmt") + def failed_count_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "failed_count_fmt") + + @failed_count_fmt.setter + def failed_count_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "failed_count_fmt", value) + + @_builtins.property + @pulumi.getter(name="failedDuration") + def failed_duration(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed_duration") + + @failed_duration.setter + def failed_duration(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed_duration", value) + + @_builtins.property + @pulumi.getter(name="failedPct") + def failed_pct(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed_pct") + + @failed_pct.setter + def failed_pct(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed_pct", value) + + @_builtins.property + @pulumi.getter(name="ignoredCount") + def ignored_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ignored_count") + + @ignored_count.setter + def ignored_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ignored_count", value) + + @_builtins.property + @pulumi.getter(name="ignoredCountFmt") + def ignored_count_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ignored_count_fmt") + + @ignored_count_fmt.setter + def ignored_count_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ignored_count_fmt", value) + + @_builtins.property + @pulumi.getter(name="ignoredPct") + def ignored_pct(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ignored_pct") + + @ignored_pct.setter + def ignored_pct(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ignored_pct", value) + + @_builtins.property + @pulumi.getter(name="succeedCount") + def succeed_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeed_count") + + @succeed_count.setter + def succeed_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeed_count", value) + + @_builtins.property + @pulumi.getter(name="succeedCountFmt") + def succeed_count_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "succeed_count_fmt") + + @succeed_count_fmt.setter + def succeed_count_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "succeed_count_fmt", value) + + @_builtins.property + @pulumi.getter(name="succeedDuration") + def succeed_duration(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeed_duration") + + @succeed_duration.setter + def succeed_duration(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeed_duration", value) + + @_builtins.property + @pulumi.getter(name="succeedPct") + def succeed_pct(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeed_pct") + + @succeed_pct.setter + def succeed_pct(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeed_pct", value) + + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/_utilities.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/_utilities.py new file mode 100644 index 00000000..e2f4cfd3 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/_utilities.py @@ -0,0 +1,360 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + + +import asyncio +import functools +import importlib.metadata +import importlib.util +import inspect +import json +import os +import sys +import typing +import warnings +import base64 + +import pulumi +import pulumi.runtime +from pulumi.runtime.sync_await import _sync_await +from pulumi.runtime.proto import resource_pb2 + +from semver import VersionInfo as SemverVersion +from parver import Version as PEP440Version + +C = typing.TypeVar("C", bound=typing.Callable) + + +def get_env(*args): + for v in args: + value = os.getenv(v) + if value is not None: + return value + return None + + +def get_env_bool(*args): + str = get_env(*args) + if str is not None: + # NOTE: these values are taken from https://golang.org/src/strconv/atob.go?s=351:391#L1, which is what + # Terraform uses internally when parsing boolean values. + if str in ["1", "t", "T", "true", "TRUE", "True"]: + return True + if str in ["0", "f", "F", "false", "FALSE", "False"]: + return False + return None + + +def get_env_int(*args): + str = get_env(*args) + if str is not None: + try: + return int(str) + except: + return None + return None + + +def get_env_float(*args): + str = get_env(*args) + if str is not None: + try: + return float(str) + except: + return None + return None + + +def _get_semver_version(): + # __name__ is set to the fully-qualified name of the current module, In our case, it will be + # ._utilities. is the module we want to query the version for. + root_package, *rest = __name__.split('.') + + # pkg_resources uses setuptools to inspect the set of installed packages. We use it here to ask + # for the currently installed version of the root package (i.e. us) and get its version. + + # Unfortunately, PEP440 and semver differ slightly in incompatible ways. The Pulumi engine expects + # to receive a valid semver string when receiving requests from the language host, so it's our + # responsibility as the library to convert our own PEP440 version into a valid semver string. + + pep440_version_string = importlib.metadata.version(root_package) + pep440_version = PEP440Version.parse(pep440_version_string) + (major, minor, patch) = pep440_version.release + prerelease = None + if pep440_version.pre_tag == 'a': + prerelease = f"alpha.{pep440_version.pre}" + elif pep440_version.pre_tag == 'b': + prerelease = f"beta.{pep440_version.pre}" + elif pep440_version.pre_tag == 'rc': + prerelease = f"rc.{pep440_version.pre}" + elif pep440_version.dev is not None: + # PEP440 has explicit support for dev builds, while semver encodes them as "prerelease" versions. To bridge + # between the two, we convert our dev build version into a prerelease tag. This matches what all of our other + # packages do when constructing their own semver string. + prerelease = f"dev.{pep440_version.dev}" + elif pep440_version.local is not None: + # PEP440 only allows a small set of prerelease tags, so when converting an arbitrary prerelease, + # PypiVersion in /pkg/codegen/python/utilities.go converts it to a local version. Therefore, we need to + # do the reverse conversion here and set the local version as the prerelease tag. + prerelease = pep440_version.local + + return SemverVersion(major=major, minor=minor, patch=patch, prerelease=prerelease) + + +# Determine the version once and cache the value, which measurably improves program performance. +_version = _get_semver_version() +_version_str = str(_version) + +def get_resource_opts_defaults() -> pulumi.ResourceOptions: + return pulumi.ResourceOptions( + version=get_version(), + plugin_download_url=get_plugin_download_url(), + ) + +def get_invoke_opts_defaults() -> pulumi.InvokeOptions: + return pulumi.InvokeOptions( + version=get_version(), + plugin_download_url=get_plugin_download_url(), + ) + +def get_resource_args_opts(resource_args_type, resource_options_type, *args, **kwargs): + """ + Return the resource args and options given the *args and **kwargs of a resource's + __init__ method. + """ + + resource_args, opts = None, None + + # If the first item is the resource args type, save it and remove it from the args list. + if args and isinstance(args[0], resource_args_type): + resource_args, args = args[0], args[1:] + + # Now look at the first item in the args list again. + # If the first item is the resource options class, save it. + if args and isinstance(args[0], resource_options_type): + opts = args[0] + + # If resource_args is None, see if "args" is in kwargs, and, if so, if it's typed as the + # the resource args type. + if resource_args is None: + a = kwargs.get("args") + if isinstance(a, resource_args_type): + resource_args = a + + # If opts is None, look it up in kwargs. + if opts is None: + opts = kwargs.get("opts") + + return resource_args, opts + + +# Temporary: just use pulumi._utils.lazy_import once everyone upgrades. +def lazy_import(fullname): + + import pulumi._utils as u + f = getattr(u, 'lazy_import', None) + if f is None: + f = _lazy_import_temp + + return f(fullname) + + +# Copied from pulumi._utils.lazy_import, see comments there. +def _lazy_import_temp(fullname): + m = sys.modules.get(fullname, None) + if m is not None: + return m + + spec = importlib.util.find_spec(fullname) + + m = sys.modules.get(fullname, None) + if m is not None: + return m + + loader = importlib.util.LazyLoader(spec.loader) + spec.loader = loader + module = importlib.util.module_from_spec(spec) + + m = sys.modules.get(fullname, None) + if m is not None: + return m + + sys.modules[fullname] = module + loader.exec_module(module) + return module + + +class Package(pulumi.runtime.ResourcePackage): + def __init__(self, pkg_info): + super().__init__() + self.pkg_info = pkg_info + + def version(self): + return _version + + def construct_provider(self, name: str, typ: str, urn: str) -> pulumi.ProviderResource: + if typ != self.pkg_info['token']: + raise Exception(f"unknown provider type {typ}") + Provider = getattr(lazy_import(self.pkg_info['fqn']), self.pkg_info['class']) + return Provider(name, pulumi.ResourceOptions(urn=urn)) + + +class Module(pulumi.runtime.ResourceModule): + def __init__(self, mod_info): + super().__init__() + self.mod_info = mod_info + + def version(self): + return _version + + def construct(self, name: str, typ: str, urn: str) -> pulumi.Resource: + class_name = self.mod_info['classes'].get(typ, None) + + if class_name is None: + raise Exception(f"unknown resource type {typ}") + + TheClass = getattr(lazy_import(self.mod_info['fqn']), class_name) + return TheClass(name, pulumi.ResourceOptions(urn=urn)) + + +def register(resource_modules, resource_packages): + resource_modules = json.loads(resource_modules) + resource_packages = json.loads(resource_packages) + + for pkg_info in resource_packages: + pulumi.runtime.register_resource_package(pkg_info['pkg'], Package(pkg_info)) + + for mod_info in resource_modules: + pulumi.runtime.register_resource_module( + mod_info['pkg'], + mod_info['mod'], + Module(mod_info)) + + +_F = typing.TypeVar('_F', bound=typing.Callable[..., typing.Any]) + + +def lift_output_func(func: typing.Any) -> typing.Callable[[_F], _F]: + """Decorator internally used on {fn}_output lifted function versions + to implement them automatically from the un-lifted function.""" + + func_sig = inspect.signature(func) + + def lifted_func(*args, opts=None, **kwargs): + bound_args = func_sig.bind(*args, **kwargs) + # Convert tuple to list, see pulumi/pulumi#8172 + args_list = list(bound_args.args) + return pulumi.Output.from_input({ + 'args': args_list, + 'kwargs': bound_args.kwargs + }).apply(lambda resolved_args: func(*resolved_args['args'], + opts=opts, + **resolved_args['kwargs'])) + + return (lambda _: lifted_func) + + +def call_plain( + tok: str, + props: pulumi.Inputs, + res: typing.Optional[pulumi.Resource] = None, + typ: typing.Optional[type] = None, +) -> typing.Any: + """ + Wraps pulumi.runtime.plain to force the output and return it plainly. + """ + + output = pulumi.runtime.call(tok, props, res, typ) + + # Ingoring deps silently. They are typically non-empty, r.f() calls include r as a dependency. + result, known, secret, _ = _sync_await(asyncio.create_task(_await_output(output))) + + problem = None + if not known: + problem = ' an unknown value' + elif secret: + problem = ' a secret value' + + if problem: + raise AssertionError( + f"Plain resource method '{tok}' incorrectly returned {problem}. " + + "This is an error in the provider, please report this to the provider developer." + ) + + return result + + +async def _await_output(o: pulumi.Output[typing.Any]) -> typing.Tuple[object, bool, bool, set]: + return ( + await o._future, + await o._is_known, + await o._is_secret, + await o._resources, + ) + + +# This is included to provide an upgrade path for users who are using a version +# of the Pulumi SDK (<3.121.0) that does not include the `deprecated` decorator. +def deprecated(message: str) -> typing.Callable[[C], C]: + """ + Decorator to indicate a function is deprecated. + + As well as inserting appropriate statements to indicate that the function is + deprecated, this decorator also tags the function with a special attribute + so that Pulumi code can detect that it is deprecated and react appropriately + in certain situations. + + message is the deprecation message that should be printed if the function is called. + """ + + def decorator(fn: C) -> C: + if not callable(fn): + raise TypeError("Expected fn to be callable") + + @functools.wraps(fn) + def deprecated_fn(*args, **kwargs): + warnings.warn(message) + pulumi.warn(f"{fn.__name__} is deprecated: {message}") + + return fn(*args, **kwargs) + + deprecated_fn.__dict__["_pulumi_deprecated_callable"] = fn + return typing.cast(C, deprecated_fn) + + return decorator + +def get_plugin_download_url(): + return None + +def get_version(): + return "0.25.2" + +_package_lock = asyncio.Lock() +_package_ref = ... +async def get_package(): + global _package_ref + if _package_ref is ...: + if pulumi.runtime.settings._sync_monitor_supports_parameterization(): + async with _package_lock: + if _package_ref is ...: + monitor = pulumi.runtime.settings.get_monitor() + parameterization = resource_pb2.Parameterization( + name="seqera", + version=get_version(), + value=base64.b64decode("eyJyZW1vdGUiOnsidXJsIjoicmVnaXN0cnkudGVycmFmb3JtLmlvL3NlcWVyYWxhYnMvc2VxZXJhIiwidmVyc2lvbiI6IjAuMjUuMiJ9fQ=="), + ) + registerPackageResponse = monitor.RegisterPackage( + resource_pb2.RegisterPackageRequest( + name="terraform-provider", + version="0.13.0", + download_url=get_plugin_download_url(), + parameterization=parameterization, + )) + _package_ref = registerPackageResponse.ref + # TODO: This check is only needed for parameterized providers, normal providers can return None for get_package when we start + # using package with them. + if _package_ref is None or _package_ref is ...: + raise Exception("The Pulumi CLI does not support parameterization. Please update the Pulumi CLI.") + return _package_ref + \ No newline at end of file diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/action.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/action.py new file mode 100644 index 00000000..b7f4b577 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/action.py @@ -0,0 +1,556 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ActionArgs', 'Action'] + +@pulumi.input_type +class ActionArgs: + def __init__(__self__, *, + launch: pulumi.Input['ActionLaunchArgs'], + source: pulumi.Input[_builtins.str], + workspace_id: pulumi.Input[_builtins.float], + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Action resource. + :param pulumi.Input['ActionLaunchArgs'] launch: Requires replacement if changed. + :param pulumi.Input[_builtins.str] source: must be one of ["github", "tower"]; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + """ + pulumi.set(__self__, "launch", launch) + pulumi.set(__self__, "source", source) + pulumi.set(__self__, "workspace_id", workspace_id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def launch(self) -> pulumi.Input['ActionLaunchArgs']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch") + + @launch.setter + def launch(self, value: pulumi.Input['ActionLaunchArgs']): + pulumi.set(self, "launch", value) + + @_builtins.property + @pulumi.getter + def source(self) -> pulumi.Input[_builtins.str]: + """ + must be one of ["github", "tower"]; Requires replacement if changed. + """ + return pulumi.get(self, "source") + + @source.setter + def source(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "source", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _ActionState: + def __init__(__self__, *, + action_id: Optional[pulumi.Input[_builtins.str]] = None, + config: Optional[pulumi.Input['ActionConfigArgs']] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + event: Optional[pulumi.Input['ActionEventArgs']] = None, + hook_id: Optional[pulumi.Input[_builtins.str]] = None, + hook_url: Optional[pulumi.Input[_builtins.str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLabelArgs']]]] = None, + last_seen: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch: Optional[pulumi.Input['ActionLaunchArgs']] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + source: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Action resources. + :param pulumi.Input[_builtins.str] action_id: Action string identifier + :param pulumi.Input[_builtins.str] hook_id: Identifier for the webhook associated with this action + :param pulumi.Input[_builtins.str] hook_url: URL endpoint for the webhook that triggers this action + :param pulumi.Input['ActionLaunchArgs'] launch: Requires replacement if changed. + :param pulumi.Input[_builtins.str] message: Status or informational message about the action + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] source: must be one of ["github", "tower"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["CREATING", "ACTIVE", "ERROR", "PAUSED"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + if action_id is not None: + pulumi.set(__self__, "action_id", action_id) + if config is not None: + pulumi.set(__self__, "config", config) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if event is not None: + pulumi.set(__self__, "event", event) + if hook_id is not None: + pulumi.set(__self__, "hook_id", hook_id) + if hook_url is not None: + pulumi.set(__self__, "hook_url", hook_url) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_seen is not None: + pulumi.set(__self__, "last_seen", last_seen) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch is not None: + pulumi.set(__self__, "launch", launch) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if source is not None: + pulumi.set(__self__, "source", source) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="actionId") + def action_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Action string identifier + """ + return pulumi.get(self, "action_id") + + @action_id.setter + def action_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "action_id", value) + + @_builtins.property + @pulumi.getter + def config(self) -> Optional[pulumi.Input['ActionConfigArgs']]: + return pulumi.get(self, "config") + + @config.setter + def config(self, value: Optional[pulumi.Input['ActionConfigArgs']]): + pulumi.set(self, "config", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def event(self) -> Optional[pulumi.Input['ActionEventArgs']]: + return pulumi.get(self, "event") + + @event.setter + def event(self, value: Optional[pulumi.Input['ActionEventArgs']]): + pulumi.set(self, "event", value) + + @_builtins.property + @pulumi.getter(name="hookId") + def hook_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Identifier for the webhook associated with this action + """ + return pulumi.get(self, "hook_id") + + @hook_id.setter + def hook_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "hook_id", value) + + @_builtins.property + @pulumi.getter(name="hookUrl") + def hook_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + URL endpoint for the webhook that triggers this action + """ + return pulumi.get(self, "hook_url") + + @hook_url.setter + def hook_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "hook_url", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="lastSeen") + def last_seen(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_seen") + + @last_seen.setter + def last_seen(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_seen", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter + def launch(self) -> Optional[pulumi.Input['ActionLaunchArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch") + + @launch.setter + def launch(self, value: Optional[pulumi.Input['ActionLaunchArgs']]): + pulumi.set(self, "launch", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Status or informational message about the action + """ + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def source(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["github", "tower"]; Requires replacement if changed. + """ + return pulumi.get(self, "source") + + @source.setter + def source(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "source", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["CREATING", "ACTIVE", "ERROR", "PAUSED"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/action:Action") +class Action(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + launch: Optional[pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + source: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Action resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']] launch: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] source: must be one of ["github", "tower"]; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ActionArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Action resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param ActionArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(ActionArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + launch: Optional[pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + source: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ActionArgs.__new__(ActionArgs) + + if launch is None and not opts.urn: + raise TypeError("Missing required property 'launch'") + __props__.__dict__["launch"] = launch + __props__.__dict__["name"] = name + if source is None and not opts.urn: + raise TypeError("Missing required property 'source'") + __props__.__dict__["source"] = source + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["action_id"] = None + __props__.__dict__["config"] = None + __props__.__dict__["date_created"] = None + __props__.__dict__["event"] = None + __props__.__dict__["hook_id"] = None + __props__.__dict__["hook_url"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["last_seen"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["message"] = None + __props__.__dict__["status"] = None + super(Action, __self__).__init__( + 'seqera:index/action:Action', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + action_id: Optional[pulumi.Input[_builtins.str]] = None, + config: Optional[pulumi.Input[Union['ActionConfigArgs', 'ActionConfigArgsDict']]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + event: Optional[pulumi.Input[Union['ActionEventArgs', 'ActionEventArgsDict']]] = None, + hook_id: Optional[pulumi.Input[_builtins.str]] = None, + hook_url: Optional[pulumi.Input[_builtins.str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ActionLabelArgs', 'ActionLabelArgsDict']]]]] = None, + last_seen: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch: Optional[pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + source: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Action': + """ + Get an existing Action resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] action_id: Action string identifier + :param pulumi.Input[_builtins.str] hook_id: Identifier for the webhook associated with this action + :param pulumi.Input[_builtins.str] hook_url: URL endpoint for the webhook that triggers this action + :param pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']] launch: Requires replacement if changed. + :param pulumi.Input[_builtins.str] message: Status or informational message about the action + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] source: must be one of ["github", "tower"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["CREATING", "ACTIVE", "ERROR", "PAUSED"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ActionState.__new__(_ActionState) + + __props__.__dict__["action_id"] = action_id + __props__.__dict__["config"] = config + __props__.__dict__["date_created"] = date_created + __props__.__dict__["event"] = event + __props__.__dict__["hook_id"] = hook_id + __props__.__dict__["hook_url"] = hook_url + __props__.__dict__["labels"] = labels + __props__.__dict__["last_seen"] = last_seen + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["launch"] = launch + __props__.__dict__["message"] = message + __props__.__dict__["name"] = name + __props__.__dict__["source"] = source + __props__.__dict__["status"] = status + __props__.__dict__["workspace_id"] = workspace_id + return Action(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="actionId") + def action_id(self) -> pulumi.Output[_builtins.str]: + """ + Action string identifier + """ + return pulumi.get(self, "action_id") + + @_builtins.property + @pulumi.getter + def config(self) -> pulumi.Output['outputs.ActionConfig']: + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def event(self) -> pulumi.Output['outputs.ActionEvent']: + return pulumi.get(self, "event") + + @_builtins.property + @pulumi.getter(name="hookId") + def hook_id(self) -> pulumi.Output[_builtins.str]: + """ + Identifier for the webhook associated with this action + """ + return pulumi.get(self, "hook_id") + + @_builtins.property + @pulumi.getter(name="hookUrl") + def hook_url(self) -> pulumi.Output[_builtins.str]: + """ + URL endpoint for the webhook that triggers this action + """ + return pulumi.get(self, "hook_url") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.ActionLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastSeen") + def last_seen(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_seen") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def launch(self) -> pulumi.Output['outputs.ActionLaunch']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch") + + @_builtins.property + @pulumi.getter + def message(self) -> pulumi.Output[_builtins.str]: + """ + Status or informational message about the action + """ + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def source(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["github", "tower"]; Requires replacement if changed. + """ + return pulumi.get(self, "source") + + @_builtins.property + @pulumi.getter + def status(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["CREATING", "ACTIVE", "ERROR", "PAUSED"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/compute_env.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/compute_env.py new file mode 100644 index 00000000..ec06971e --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/compute_env.py @@ -0,0 +1,276 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ComputeEnvArgs', 'ComputeEnv'] + +@pulumi.input_type +class ComputeEnvArgs: + def __init__(__self__, *, + compute_env: pulumi.Input['ComputeEnvComputeEnvArgs'], + workspace_id: pulumi.Input[_builtins.float], + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None): + """ + The set of arguments for constructing a ComputeEnv resource. + :param pulumi.Input['ComputeEnvComputeEnvArgs'] compute_env: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env", compute_env) + pulumi.set(__self__, "workspace_id", workspace_id) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> pulumi.Input['ComputeEnvComputeEnvArgs']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: pulumi.Input['ComputeEnvComputeEnvArgs']): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + +@pulumi.input_type +class _ComputeEnvState: + def __init__(__self__, *, + compute_env: Optional[pulumi.Input['ComputeEnvComputeEnvArgs']] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering ComputeEnv resources. + :param pulumi.Input['ComputeEnvComputeEnvArgs'] compute_env: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Compute environment string identifier + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvArgs']]): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Compute environment string identifier + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/computeEnv:ComputeEnv") +class ComputeEnv(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + compute_env: Optional[pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a ComputeEnv resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']] compute_env: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ComputeEnvArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a ComputeEnv resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param ComputeEnvArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(ComputeEnvArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + compute_env: Optional[pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ComputeEnvArgs.__new__(ComputeEnvArgs) + + if compute_env is None and not opts.urn: + raise TypeError("Missing required property 'compute_env'") + __props__.__dict__["compute_env"] = compute_env + __props__.__dict__["label_ids"] = label_ids + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["compute_env_id"] = None + super(ComputeEnv, __self__).__init__( + 'seqera:index/computeEnv:ComputeEnv', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + compute_env: Optional[pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'ComputeEnv': + """ + Get an existing ComputeEnv resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']] compute_env: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Compute environment string identifier + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ComputeEnvState.__new__(_ComputeEnvState) + + __props__.__dict__["compute_env"] = compute_env + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["workspace_id"] = workspace_id + return ComputeEnv(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> pulumi.Output['outputs.ComputeEnvComputeEnv']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Output[_builtins.str]: + """ + Compute environment string identifier + """ + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.float]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/config/__init__.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/config/__init__.py new file mode 100644 index 00000000..43ec6e26 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/config/__init__.py @@ -0,0 +1,9 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import sys +from .vars import _ExportableConfig + +sys.modules[__name__].__class__ = _ExportableConfig diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/config/vars.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/config/vars.py new file mode 100644 index 00000000..0f78b6a4 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/config/vars.py @@ -0,0 +1,33 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from .. import _utilities + +import types + +__config__ = pulumi.Config('seqera') + + +class _ExportableConfig(types.ModuleType): + @_builtins.property + def bearer_auth(self) -> Optional[str]: + return __config__.get('bearerAuth') + + @_builtins.property + def server_url(self) -> Optional[str]: + """ + Server URL (defaults to https://api.cloud.seqera.io) + """ + return __config__.get('serverUrl') + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/credential.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/credential.py new file mode 100644 index 00000000..2fee60a7 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/credential.py @@ -0,0 +1,610 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['CredentialArgs', 'Credential'] + +@pulumi.input_type +class CredentialArgs: + def __init__(__self__, *, + keys: pulumi.Input['CredentialKeysArgs'], + provider_type: pulumi.Input[_builtins.str], + workspace_id: pulumi.Input[_builtins.float], + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Credential resource. + :param pulumi.Input[_builtins.str] provider_type: Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + :param pulumi.Input[_builtins.bool] checked: If set credentials deletion will be blocked by running jobs that depend on them + :param pulumi.Input[_builtins.str] credentials_id: Unique identifier for the credential (max 22 characters) + :param pulumi.Input[_builtins.str] description: Optional description explaining the purpose of the credential + :param pulumi.Input[_builtins.str] name: Display name for the credential (max 100 characters) + """ + pulumi.set(__self__, "keys", keys) + pulumi.set(__self__, "provider_type", provider_type) + pulumi.set(__self__, "workspace_id", workspace_id) + if base_url is not None: + pulumi.set(__self__, "base_url", base_url) + if category is not None: + pulumi.set(__self__, "category", category) + if checked is not None: + pulumi.set(__self__, "checked", checked) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def keys(self) -> pulumi.Input['CredentialKeysArgs']: + return pulumi.get(self, "keys") + + @keys.setter + def keys(self, value: pulumi.Input['CredentialKeysArgs']): + pulumi.set(self, "keys", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> pulumi.Input[_builtins.str]: + """ + Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="baseUrl") + def base_url(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "base_url") + + @base_url.setter + def base_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "base_url", value) + + @_builtins.property + @pulumi.getter + def category(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "category") + + @category.setter + def category(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "category", value) + + @_builtins.property + @pulumi.getter + def checked(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + If set credentials deletion will be blocked by running jobs that depend on them + """ + return pulumi.get(self, "checked") + + @checked.setter + def checked(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "checked", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the credential (max 22 characters) + """ + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Optional description explaining the purpose of the credential + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Display name for the credential (max 100 characters) + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _CredentialState: + def __init__(__self__, *, + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + keys: Optional[pulumi.Input['CredentialKeysArgs']] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Credential resources. + :param pulumi.Input[_builtins.bool] checked: If set credentials deletion will be blocked by running jobs that depend on them + :param pulumi.Input[_builtins.str] credentials_id: Unique identifier for the credential (max 22 characters) + :param pulumi.Input[_builtins.str] date_created: Timestamp when the credential was created + :param pulumi.Input[_builtins.bool] deleted: Flag indicating if the credential has been soft-deleted + :param pulumi.Input[_builtins.str] description: Optional description explaining the purpose of the credential + :param pulumi.Input[_builtins.str] last_used: Timestamp when the credential was last used + :param pulumi.Input[_builtins.str] name: Display name for the credential (max 100 characters) + :param pulumi.Input[_builtins.str] provider_type: Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if base_url is not None: + pulumi.set(__self__, "base_url", base_url) + if category is not None: + pulumi.set(__self__, "category", category) + if checked is not None: + pulumi.set(__self__, "checked", checked) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if keys is not None: + pulumi.set(__self__, "keys", keys) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="baseUrl") + def base_url(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "base_url") + + @base_url.setter + def base_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "base_url", value) + + @_builtins.property + @pulumi.getter + def category(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "category") + + @category.setter + def category(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "category", value) + + @_builtins.property + @pulumi.getter + def checked(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + If set credentials deletion will be blocked by running jobs that depend on them + """ + return pulumi.get(self, "checked") + + @checked.setter + def checked(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "checked", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the credential (max 22 characters) + """ + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the credential was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if the credential has been soft-deleted + """ + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Optional description explaining the purpose of the credential + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def keys(self) -> Optional[pulumi.Input['CredentialKeysArgs']]: + return pulumi.get(self, "keys") + + @keys.setter + def keys(self, value: Optional[pulumi.Input['CredentialKeysArgs']]): + pulumi.set(self, "keys", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the credential was last used + """ + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Display name for the credential (max 100 characters) + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/credential:Credential") +class Credential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + keys: Optional[pulumi.Input[Union['CredentialKeysArgs', 'CredentialKeysArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Credential resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] checked: If set credentials deletion will be blocked by running jobs that depend on them + :param pulumi.Input[_builtins.str] credentials_id: Unique identifier for the credential (max 22 characters) + :param pulumi.Input[_builtins.str] description: Optional description explaining the purpose of the credential + :param pulumi.Input[_builtins.str] name: Display name for the credential (max 100 characters) + :param pulumi.Input[_builtins.str] provider_type: Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: CredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Credential resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param CredentialArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(CredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + keys: Optional[pulumi.Input[Union['CredentialKeysArgs', 'CredentialKeysArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = CredentialArgs.__new__(CredentialArgs) + + __props__.__dict__["base_url"] = base_url + __props__.__dict__["category"] = category + __props__.__dict__["checked"] = checked + __props__.__dict__["credentials_id"] = credentials_id + __props__.__dict__["description"] = description + if keys is None and not opts.urn: + raise TypeError("Missing required property 'keys'") + __props__.__dict__["keys"] = keys + __props__.__dict__["name"] = name + if provider_type is None and not opts.urn: + raise TypeError("Missing required property 'provider_type'") + __props__.__dict__["provider_type"] = provider_type + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["date_created"] = None + __props__.__dict__["deleted"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["last_used"] = None + super(Credential, __self__).__init__( + 'seqera:index/credential:Credential', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + keys: Optional[pulumi.Input[Union['CredentialKeysArgs', 'CredentialKeysArgsDict']]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Credential': + """ + Get an existing Credential resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] checked: If set credentials deletion will be blocked by running jobs that depend on them + :param pulumi.Input[_builtins.str] credentials_id: Unique identifier for the credential (max 22 characters) + :param pulumi.Input[_builtins.str] date_created: Timestamp when the credential was created + :param pulumi.Input[_builtins.bool] deleted: Flag indicating if the credential has been soft-deleted + :param pulumi.Input[_builtins.str] description: Optional description explaining the purpose of the credential + :param pulumi.Input[_builtins.str] last_used: Timestamp when the credential was last used + :param pulumi.Input[_builtins.str] name: Display name for the credential (max 100 characters) + :param pulumi.Input[_builtins.str] provider_type: Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _CredentialState.__new__(_CredentialState) + + __props__.__dict__["base_url"] = base_url + __props__.__dict__["category"] = category + __props__.__dict__["checked"] = checked + __props__.__dict__["credentials_id"] = credentials_id + __props__.__dict__["date_created"] = date_created + __props__.__dict__["deleted"] = deleted + __props__.__dict__["description"] = description + __props__.__dict__["keys"] = keys + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["last_used"] = last_used + __props__.__dict__["name"] = name + __props__.__dict__["provider_type"] = provider_type + __props__.__dict__["workspace_id"] = workspace_id + return Credential(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="baseUrl") + def base_url(self) -> pulumi.Output[Optional[_builtins.str]]: + return pulumi.get(self, "base_url") + + @_builtins.property + @pulumi.getter + def category(self) -> pulumi.Output[Optional[_builtins.str]]: + return pulumi.get(self, "category") + + @_builtins.property + @pulumi.getter + def checked(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + If set credentials deletion will be blocked by running jobs that depend on them + """ + return pulumi.get(self, "checked") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> pulumi.Output[_builtins.str]: + """ + Unique identifier for the credential (max 22 characters) + """ + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + """ + Timestamp when the credential was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> pulumi.Output[_builtins.bool]: + """ + Flag indicating if the credential has been soft-deleted + """ + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Optional description explaining the purpose of the credential + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def keys(self) -> pulumi.Output['outputs.CredentialKeys']: + return pulumi.get(self, "keys") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> pulumi.Output[_builtins.str]: + """ + Timestamp when the credential was last used + """ + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Display name for the credential (max 100 characters) + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> pulumi.Output[_builtins.str]: + """ + Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/data_link.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/data_link.py new file mode 100644 index 00000000..31f5a9ff --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/data_link.py @@ -0,0 +1,601 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['DataLinkArgs', 'DataLink'] + +@pulumi.input_type +class DataLinkArgs: + def __init__(__self__, *, + credentials_id: pulumi.Input[_builtins.str], + description: pulumi.Input[_builtins.str], + provider_type: pulumi.Input[_builtins.str], + public_accessible: pulumi.Input[_builtins.bool], + resource_ref: pulumi.Input[_builtins.str], + type: pulumi.Input[_builtins.str], + workspace_id: pulumi.Input[_builtins.float], + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a DataLink resource. + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] public_accessible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] resource_ref: Requires replacement if changed. + :param pulumi.Input[_builtins.str] type: must be "bucket"; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "provider_type", provider_type) + pulumi.set(__self__, "public_accessible", public_accessible) + pulumi.set(__self__, "resource_ref", resource_ref) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "workspace_id", workspace_id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> pulumi.Input[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> pulumi.Input[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "public_accessible") + + @public_accessible.setter + def public_accessible(self, value: pulumi.Input[_builtins.bool]): + pulumi.set(self, "public_accessible", value) + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource_ref") + + @resource_ref.setter + def resource_ref(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "resource_ref", value) + + @_builtins.property + @pulumi.getter + def type(self) -> pulumi.Input[_builtins.str]: + """ + must be "bucket"; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _DataLinkState: + def __init__(__self__, *, + credentials: Optional[pulumi.Input[Sequence[pulumi.Input['DataLinkCredentialArgs']]]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + data_link_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + hidden: Optional[pulumi.Input[_builtins.bool]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering DataLink resources. + :param pulumi.Input[Sequence[pulumi.Input['DataLinkCredentialArgs']]] credentials: Array of credentials required to access the data link + :param pulumi.Input[_builtins.str] data_link_id: Unique identifier for the data link + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] public_accessible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Geographic region where the data link is hosted + :param pulumi.Input[_builtins.str] resource_ref: Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["VALID", "INVALID"] + :param pulumi.Input[_builtins.str] type: must be "bucket"; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if credentials is not None: + pulumi.set(__self__, "credentials", credentials) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if data_link_id is not None: + pulumi.set(__self__, "data_link_id", data_link_id) + if description is not None: + pulumi.set(__self__, "description", description) + if hidden is not None: + pulumi.set(__self__, "hidden", hidden) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + if public_accessible is not None: + pulumi.set(__self__, "public_accessible", public_accessible) + if region is not None: + pulumi.set(__self__, "region", region) + if resource_ref is not None: + pulumi.set(__self__, "resource_ref", resource_ref) + if status is not None: + pulumi.set(__self__, "status", status) + if type is not None: + pulumi.set(__self__, "type", type) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataLinkCredentialArgs']]]]: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @credentials.setter + def credentials(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataLinkCredentialArgs']]]]): + pulumi.set(self, "credentials", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @data_link_id.setter + def data_link_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "data_link_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def hidden(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "hidden") + + @hidden.setter + def hidden(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "hidden", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "public_accessible") + + @public_accessible.setter + def public_accessible(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "public_accessible", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource_ref") + + @resource_ref.setter + def resource_ref(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "resource_ref", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["VALID", "INVALID"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be "bucket"; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/dataLink:DataLink") +class DataLink(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a DataLink resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] public_accessible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] resource_ref: Requires replacement if changed. + :param pulumi.Input[_builtins.str] type: must be "bucket"; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DataLinkArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a DataLink resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param DataLinkArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(DataLinkArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = DataLinkArgs.__new__(DataLinkArgs) + + if credentials_id is None and not opts.urn: + raise TypeError("Missing required property 'credentials_id'") + __props__.__dict__["credentials_id"] = credentials_id + if description is None and not opts.urn: + raise TypeError("Missing required property 'description'") + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + if provider_type is None and not opts.urn: + raise TypeError("Missing required property 'provider_type'") + __props__.__dict__["provider_type"] = provider_type + if public_accessible is None and not opts.urn: + raise TypeError("Missing required property 'public_accessible'") + __props__.__dict__["public_accessible"] = public_accessible + if resource_ref is None and not opts.urn: + raise TypeError("Missing required property 'resource_ref'") + __props__.__dict__["resource_ref"] = resource_ref + if type is None and not opts.urn: + raise TypeError("Missing required property 'type'") + __props__.__dict__["type"] = type + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["credentials"] = None + __props__.__dict__["data_link_id"] = None + __props__.__dict__["hidden"] = None + __props__.__dict__["message"] = None + __props__.__dict__["region"] = None + __props__.__dict__["status"] = None + super(DataLink, __self__).__init__( + 'seqera:index/dataLink:DataLink', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credentials: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DataLinkCredentialArgs', 'DataLinkCredentialArgsDict']]]]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + data_link_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + hidden: Optional[pulumi.Input[_builtins.bool]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'DataLink': + """ + Get an existing DataLink resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[Union['DataLinkCredentialArgs', 'DataLinkCredentialArgsDict']]]] credentials: Array of credentials required to access the data link + :param pulumi.Input[_builtins.str] data_link_id: Unique identifier for the data link + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] public_accessible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Geographic region where the data link is hosted + :param pulumi.Input[_builtins.str] resource_ref: Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["VALID", "INVALID"] + :param pulumi.Input[_builtins.str] type: must be "bucket"; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DataLinkState.__new__(_DataLinkState) + + __props__.__dict__["credentials"] = credentials + __props__.__dict__["credentials_id"] = credentials_id + __props__.__dict__["data_link_id"] = data_link_id + __props__.__dict__["description"] = description + __props__.__dict__["hidden"] = hidden + __props__.__dict__["message"] = message + __props__.__dict__["name"] = name + __props__.__dict__["provider_type"] = provider_type + __props__.__dict__["public_accessible"] = public_accessible + __props__.__dict__["region"] = region + __props__.__dict__["resource_ref"] = resource_ref + __props__.__dict__["status"] = status + __props__.__dict__["type"] = type + __props__.__dict__["workspace_id"] = workspace_id + return DataLink(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter + def credentials(self) -> pulumi.Output[Sequence['outputs.DataLinkCredential']]: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> pulumi.Output[_builtins.str]: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def hidden(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "hidden") + + @_builtins.property + @pulumi.getter + def message(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + """ + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> pulumi.Output[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "public_accessible") + + @_builtins.property + @pulumi.getter + def region(self) -> pulumi.Output[_builtins.str]: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource_ref") + + @_builtins.property + @pulumi.getter + def status(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["VALID", "INVALID"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def type(self) -> pulumi.Output[_builtins.str]: + """ + must be "bucket"; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/datasets.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/datasets.py new file mode 100644 index 00000000..94e03e62 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/datasets.py @@ -0,0 +1,341 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['DatasetsArgs', 'Datasets'] + +@pulumi.input_type +class DatasetsArgs: + def __init__(__self__, *, + workspace_id: pulumi.Input[_builtins.float], + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Datasets resource. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + """ + pulumi.set(__self__, "workspace_id", workspace_id) + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _DatasetsState: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + media_type: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Datasets resources. + :param pulumi.Input[_builtins.bool] deleted: Read-only flag indicating if the dataset has been deleted + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] media_type: MIME type or media type of the dataset content (max 80 characters) + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if media_type is not None: + pulumi.set(__self__, "media_type", media_type) + if name is not None: + pulumi.set(__self__, "name", name) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Read-only flag indicating if the dataset has been deleted + """ + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="mediaType") + def media_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + MIME type or media type of the dataset content (max 80 characters) + """ + return pulumi.get(self, "media_type") + + @media_type.setter + def media_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "media_type", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/datasets:Datasets") +class Datasets(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Datasets resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DatasetsArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Datasets resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param DatasetsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(DatasetsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = DatasetsArgs.__new__(DatasetsArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["date_created"] = None + __props__.__dict__["deleted"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["media_type"] = None + super(Datasets, __self__).__init__( + 'seqera:index/datasets:Datasets', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + media_type: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Datasets': + """ + Get an existing Datasets resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] deleted: Read-only flag indicating if the dataset has been deleted + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] media_type: MIME type or media type of the dataset content (max 80 characters) + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DatasetsState.__new__(_DatasetsState) + + __props__.__dict__["date_created"] = date_created + __props__.__dict__["deleted"] = deleted + __props__.__dict__["description"] = description + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["media_type"] = media_type + __props__.__dict__["name"] = name + __props__.__dict__["workspace_id"] = workspace_id + return Datasets(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> pulumi.Output[_builtins.bool]: + """ + Read-only flag indicating if the dataset has been deleted + """ + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="mediaType") + def media_type(self) -> pulumi.Output[_builtins.str]: + """ + MIME type or media type of the dataset content (max 80 characters) + """ + return pulumi.get(self, "media_type") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_action.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_action.py new file mode 100644 index 00000000..87125ed0 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_action.py @@ -0,0 +1,256 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetActionResult', + 'AwaitableGetActionResult', + 'get_action', + 'get_action_output', +] + +@pulumi.output_type +class GetActionResult: + """ + A collection of values returned by getAction. + """ + def __init__(__self__, action_id=None, attributes=None, config=None, date_created=None, event=None, hook_id=None, hook_url=None, id=None, labels=None, last_seen=None, last_updated=None, launch=None, message=None, name=None, source=None, status=None, workspace_id=None): + if action_id and not isinstance(action_id, str): + raise TypeError("Expected argument 'action_id' to be a str") + pulumi.set(__self__, "action_id", action_id) + if attributes and not isinstance(attributes, list): + raise TypeError("Expected argument 'attributes' to be a list") + pulumi.set(__self__, "attributes", attributes) + if config and not isinstance(config, dict): + raise TypeError("Expected argument 'config' to be a dict") + pulumi.set(__self__, "config", config) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if event and not isinstance(event, dict): + raise TypeError("Expected argument 'event' to be a dict") + pulumi.set(__self__, "event", event) + if hook_id and not isinstance(hook_id, str): + raise TypeError("Expected argument 'hook_id' to be a str") + pulumi.set(__self__, "hook_id", hook_id) + if hook_url and not isinstance(hook_url, str): + raise TypeError("Expected argument 'hook_url' to be a str") + pulumi.set(__self__, "hook_url", hook_url) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if last_seen and not isinstance(last_seen, str): + raise TypeError("Expected argument 'last_seen' to be a str") + pulumi.set(__self__, "last_seen", last_seen) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if launch and not isinstance(launch, dict): + raise TypeError("Expected argument 'launch' to be a dict") + pulumi.set(__self__, "launch", launch) + if message and not isinstance(message, str): + raise TypeError("Expected argument 'message' to be a str") + pulumi.set(__self__, "message", message) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if source and not isinstance(source, str): + raise TypeError("Expected argument 'source' to be a str") + pulumi.set(__self__, "source", source) + if status and not isinstance(status, str): + raise TypeError("Expected argument 'status' to be a str") + pulumi.set(__self__, "status", status) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="actionId") + def action_id(self) -> _builtins.str: + return pulumi.get(self, "action_id") + + @_builtins.property + @pulumi.getter + def attributes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "attributes") + + @_builtins.property + @pulumi.getter + def config(self) -> 'outputs.GetActionConfigResult': + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def event(self) -> 'outputs.GetActionEventResult': + return pulumi.get(self, "event") + + @_builtins.property + @pulumi.getter(name="hookId") + def hook_id(self) -> _builtins.str: + return pulumi.get(self, "hook_id") + + @_builtins.property + @pulumi.getter(name="hookUrl") + def hook_url(self) -> _builtins.str: + return pulumi.get(self, "hook_url") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetActionLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastSeen") + def last_seen(self) -> _builtins.str: + return pulumi.get(self, "last_seen") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def launch(self) -> 'outputs.GetActionLaunchResult': + return pulumi.get(self, "launch") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def source(self) -> _builtins.str: + return pulumi.get(self, "source") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetActionResult(GetActionResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetActionResult( + action_id=self.action_id, + attributes=self.attributes, + config=self.config, + date_created=self.date_created, + event=self.event, + hook_id=self.hook_id, + hook_url=self.hook_url, + id=self.id, + labels=self.labels, + last_seen=self.last_seen, + last_updated=self.last_updated, + launch=self.launch, + message=self.message, + name=self.name, + source=self.source, + status=self.status, + workspace_id=self.workspace_id) + + +def get_action(action_id: Optional[_builtins.str] = None, + attributes: Optional[Sequence[_builtins.str]] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetActionResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['actionId'] = action_id + __args__['attributes'] = attributes + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getAction:getAction', __args__, opts=opts, typ=GetActionResult, package_ref=_utilities.get_package()).value + + return AwaitableGetActionResult( + action_id=pulumi.get(__ret__, 'action_id'), + attributes=pulumi.get(__ret__, 'attributes'), + config=pulumi.get(__ret__, 'config'), + date_created=pulumi.get(__ret__, 'date_created'), + event=pulumi.get(__ret__, 'event'), + hook_id=pulumi.get(__ret__, 'hook_id'), + hook_url=pulumi.get(__ret__, 'hook_url'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + last_seen=pulumi.get(__ret__, 'last_seen'), + last_updated=pulumi.get(__ret__, 'last_updated'), + launch=pulumi.get(__ret__, 'launch'), + message=pulumi.get(__ret__, 'message'), + name=pulumi.get(__ret__, 'name'), + source=pulumi.get(__ret__, 'source'), + status=pulumi.get(__ret__, 'status'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_action_output(action_id: Optional[pulumi.Input[_builtins.str]] = None, + attributes: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetActionResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['actionId'] = action_id + __args__['attributes'] = attributes + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getAction:getAction', __args__, opts=opts, typ=GetActionResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetActionResult( + action_id=pulumi.get(__response__, 'action_id'), + attributes=pulumi.get(__response__, 'attributes'), + config=pulumi.get(__response__, 'config'), + date_created=pulumi.get(__response__, 'date_created'), + event=pulumi.get(__response__, 'event'), + hook_id=pulumi.get(__response__, 'hook_id'), + hook_url=pulumi.get(__response__, 'hook_url'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + last_seen=pulumi.get(__response__, 'last_seen'), + last_updated=pulumi.get(__response__, 'last_updated'), + launch=pulumi.get(__response__, 'launch'), + message=pulumi.get(__response__, 'message'), + name=pulumi.get(__response__, 'name'), + source=pulumi.get(__response__, 'source'), + status=pulumi.get(__response__, 'status'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_compute_env.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_compute_env.py new file mode 100644 index 00000000..b55e68cb --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_compute_env.py @@ -0,0 +1,127 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetComputeEnvResult', + 'AwaitableGetComputeEnvResult', + 'get_compute_env', + 'get_compute_env_output', +] + +@pulumi.output_type +class GetComputeEnvResult: + """ + A collection of values returned by getComputeEnv. + """ + def __init__(__self__, attributes=None, compute_env=None, compute_env_id=None, id=None, workspace_id=None): + if attributes and not isinstance(attributes, list): + raise TypeError("Expected argument 'attributes' to be a list") + pulumi.set(__self__, "attributes", attributes) + if compute_env and not isinstance(compute_env, dict): + raise TypeError("Expected argument 'compute_env' to be a dict") + pulumi.set(__self__, "compute_env", compute_env) + if compute_env_id and not isinstance(compute_env_id, str): + raise TypeError("Expected argument 'compute_env_id' to be a str") + pulumi.set(__self__, "compute_env_id", compute_env_id) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def attributes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "attributes") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> 'outputs.GetComputeEnvComputeEnvResult': + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetComputeEnvResult(GetComputeEnvResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetComputeEnvResult( + attributes=self.attributes, + compute_env=self.compute_env, + compute_env_id=self.compute_env_id, + id=self.id, + workspace_id=self.workspace_id) + + +def get_compute_env(attributes: Optional[Sequence[_builtins.str]] = None, + compute_env_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetComputeEnvResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['computeEnvId'] = compute_env_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getComputeEnv:getComputeEnv', __args__, opts=opts, typ=GetComputeEnvResult, package_ref=_utilities.get_package()).value + + return AwaitableGetComputeEnvResult( + attributes=pulumi.get(__ret__, 'attributes'), + compute_env=pulumi.get(__ret__, 'compute_env'), + compute_env_id=pulumi.get(__ret__, 'compute_env_id'), + id=pulumi.get(__ret__, 'id'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_compute_env_output(attributes: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetComputeEnvResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['computeEnvId'] = compute_env_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getComputeEnv:getComputeEnv', __args__, opts=opts, typ=GetComputeEnvResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetComputeEnvResult( + attributes=pulumi.get(__response__, 'attributes'), + compute_env=pulumi.get(__response__, 'compute_env'), + compute_env_id=pulumi.get(__response__, 'compute_env_id'), + id=pulumi.get(__response__, 'id'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_credential.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_credential.py new file mode 100644 index 00000000..2c79ce65 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_credential.py @@ -0,0 +1,211 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetCredentialResult', + 'AwaitableGetCredentialResult', + 'get_credential', + 'get_credential_output', +] + +@pulumi.output_type +class GetCredentialResult: + """ + A collection of values returned by getCredential. + """ + def __init__(__self__, base_url=None, category=None, credentials_id=None, date_created=None, deleted=None, description=None, id=None, keys=None, last_updated=None, last_used=None, name=None, provider_type=None, workspace_id=None): + if base_url and not isinstance(base_url, str): + raise TypeError("Expected argument 'base_url' to be a str") + pulumi.set(__self__, "base_url", base_url) + if category and not isinstance(category, str): + raise TypeError("Expected argument 'category' to be a str") + pulumi.set(__self__, "category", category) + if credentials_id and not isinstance(credentials_id, str): + raise TypeError("Expected argument 'credentials_id' to be a str") + pulumi.set(__self__, "credentials_id", credentials_id) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if deleted and not isinstance(deleted, bool): + raise TypeError("Expected argument 'deleted' to be a bool") + pulumi.set(__self__, "deleted", deleted) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if keys and not isinstance(keys, dict): + raise TypeError("Expected argument 'keys' to be a dict") + pulumi.set(__self__, "keys", keys) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if last_used and not isinstance(last_used, str): + raise TypeError("Expected argument 'last_used' to be a str") + pulumi.set(__self__, "last_used", last_used) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if provider_type and not isinstance(provider_type, str): + raise TypeError("Expected argument 'provider_type' to be a str") + pulumi.set(__self__, "provider_type", provider_type) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="baseUrl") + def base_url(self) -> _builtins.str: + return pulumi.get(self, "base_url") + + @_builtins.property + @pulumi.getter + def category(self) -> _builtins.str: + return pulumi.get(self, "category") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def keys(self) -> 'outputs.GetCredentialKeysResult': + return pulumi.get(self, "keys") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetCredentialResult(GetCredentialResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetCredentialResult( + base_url=self.base_url, + category=self.category, + credentials_id=self.credentials_id, + date_created=self.date_created, + deleted=self.deleted, + description=self.description, + id=self.id, + keys=self.keys, + last_updated=self.last_updated, + last_used=self.last_used, + name=self.name, + provider_type=self.provider_type, + workspace_id=self.workspace_id) + + +def get_credential(credentials_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetCredentialResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['credentialsId'] = credentials_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getCredential:getCredential', __args__, opts=opts, typ=GetCredentialResult, package_ref=_utilities.get_package()).value + + return AwaitableGetCredentialResult( + base_url=pulumi.get(__ret__, 'base_url'), + category=pulumi.get(__ret__, 'category'), + credentials_id=pulumi.get(__ret__, 'credentials_id'), + date_created=pulumi.get(__ret__, 'date_created'), + deleted=pulumi.get(__ret__, 'deleted'), + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + keys=pulumi.get(__ret__, 'keys'), + last_updated=pulumi.get(__ret__, 'last_updated'), + last_used=pulumi.get(__ret__, 'last_used'), + name=pulumi.get(__ret__, 'name'), + provider_type=pulumi.get(__ret__, 'provider_type'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_credential_output(credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetCredentialResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['credentialsId'] = credentials_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getCredential:getCredential', __args__, opts=opts, typ=GetCredentialResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetCredentialResult( + base_url=pulumi.get(__response__, 'base_url'), + category=pulumi.get(__response__, 'category'), + credentials_id=pulumi.get(__response__, 'credentials_id'), + date_created=pulumi.get(__response__, 'date_created'), + deleted=pulumi.get(__response__, 'deleted'), + description=pulumi.get(__response__, 'description'), + id=pulumi.get(__response__, 'id'), + keys=pulumi.get(__response__, 'keys'), + last_updated=pulumi.get(__response__, 'last_updated'), + last_used=pulumi.get(__response__, 'last_used'), + name=pulumi.get(__response__, 'name'), + provider_type=pulumi.get(__response__, 'provider_type'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_data_link.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_data_link.py new file mode 100644 index 00000000..c180a771 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_data_link.py @@ -0,0 +1,237 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetDataLinkResult', + 'AwaitableGetDataLinkResult', + 'get_data_link', + 'get_data_link_output', +] + +@pulumi.output_type +class GetDataLinkResult: + """ + A collection of values returned by getDataLink. + """ + def __init__(__self__, credentials=None, credentials_id=None, data_link_id=None, description=None, hidden=None, id=None, message=None, name=None, provider_type=None, public_accessible=None, region=None, resource_ref=None, status=None, type=None, workspace_id=None): + if credentials and not isinstance(credentials, list): + raise TypeError("Expected argument 'credentials' to be a list") + pulumi.set(__self__, "credentials", credentials) + if credentials_id and not isinstance(credentials_id, str): + raise TypeError("Expected argument 'credentials_id' to be a str") + pulumi.set(__self__, "credentials_id", credentials_id) + if data_link_id and not isinstance(data_link_id, str): + raise TypeError("Expected argument 'data_link_id' to be a str") + pulumi.set(__self__, "data_link_id", data_link_id) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if hidden and not isinstance(hidden, bool): + raise TypeError("Expected argument 'hidden' to be a bool") + pulumi.set(__self__, "hidden", hidden) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if message and not isinstance(message, str): + raise TypeError("Expected argument 'message' to be a str") + pulumi.set(__self__, "message", message) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if provider_type and not isinstance(provider_type, str): + raise TypeError("Expected argument 'provider_type' to be a str") + pulumi.set(__self__, "provider_type", provider_type) + if public_accessible and not isinstance(public_accessible, bool): + raise TypeError("Expected argument 'public_accessible' to be a bool") + pulumi.set(__self__, "public_accessible", public_accessible) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if resource_ref and not isinstance(resource_ref, str): + raise TypeError("Expected argument 'resource_ref' to be a str") + pulumi.set(__self__, "resource_ref", resource_ref) + if status and not isinstance(status, str): + raise TypeError("Expected argument 'status' to be a str") + pulumi.set(__self__, "status", status) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Sequence['outputs.GetDataLinkCredentialResult']: + return pulumi.get(self, "credentials") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> _builtins.str: + return pulumi.get(self, "data_link_id") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def hidden(self) -> _builtins.bool: + return pulumi.get(self, "hidden") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> _builtins.bool: + return pulumi.get(self, "public_accessible") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> _builtins.str: + return pulumi.get(self, "resource_ref") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetDataLinkResult(GetDataLinkResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetDataLinkResult( + credentials=self.credentials, + credentials_id=self.credentials_id, + data_link_id=self.data_link_id, + description=self.description, + hidden=self.hidden, + id=self.id, + message=self.message, + name=self.name, + provider_type=self.provider_type, + public_accessible=self.public_accessible, + region=self.region, + resource_ref=self.resource_ref, + status=self.status, + type=self.type, + workspace_id=self.workspace_id) + + +def get_data_link(credentials_id: Optional[_builtins.str] = None, + data_link_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDataLinkResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['credentialsId'] = credentials_id + __args__['dataLinkId'] = data_link_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getDataLink:getDataLink', __args__, opts=opts, typ=GetDataLinkResult, package_ref=_utilities.get_package()).value + + return AwaitableGetDataLinkResult( + credentials=pulumi.get(__ret__, 'credentials'), + credentials_id=pulumi.get(__ret__, 'credentials_id'), + data_link_id=pulumi.get(__ret__, 'data_link_id'), + description=pulumi.get(__ret__, 'description'), + hidden=pulumi.get(__ret__, 'hidden'), + id=pulumi.get(__ret__, 'id'), + message=pulumi.get(__ret__, 'message'), + name=pulumi.get(__ret__, 'name'), + provider_type=pulumi.get(__ret__, 'provider_type'), + public_accessible=pulumi.get(__ret__, 'public_accessible'), + region=pulumi.get(__ret__, 'region'), + resource_ref=pulumi.get(__ret__, 'resource_ref'), + status=pulumi.get(__ret__, 'status'), + type=pulumi.get(__ret__, 'type'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_data_link_output(credentials_id: Optional[pulumi.Input[Optional[_builtins.str]]] = None, + data_link_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDataLinkResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['credentialsId'] = credentials_id + __args__['dataLinkId'] = data_link_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getDataLink:getDataLink', __args__, opts=opts, typ=GetDataLinkResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetDataLinkResult( + credentials=pulumi.get(__response__, 'credentials'), + credentials_id=pulumi.get(__response__, 'credentials_id'), + data_link_id=pulumi.get(__response__, 'data_link_id'), + description=pulumi.get(__response__, 'description'), + hidden=pulumi.get(__response__, 'hidden'), + id=pulumi.get(__response__, 'id'), + message=pulumi.get(__response__, 'message'), + name=pulumi.get(__response__, 'name'), + provider_type=pulumi.get(__response__, 'provider_type'), + public_accessible=pulumi.get(__response__, 'public_accessible'), + region=pulumi.get(__response__, 'region'), + resource_ref=pulumi.get(__response__, 'resource_ref'), + status=pulumi.get(__response__, 'status'), + type=pulumi.get(__response__, 'type'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_dataset.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_dataset.py new file mode 100644 index 00000000..a77634c8 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_dataset.py @@ -0,0 +1,112 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetDatasetResult', + 'AwaitableGetDatasetResult', + 'get_dataset', + 'get_dataset_output', +] + +@pulumi.output_type +class GetDatasetResult: + """ + A collection of values returned by getDataset. + """ + def __init__(__self__, dataset=None, dataset_id=None, id=None, workspace_id=None): + if dataset and not isinstance(dataset, dict): + raise TypeError("Expected argument 'dataset' to be a dict") + pulumi.set(__self__, "dataset", dataset) + if dataset_id and not isinstance(dataset_id, str): + raise TypeError("Expected argument 'dataset_id' to be a str") + pulumi.set(__self__, "dataset_id", dataset_id) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def dataset(self) -> 'outputs.GetDatasetDatasetResult': + return pulumi.get(self, "dataset") + + @_builtins.property + @pulumi.getter(name="datasetId") + def dataset_id(self) -> _builtins.str: + return pulumi.get(self, "dataset_id") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetDatasetResult(GetDatasetResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetDatasetResult( + dataset=self.dataset, + dataset_id=self.dataset_id, + id=self.id, + workspace_id=self.workspace_id) + + +def get_dataset(dataset_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatasetResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['datasetId'] = dataset_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getDataset:getDataset', __args__, opts=opts, typ=GetDatasetResult, package_ref=_utilities.get_package()).value + + return AwaitableGetDatasetResult( + dataset=pulumi.get(__ret__, 'dataset'), + dataset_id=pulumi.get(__ret__, 'dataset_id'), + id=pulumi.get(__ret__, 'id'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_dataset_output(dataset_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatasetResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['datasetId'] = dataset_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getDataset:getDataset', __args__, opts=opts, typ=GetDatasetResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetDatasetResult( + dataset=pulumi.get(__response__, 'dataset'), + dataset_id=pulumi.get(__response__, 'dataset_id'), + id=pulumi.get(__response__, 'id'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_labels.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_labels.py new file mode 100644 index 00000000..6c86d322 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_labels.py @@ -0,0 +1,183 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetLabelsResult', + 'AwaitableGetLabelsResult', + 'get_labels', + 'get_labels_output', +] + +@pulumi.output_type +class GetLabelsResult: + """ + A collection of values returned by getLabels. + """ + def __init__(__self__, id=None, is_default=None, labels=None, max=None, offset=None, search=None, total_size=None, type=None, workspace_id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if is_default and not isinstance(is_default, bool): + raise TypeError("Expected argument 'is_default' to be a bool") + pulumi.set(__self__, "is_default", is_default) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if max and not isinstance(max, float): + raise TypeError("Expected argument 'max' to be a float") + pulumi.set(__self__, "max", max) + if offset and not isinstance(offset, float): + raise TypeError("Expected argument 'offset' to be a float") + pulumi.set(__self__, "offset", offset) + if search and not isinstance(search, str): + raise TypeError("Expected argument 'search' to be a str") + pulumi.set(__self__, "search", search) + if total_size and not isinstance(total_size, float): + raise TypeError("Expected argument 'total_size' to be a float") + pulumi.set(__self__, "total_size", total_size) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetLabelsLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def max(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max") + + @_builtins.property + @pulumi.getter + def offset(self) -> Optional[_builtins.float]: + return pulumi.get(self, "offset") + + @_builtins.property + @pulumi.getter + def search(self) -> Optional[_builtins.str]: + return pulumi.get(self, "search") + + @_builtins.property + @pulumi.getter(name="totalSize") + def total_size(self) -> _builtins.float: + return pulumi.get(self, "total_size") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetLabelsResult(GetLabelsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetLabelsResult( + id=self.id, + is_default=self.is_default, + labels=self.labels, + max=self.max, + offset=self.offset, + search=self.search, + total_size=self.total_size, + type=self.type, + workspace_id=self.workspace_id) + + +def get_labels(is_default: Optional[_builtins.bool] = None, + max: Optional[_builtins.float] = None, + offset: Optional[_builtins.float] = None, + search: Optional[_builtins.str] = None, + type: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLabelsResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['isDefault'] = is_default + __args__['max'] = max + __args__['offset'] = offset + __args__['search'] = search + __args__['type'] = type + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getLabels:getLabels', __args__, opts=opts, typ=GetLabelsResult, package_ref=_utilities.get_package()).value + + return AwaitableGetLabelsResult( + id=pulumi.get(__ret__, 'id'), + is_default=pulumi.get(__ret__, 'is_default'), + labels=pulumi.get(__ret__, 'labels'), + max=pulumi.get(__ret__, 'max'), + offset=pulumi.get(__ret__, 'offset'), + search=pulumi.get(__ret__, 'search'), + total_size=pulumi.get(__ret__, 'total_size'), + type=pulumi.get(__ret__, 'type'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_labels_output(is_default: Optional[pulumi.Input[Optional[_builtins.bool]]] = None, + max: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + offset: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + search: Optional[pulumi.Input[Optional[_builtins.str]]] = None, + type: Optional[pulumi.Input[Optional[_builtins.str]]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetLabelsResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['isDefault'] = is_default + __args__['max'] = max + __args__['offset'] = offset + __args__['search'] = search + __args__['type'] = type + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getLabels:getLabels', __args__, opts=opts, typ=GetLabelsResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetLabelsResult( + id=pulumi.get(__response__, 'id'), + is_default=pulumi.get(__response__, 'is_default'), + labels=pulumi.get(__response__, 'labels'), + max=pulumi.get(__response__, 'max'), + offset=pulumi.get(__response__, 'offset'), + search=pulumi.get(__response__, 'search'), + total_size=pulumi.get(__response__, 'total_size'), + type=pulumi.get(__response__, 'type'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_orgs.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_orgs.py new file mode 100644 index 00000000..2da64c18 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_orgs.py @@ -0,0 +1,207 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetOrgsResult', + 'AwaitableGetOrgsResult', + 'get_orgs', + 'get_orgs_output', +] + +@pulumi.output_type +class GetOrgsResult: + """ + A collection of values returned by getOrgs. + """ + def __init__(__self__, description=None, full_name=None, id=None, location=None, logo_id=None, logo_url=None, member_id=None, member_role=None, name=None, org_id=None, paying=None, type=None, website=None): + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if full_name and not isinstance(full_name, str): + raise TypeError("Expected argument 'full_name' to be a str") + pulumi.set(__self__, "full_name", full_name) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if location and not isinstance(location, str): + raise TypeError("Expected argument 'location' to be a str") + pulumi.set(__self__, "location", location) + if logo_id and not isinstance(logo_id, str): + raise TypeError("Expected argument 'logo_id' to be a str") + pulumi.set(__self__, "logo_id", logo_id) + if logo_url and not isinstance(logo_url, str): + raise TypeError("Expected argument 'logo_url' to be a str") + pulumi.set(__self__, "logo_url", logo_url) + if member_id and not isinstance(member_id, float): + raise TypeError("Expected argument 'member_id' to be a float") + pulumi.set(__self__, "member_id", member_id) + if member_role and not isinstance(member_role, str): + raise TypeError("Expected argument 'member_role' to be a str") + pulumi.set(__self__, "member_role", member_role) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if paying and not isinstance(paying, bool): + raise TypeError("Expected argument 'paying' to be a bool") + pulumi.set(__self__, "paying", paying) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + if website and not isinstance(website, str): + raise TypeError("Expected argument 'website' to be a str") + pulumi.set(__self__, "website", website) + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> _builtins.str: + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="logoId") + def logo_id(self) -> _builtins.str: + return pulumi.get(self, "logo_id") + + @_builtins.property + @pulumi.getter(name="logoUrl") + def logo_url(self) -> _builtins.str: + return pulumi.get(self, "logo_url") + + @_builtins.property + @pulumi.getter(name="memberId") + def member_id(self) -> _builtins.float: + return pulumi.get(self, "member_id") + + @_builtins.property + @pulumi.getter(name="memberRole") + def member_role(self) -> _builtins.str: + return pulumi.get(self, "member_role") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def paying(self) -> _builtins.bool: + return pulumi.get(self, "paying") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter + def website(self) -> _builtins.str: + return pulumi.get(self, "website") + + +class AwaitableGetOrgsResult(GetOrgsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetOrgsResult( + description=self.description, + full_name=self.full_name, + id=self.id, + location=self.location, + logo_id=self.logo_id, + logo_url=self.logo_url, + member_id=self.member_id, + member_role=self.member_role, + name=self.name, + org_id=self.org_id, + paying=self.paying, + type=self.type, + website=self.website) + + +def get_orgs(org_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetOrgsResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getOrgs:getOrgs', __args__, opts=opts, typ=GetOrgsResult, package_ref=_utilities.get_package()).value + + return AwaitableGetOrgsResult( + description=pulumi.get(__ret__, 'description'), + full_name=pulumi.get(__ret__, 'full_name'), + id=pulumi.get(__ret__, 'id'), + location=pulumi.get(__ret__, 'location'), + logo_id=pulumi.get(__ret__, 'logo_id'), + logo_url=pulumi.get(__ret__, 'logo_url'), + member_id=pulumi.get(__ret__, 'member_id'), + member_role=pulumi.get(__ret__, 'member_role'), + name=pulumi.get(__ret__, 'name'), + org_id=pulumi.get(__ret__, 'org_id'), + paying=pulumi.get(__ret__, 'paying'), + type=pulumi.get(__ret__, 'type'), + website=pulumi.get(__ret__, 'website')) +def get_orgs_output(org_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetOrgsResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getOrgs:getOrgs', __args__, opts=opts, typ=GetOrgsResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetOrgsResult( + description=pulumi.get(__response__, 'description'), + full_name=pulumi.get(__response__, 'full_name'), + id=pulumi.get(__response__, 'id'), + location=pulumi.get(__response__, 'location'), + logo_id=pulumi.get(__response__, 'logo_id'), + logo_url=pulumi.get(__response__, 'logo_url'), + member_id=pulumi.get(__response__, 'member_id'), + member_role=pulumi.get(__response__, 'member_role'), + name=pulumi.get(__response__, 'name'), + org_id=pulumi.get(__response__, 'org_id'), + paying=pulumi.get(__response__, 'paying'), + type=pulumi.get(__response__, 'type'), + website=pulumi.get(__response__, 'website'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_pipeline.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_pipeline.py new file mode 100644 index 00000000..f9c3329e --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_pipeline.py @@ -0,0 +1,340 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetPipelineResult', + 'AwaitableGetPipelineResult', + 'get_pipeline', + 'get_pipeline_output', +] + +@pulumi.output_type +class GetPipelineResult: + """ + A collection of values returned by getPipeline. + """ + def __init__(__self__, attributes=None, compute_env=None, deleted=None, description=None, icon=None, id=None, labels=None, last_updated=None, name=None, optimization_id=None, optimization_status=None, optimization_targets=None, org_id=None, org_name=None, pipeline_id=None, repository=None, source_workspace_id=None, user_first_name=None, user_id=None, user_last_name=None, user_name=None, visibility=None, workspace_id=None, workspace_name=None): + if attributes and not isinstance(attributes, list): + raise TypeError("Expected argument 'attributes' to be a list") + pulumi.set(__self__, "attributes", attributes) + if compute_env and not isinstance(compute_env, dict): + raise TypeError("Expected argument 'compute_env' to be a dict") + pulumi.set(__self__, "compute_env", compute_env) + if deleted and not isinstance(deleted, bool): + raise TypeError("Expected argument 'deleted' to be a bool") + pulumi.set(__self__, "deleted", deleted) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if icon and not isinstance(icon, str): + raise TypeError("Expected argument 'icon' to be a str") + pulumi.set(__self__, "icon", icon) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if optimization_id and not isinstance(optimization_id, str): + raise TypeError("Expected argument 'optimization_id' to be a str") + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_status and not isinstance(optimization_status, str): + raise TypeError("Expected argument 'optimization_status' to be a str") + pulumi.set(__self__, "optimization_status", optimization_status) + if optimization_targets and not isinstance(optimization_targets, str): + raise TypeError("Expected argument 'optimization_targets' to be a str") + pulumi.set(__self__, "optimization_targets", optimization_targets) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if org_name and not isinstance(org_name, str): + raise TypeError("Expected argument 'org_name' to be a str") + pulumi.set(__self__, "org_name", org_name) + if pipeline_id and not isinstance(pipeline_id, float): + raise TypeError("Expected argument 'pipeline_id' to be a float") + pulumi.set(__self__, "pipeline_id", pipeline_id) + if repository and not isinstance(repository, str): + raise TypeError("Expected argument 'repository' to be a str") + pulumi.set(__self__, "repository", repository) + if source_workspace_id and not isinstance(source_workspace_id, float): + raise TypeError("Expected argument 'source_workspace_id' to be a float") + pulumi.set(__self__, "source_workspace_id", source_workspace_id) + if user_first_name and not isinstance(user_first_name, str): + raise TypeError("Expected argument 'user_first_name' to be a str") + pulumi.set(__self__, "user_first_name", user_first_name) + if user_id and not isinstance(user_id, float): + raise TypeError("Expected argument 'user_id' to be a float") + pulumi.set(__self__, "user_id", user_id) + if user_last_name and not isinstance(user_last_name, str): + raise TypeError("Expected argument 'user_last_name' to be a str") + pulumi.set(__self__, "user_last_name", user_last_name) + if user_name and not isinstance(user_name, str): + raise TypeError("Expected argument 'user_name' to be a str") + pulumi.set(__self__, "user_name", user_name) + if visibility and not isinstance(visibility, str): + raise TypeError("Expected argument 'visibility' to be a str") + pulumi.set(__self__, "visibility", visibility) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + if workspace_name and not isinstance(workspace_name, str): + raise TypeError("Expected argument 'workspace_name' to be a str") + pulumi.set(__self__, "workspace_name", workspace_name) + + @_builtins.property + @pulumi.getter + def attributes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "attributes") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> 'outputs.GetPipelineComputeEnvResult': + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def icon(self) -> _builtins.str: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetPipelineLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> _builtins.str: + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationStatus") + def optimization_status(self) -> _builtins.str: + return pulumi.get(self, "optimization_status") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> _builtins.str: + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> _builtins.str: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter(name="pipelineId") + def pipeline_id(self) -> _builtins.float: + return pulumi.get(self, "pipeline_id") + + @_builtins.property + @pulumi.getter + def repository(self) -> _builtins.str: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter(name="sourceWorkspaceId") + def source_workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "source_workspace_id") + + @_builtins.property + @pulumi.getter(name="userFirstName") + def user_first_name(self) -> _builtins.str: + return pulumi.get(self, "user_first_name") + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> _builtins.float: + return pulumi.get(self, "user_id") + + @_builtins.property + @pulumi.getter(name="userLastName") + def user_last_name(self) -> _builtins.str: + return pulumi.get(self, "user_last_name") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter + def visibility(self) -> _builtins.str: + return pulumi.get(self, "visibility") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> _builtins.str: + return pulumi.get(self, "workspace_name") + + +class AwaitableGetPipelineResult(GetPipelineResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPipelineResult( + attributes=self.attributes, + compute_env=self.compute_env, + deleted=self.deleted, + description=self.description, + icon=self.icon, + id=self.id, + labels=self.labels, + last_updated=self.last_updated, + name=self.name, + optimization_id=self.optimization_id, + optimization_status=self.optimization_status, + optimization_targets=self.optimization_targets, + org_id=self.org_id, + org_name=self.org_name, + pipeline_id=self.pipeline_id, + repository=self.repository, + source_workspace_id=self.source_workspace_id, + user_first_name=self.user_first_name, + user_id=self.user_id, + user_last_name=self.user_last_name, + user_name=self.user_name, + visibility=self.visibility, + workspace_id=self.workspace_id, + workspace_name=self.workspace_name) + + +def get_pipeline(attributes: Optional[Sequence[_builtins.str]] = None, + pipeline_id: Optional[_builtins.float] = None, + source_workspace_id: Optional[_builtins.float] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPipelineResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['pipelineId'] = pipeline_id + __args__['sourceWorkspaceId'] = source_workspace_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getPipeline:getPipeline', __args__, opts=opts, typ=GetPipelineResult, package_ref=_utilities.get_package()).value + + return AwaitableGetPipelineResult( + attributes=pulumi.get(__ret__, 'attributes'), + compute_env=pulumi.get(__ret__, 'compute_env'), + deleted=pulumi.get(__ret__, 'deleted'), + description=pulumi.get(__ret__, 'description'), + icon=pulumi.get(__ret__, 'icon'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + last_updated=pulumi.get(__ret__, 'last_updated'), + name=pulumi.get(__ret__, 'name'), + optimization_id=pulumi.get(__ret__, 'optimization_id'), + optimization_status=pulumi.get(__ret__, 'optimization_status'), + optimization_targets=pulumi.get(__ret__, 'optimization_targets'), + org_id=pulumi.get(__ret__, 'org_id'), + org_name=pulumi.get(__ret__, 'org_name'), + pipeline_id=pulumi.get(__ret__, 'pipeline_id'), + repository=pulumi.get(__ret__, 'repository'), + source_workspace_id=pulumi.get(__ret__, 'source_workspace_id'), + user_first_name=pulumi.get(__ret__, 'user_first_name'), + user_id=pulumi.get(__ret__, 'user_id'), + user_last_name=pulumi.get(__ret__, 'user_last_name'), + user_name=pulumi.get(__ret__, 'user_name'), + visibility=pulumi.get(__ret__, 'visibility'), + workspace_id=pulumi.get(__ret__, 'workspace_id'), + workspace_name=pulumi.get(__ret__, 'workspace_name')) +def get_pipeline_output(attributes: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None, + pipeline_id: Optional[pulumi.Input[_builtins.float]] = None, + source_workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPipelineResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['pipelineId'] = pipeline_id + __args__['sourceWorkspaceId'] = source_workspace_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getPipeline:getPipeline', __args__, opts=opts, typ=GetPipelineResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetPipelineResult( + attributes=pulumi.get(__response__, 'attributes'), + compute_env=pulumi.get(__response__, 'compute_env'), + deleted=pulumi.get(__response__, 'deleted'), + description=pulumi.get(__response__, 'description'), + icon=pulumi.get(__response__, 'icon'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + last_updated=pulumi.get(__response__, 'last_updated'), + name=pulumi.get(__response__, 'name'), + optimization_id=pulumi.get(__response__, 'optimization_id'), + optimization_status=pulumi.get(__response__, 'optimization_status'), + optimization_targets=pulumi.get(__response__, 'optimization_targets'), + org_id=pulumi.get(__response__, 'org_id'), + org_name=pulumi.get(__response__, 'org_name'), + pipeline_id=pulumi.get(__response__, 'pipeline_id'), + repository=pulumi.get(__response__, 'repository'), + source_workspace_id=pulumi.get(__response__, 'source_workspace_id'), + user_first_name=pulumi.get(__response__, 'user_first_name'), + user_id=pulumi.get(__response__, 'user_id'), + user_last_name=pulumi.get(__response__, 'user_last_name'), + user_name=pulumi.get(__response__, 'user_name'), + visibility=pulumi.get(__response__, 'visibility'), + workspace_id=pulumi.get(__response__, 'workspace_id'), + workspace_name=pulumi.get(__response__, 'workspace_name'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_pipeline_secret.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_pipeline_secret.py new file mode 100644 index 00000000..fa0aea82 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_pipeline_secret.py @@ -0,0 +1,141 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetPipelineSecretResult', + 'AwaitableGetPipelineSecretResult', + 'get_pipeline_secret', + 'get_pipeline_secret_output', +] + +@pulumi.output_type +class GetPipelineSecretResult: + """ + A collection of values returned by getPipelineSecret. + """ + def __init__(__self__, date_created=None, id=None, last_updated=None, last_used=None, name=None, secret_id=None, workspace_id=None): + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if id and not isinstance(id, float): + raise TypeError("Expected argument 'id' to be a float") + pulumi.set(__self__, "id", id) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if last_used and not isinstance(last_used, str): + raise TypeError("Expected argument 'last_used' to be a str") + pulumi.set(__self__, "last_used", last_used) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if secret_id and not isinstance(secret_id, float): + raise TypeError("Expected argument 'secret_id' to be a float") + pulumi.set(__self__, "secret_id", secret_id) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="secretId") + def secret_id(self) -> _builtins.float: + return pulumi.get(self, "secret_id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetPipelineSecretResult(GetPipelineSecretResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPipelineSecretResult( + date_created=self.date_created, + id=self.id, + last_updated=self.last_updated, + last_used=self.last_used, + name=self.name, + secret_id=self.secret_id, + workspace_id=self.workspace_id) + + +def get_pipeline_secret(secret_id: Optional[_builtins.float] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPipelineSecretResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['secretId'] = secret_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getPipelineSecret:getPipelineSecret', __args__, opts=opts, typ=GetPipelineSecretResult, package_ref=_utilities.get_package()).value + + return AwaitableGetPipelineSecretResult( + date_created=pulumi.get(__ret__, 'date_created'), + id=pulumi.get(__ret__, 'id'), + last_updated=pulumi.get(__ret__, 'last_updated'), + last_used=pulumi.get(__ret__, 'last_used'), + name=pulumi.get(__ret__, 'name'), + secret_id=pulumi.get(__ret__, 'secret_id'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_pipeline_secret_output(secret_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPipelineSecretResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['secretId'] = secret_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getPipelineSecret:getPipelineSecret', __args__, opts=opts, typ=GetPipelineSecretResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetPipelineSecretResult( + date_created=pulumi.get(__response__, 'date_created'), + id=pulumi.get(__response__, 'id'), + last_updated=pulumi.get(__response__, 'last_updated'), + last_used=pulumi.get(__response__, 'last_used'), + name=pulumi.get(__response__, 'name'), + secret_id=pulumi.get(__response__, 'secret_id'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_studios.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_studios.py new file mode 100644 index 00000000..c762d8c2 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_studios.py @@ -0,0 +1,328 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetStudiosResult', + 'AwaitableGetStudiosResult', + 'get_studios', + 'get_studios_output', +] + +@pulumi.output_type +class GetStudiosResult: + """ + A collection of values returned by getStudios. + """ + def __init__(__self__, active_connections=None, base_image=None, compute_env=None, configuration=None, custom_image=None, date_created=None, description=None, effective_lifespan_hours=None, id=None, is_private=None, labels=None, last_started=None, last_updated=None, mounted_data_links=None, name=None, parent_checkpoint=None, progresses=None, session_id=None, status_info=None, studio_url=None, template=None, user=None, wave_build_url=None, workspace_id=None): + if active_connections and not isinstance(active_connections, list): + raise TypeError("Expected argument 'active_connections' to be a list") + pulumi.set(__self__, "active_connections", active_connections) + if base_image and not isinstance(base_image, str): + raise TypeError("Expected argument 'base_image' to be a str") + pulumi.set(__self__, "base_image", base_image) + if compute_env and not isinstance(compute_env, dict): + raise TypeError("Expected argument 'compute_env' to be a dict") + pulumi.set(__self__, "compute_env", compute_env) + if configuration and not isinstance(configuration, dict): + raise TypeError("Expected argument 'configuration' to be a dict") + pulumi.set(__self__, "configuration", configuration) + if custom_image and not isinstance(custom_image, bool): + raise TypeError("Expected argument 'custom_image' to be a bool") + pulumi.set(__self__, "custom_image", custom_image) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if effective_lifespan_hours and not isinstance(effective_lifespan_hours, float): + raise TypeError("Expected argument 'effective_lifespan_hours' to be a float") + pulumi.set(__self__, "effective_lifespan_hours", effective_lifespan_hours) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if is_private and not isinstance(is_private, bool): + raise TypeError("Expected argument 'is_private' to be a bool") + pulumi.set(__self__, "is_private", is_private) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if last_started and not isinstance(last_started, str): + raise TypeError("Expected argument 'last_started' to be a str") + pulumi.set(__self__, "last_started", last_started) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if mounted_data_links and not isinstance(mounted_data_links, list): + raise TypeError("Expected argument 'mounted_data_links' to be a list") + pulumi.set(__self__, "mounted_data_links", mounted_data_links) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if parent_checkpoint and not isinstance(parent_checkpoint, dict): + raise TypeError("Expected argument 'parent_checkpoint' to be a dict") + pulumi.set(__self__, "parent_checkpoint", parent_checkpoint) + if progresses and not isinstance(progresses, list): + raise TypeError("Expected argument 'progresses' to be a list") + pulumi.set(__self__, "progresses", progresses) + if session_id and not isinstance(session_id, str): + raise TypeError("Expected argument 'session_id' to be a str") + pulumi.set(__self__, "session_id", session_id) + if status_info and not isinstance(status_info, dict): + raise TypeError("Expected argument 'status_info' to be a dict") + pulumi.set(__self__, "status_info", status_info) + if studio_url and not isinstance(studio_url, str): + raise TypeError("Expected argument 'studio_url' to be a str") + pulumi.set(__self__, "studio_url", studio_url) + if template and not isinstance(template, dict): + raise TypeError("Expected argument 'template' to be a dict") + pulumi.set(__self__, "template", template) + if user and not isinstance(user, dict): + raise TypeError("Expected argument 'user' to be a dict") + pulumi.set(__self__, "user", user) + if wave_build_url and not isinstance(wave_build_url, str): + raise TypeError("Expected argument 'wave_build_url' to be a str") + pulumi.set(__self__, "wave_build_url", wave_build_url) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="activeConnections") + def active_connections(self) -> Sequence['outputs.GetStudiosActiveConnectionResult']: + return pulumi.get(self, "active_connections") + + @_builtins.property + @pulumi.getter(name="baseImage") + def base_image(self) -> _builtins.str: + return pulumi.get(self, "base_image") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> 'outputs.GetStudiosComputeEnvResult': + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter + def configuration(self) -> 'outputs.GetStudiosConfigurationResult': + return pulumi.get(self, "configuration") + + @_builtins.property + @pulumi.getter(name="customImage") + def custom_image(self) -> _builtins.bool: + return pulumi.get(self, "custom_image") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="effectiveLifespanHours") + def effective_lifespan_hours(self) -> _builtins.float: + return pulumi.get(self, "effective_lifespan_hours") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isPrivate") + def is_private(self) -> _builtins.bool: + return pulumi.get(self, "is_private") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetStudiosLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastStarted") + def last_started(self) -> _builtins.str: + return pulumi.get(self, "last_started") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="mountedDataLinks") + def mounted_data_links(self) -> Sequence['outputs.GetStudiosMountedDataLinkResult']: + return pulumi.get(self, "mounted_data_links") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="parentCheckpoint") + def parent_checkpoint(self) -> 'outputs.GetStudiosParentCheckpointResult': + return pulumi.get(self, "parent_checkpoint") + + @_builtins.property + @pulumi.getter + def progresses(self) -> Sequence['outputs.GetStudiosProgressResult']: + return pulumi.get(self, "progresses") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> _builtins.str: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="statusInfo") + def status_info(self) -> 'outputs.GetStudiosStatusInfoResult': + return pulumi.get(self, "status_info") + + @_builtins.property + @pulumi.getter(name="studioUrl") + def studio_url(self) -> _builtins.str: + return pulumi.get(self, "studio_url") + + @_builtins.property + @pulumi.getter + def template(self) -> 'outputs.GetStudiosTemplateResult': + return pulumi.get(self, "template") + + @_builtins.property + @pulumi.getter + def user(self) -> 'outputs.GetStudiosUserResult': + return pulumi.get(self, "user") + + @_builtins.property + @pulumi.getter(name="waveBuildUrl") + def wave_build_url(self) -> _builtins.str: + return pulumi.get(self, "wave_build_url") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetStudiosResult(GetStudiosResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetStudiosResult( + active_connections=self.active_connections, + base_image=self.base_image, + compute_env=self.compute_env, + configuration=self.configuration, + custom_image=self.custom_image, + date_created=self.date_created, + description=self.description, + effective_lifespan_hours=self.effective_lifespan_hours, + id=self.id, + is_private=self.is_private, + labels=self.labels, + last_started=self.last_started, + last_updated=self.last_updated, + mounted_data_links=self.mounted_data_links, + name=self.name, + parent_checkpoint=self.parent_checkpoint, + progresses=self.progresses, + session_id=self.session_id, + status_info=self.status_info, + studio_url=self.studio_url, + template=self.template, + user=self.user, + wave_build_url=self.wave_build_url, + workspace_id=self.workspace_id) + + +def get_studios(workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStudiosResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getStudios:getStudios', __args__, opts=opts, typ=GetStudiosResult, package_ref=_utilities.get_package()).value + + return AwaitableGetStudiosResult( + active_connections=pulumi.get(__ret__, 'active_connections'), + base_image=pulumi.get(__ret__, 'base_image'), + compute_env=pulumi.get(__ret__, 'compute_env'), + configuration=pulumi.get(__ret__, 'configuration'), + custom_image=pulumi.get(__ret__, 'custom_image'), + date_created=pulumi.get(__ret__, 'date_created'), + description=pulumi.get(__ret__, 'description'), + effective_lifespan_hours=pulumi.get(__ret__, 'effective_lifespan_hours'), + id=pulumi.get(__ret__, 'id'), + is_private=pulumi.get(__ret__, 'is_private'), + labels=pulumi.get(__ret__, 'labels'), + last_started=pulumi.get(__ret__, 'last_started'), + last_updated=pulumi.get(__ret__, 'last_updated'), + mounted_data_links=pulumi.get(__ret__, 'mounted_data_links'), + name=pulumi.get(__ret__, 'name'), + parent_checkpoint=pulumi.get(__ret__, 'parent_checkpoint'), + progresses=pulumi.get(__ret__, 'progresses'), + session_id=pulumi.get(__ret__, 'session_id'), + status_info=pulumi.get(__ret__, 'status_info'), + studio_url=pulumi.get(__ret__, 'studio_url'), + template=pulumi.get(__ret__, 'template'), + user=pulumi.get(__ret__, 'user'), + wave_build_url=pulumi.get(__ret__, 'wave_build_url'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_studios_output(workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetStudiosResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getStudios:getStudios', __args__, opts=opts, typ=GetStudiosResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetStudiosResult( + active_connections=pulumi.get(__response__, 'active_connections'), + base_image=pulumi.get(__response__, 'base_image'), + compute_env=pulumi.get(__response__, 'compute_env'), + configuration=pulumi.get(__response__, 'configuration'), + custom_image=pulumi.get(__response__, 'custom_image'), + date_created=pulumi.get(__response__, 'date_created'), + description=pulumi.get(__response__, 'description'), + effective_lifespan_hours=pulumi.get(__response__, 'effective_lifespan_hours'), + id=pulumi.get(__response__, 'id'), + is_private=pulumi.get(__response__, 'is_private'), + labels=pulumi.get(__response__, 'labels'), + last_started=pulumi.get(__response__, 'last_started'), + last_updated=pulumi.get(__response__, 'last_updated'), + mounted_data_links=pulumi.get(__response__, 'mounted_data_links'), + name=pulumi.get(__response__, 'name'), + parent_checkpoint=pulumi.get(__response__, 'parent_checkpoint'), + progresses=pulumi.get(__response__, 'progresses'), + session_id=pulumi.get(__response__, 'session_id'), + status_info=pulumi.get(__response__, 'status_info'), + studio_url=pulumi.get(__response__, 'studio_url'), + template=pulumi.get(__response__, 'template'), + user=pulumi.get(__response__, 'user'), + wave_build_url=pulumi.get(__response__, 'wave_build_url'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_teams.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_teams.py new file mode 100644 index 00000000..9ae0756b --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_teams.py @@ -0,0 +1,144 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetTeamsResult', + 'AwaitableGetTeamsResult', + 'get_teams', + 'get_teams_output', +] + +@pulumi.output_type +class GetTeamsResult: + """ + A collection of values returned by getTeams. + """ + def __init__(__self__, avatar_url=None, description=None, id=None, members_count=None, name=None, org_id=None, team_id=None): + if avatar_url and not isinstance(avatar_url, str): + raise TypeError("Expected argument 'avatar_url' to be a str") + pulumi.set(__self__, "avatar_url", avatar_url) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if members_count and not isinstance(members_count, float): + raise TypeError("Expected argument 'members_count' to be a float") + pulumi.set(__self__, "members_count", members_count) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if team_id and not isinstance(team_id, float): + raise TypeError("Expected argument 'team_id' to be a float") + pulumi.set(__self__, "team_id", team_id) + + @_builtins.property + @pulumi.getter(name="avatarUrl") + def avatar_url(self) -> _builtins.str: + return pulumi.get(self, "avatar_url") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="membersCount") + def members_count(self) -> _builtins.float: + return pulumi.get(self, "members_count") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="teamId") + def team_id(self) -> _builtins.float: + return pulumi.get(self, "team_id") + + +class AwaitableGetTeamsResult(GetTeamsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetTeamsResult( + avatar_url=self.avatar_url, + description=self.description, + id=self.id, + members_count=self.members_count, + name=self.name, + org_id=self.org_id, + team_id=self.team_id) + + +def get_teams(org_id: Optional[_builtins.float] = None, + team_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTeamsResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + __args__['teamId'] = team_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getTeams:getTeams', __args__, opts=opts, typ=GetTeamsResult, package_ref=_utilities.get_package()).value + + return AwaitableGetTeamsResult( + avatar_url=pulumi.get(__ret__, 'avatar_url'), + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + members_count=pulumi.get(__ret__, 'members_count'), + name=pulumi.get(__ret__, 'name'), + org_id=pulumi.get(__ret__, 'org_id'), + team_id=pulumi.get(__ret__, 'team_id')) +def get_teams_output(org_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + team_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTeamsResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + __args__['teamId'] = team_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getTeams:getTeams', __args__, opts=opts, typ=GetTeamsResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetTeamsResult( + avatar_url=pulumi.get(__response__, 'avatar_url'), + description=pulumi.get(__response__, 'description'), + id=pulumi.get(__response__, 'id'), + members_count=pulumi.get(__response__, 'members_count'), + name=pulumi.get(__response__, 'name'), + org_id=pulumi.get(__response__, 'org_id'), + team_id=pulumi.get(__response__, 'team_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_tokens.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_tokens.py new file mode 100644 index 00000000..0b2dec28 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_tokens.py @@ -0,0 +1,112 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetTokensResult', + 'AwaitableGetTokensResult', + 'get_tokens', + 'get_tokens_output', +] + +@pulumi.output_type +class GetTokensResult: + """ + A collection of values returned by getTokens. + """ + def __init__(__self__, basic_auth=None, date_created=None, id=None, last_used=None, name=None): + if basic_auth and not isinstance(basic_auth, str): + raise TypeError("Expected argument 'basic_auth' to be a str") + pulumi.set(__self__, "basic_auth", basic_auth) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if id and not isinstance(id, float): + raise TypeError("Expected argument 'id' to be a float") + pulumi.set(__self__, "id", id) + if last_used and not isinstance(last_used, str): + raise TypeError("Expected argument 'last_used' to be a str") + pulumi.set(__self__, "last_used", last_used) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> _builtins.str: + return pulumi.get(self, "basic_auth") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + +class AwaitableGetTokensResult(GetTokensResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetTokensResult( + basic_auth=self.basic_auth, + date_created=self.date_created, + id=self.id, + last_used=self.last_used, + name=self.name) + + +def get_tokens(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTokensResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getTokens:getTokens', __args__, opts=opts, typ=GetTokensResult, package_ref=_utilities.get_package()).value + + return AwaitableGetTokensResult( + basic_auth=pulumi.get(__ret__, 'basic_auth'), + date_created=pulumi.get(__ret__, 'date_created'), + id=pulumi.get(__ret__, 'id'), + last_used=pulumi.get(__ret__, 'last_used'), + name=pulumi.get(__ret__, 'name')) +def get_tokens_output(opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTokensResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getTokens:getTokens', __args__, opts=opts, typ=GetTokensResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetTokensResult( + basic_auth=pulumi.get(__response__, 'basic_auth'), + date_created=pulumi.get(__response__, 'date_created'), + id=pulumi.get(__response__, 'id'), + last_used=pulumi.get(__response__, 'last_used'), + name=pulumi.get(__response__, 'name'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_user.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_user.py new file mode 100644 index 00000000..5cb8d15d --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_user.py @@ -0,0 +1,269 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetUserResult', + 'AwaitableGetUserResult', + 'get_user', + 'get_user_output', +] + +@pulumi.output_type +class GetUserResult: + """ + A collection of values returned by getUser. + """ + def __init__(__self__, avatar=None, avatar_id=None, date_created=None, default_workspace_id=None, deleted=None, description=None, email=None, first_name=None, id=None, last_access=None, last_name=None, last_updated=None, marketing_consent=None, need_consent=None, notification=None, organization=None, terms_of_use_consent=None, user_id=None, user_name=None): + if avatar and not isinstance(avatar, str): + raise TypeError("Expected argument 'avatar' to be a str") + pulumi.set(__self__, "avatar", avatar) + if avatar_id and not isinstance(avatar_id, str): + raise TypeError("Expected argument 'avatar_id' to be a str") + pulumi.set(__self__, "avatar_id", avatar_id) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if default_workspace_id and not isinstance(default_workspace_id, float): + raise TypeError("Expected argument 'default_workspace_id' to be a float") + pulumi.set(__self__, "default_workspace_id", default_workspace_id) + if deleted and not isinstance(deleted, bool): + raise TypeError("Expected argument 'deleted' to be a bool") + pulumi.set(__self__, "deleted", deleted) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if email and not isinstance(email, str): + raise TypeError("Expected argument 'email' to be a str") + pulumi.set(__self__, "email", email) + if first_name and not isinstance(first_name, str): + raise TypeError("Expected argument 'first_name' to be a str") + pulumi.set(__self__, "first_name", first_name) + if id and not isinstance(id, float): + raise TypeError("Expected argument 'id' to be a float") + pulumi.set(__self__, "id", id) + if last_access and not isinstance(last_access, str): + raise TypeError("Expected argument 'last_access' to be a str") + pulumi.set(__self__, "last_access", last_access) + if last_name and not isinstance(last_name, str): + raise TypeError("Expected argument 'last_name' to be a str") + pulumi.set(__self__, "last_name", last_name) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if marketing_consent and not isinstance(marketing_consent, bool): + raise TypeError("Expected argument 'marketing_consent' to be a bool") + pulumi.set(__self__, "marketing_consent", marketing_consent) + if need_consent and not isinstance(need_consent, bool): + raise TypeError("Expected argument 'need_consent' to be a bool") + pulumi.set(__self__, "need_consent", need_consent) + if notification and not isinstance(notification, bool): + raise TypeError("Expected argument 'notification' to be a bool") + pulumi.set(__self__, "notification", notification) + if organization and not isinstance(organization, str): + raise TypeError("Expected argument 'organization' to be a str") + pulumi.set(__self__, "organization", organization) + if terms_of_use_consent and not isinstance(terms_of_use_consent, bool): + raise TypeError("Expected argument 'terms_of_use_consent' to be a bool") + pulumi.set(__self__, "terms_of_use_consent", terms_of_use_consent) + if user_id and not isinstance(user_id, float): + raise TypeError("Expected argument 'user_id' to be a float") + pulumi.set(__self__, "user_id", user_id) + if user_name and not isinstance(user_name, str): + raise TypeError("Expected argument 'user_name' to be a str") + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> _builtins.str: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter(name="avatarId") + def avatar_id(self) -> _builtins.str: + return pulumi.get(self, "avatar_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="defaultWorkspaceId") + def default_workspace_id(self) -> _builtins.float: + return pulumi.get(self, "default_workspace_id") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def email(self) -> _builtins.str: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter(name="firstName") + def first_name(self) -> _builtins.str: + return pulumi.get(self, "first_name") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastAccess") + def last_access(self) -> _builtins.str: + return pulumi.get(self, "last_access") + + @_builtins.property + @pulumi.getter(name="lastName") + def last_name(self) -> _builtins.str: + return pulumi.get(self, "last_name") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="marketingConsent") + def marketing_consent(self) -> _builtins.bool: + return pulumi.get(self, "marketing_consent") + + @_builtins.property + @pulumi.getter(name="needConsent") + def need_consent(self) -> _builtins.bool: + return pulumi.get(self, "need_consent") + + @_builtins.property + @pulumi.getter + def notification(self) -> _builtins.bool: + return pulumi.get(self, "notification") + + @_builtins.property + @pulumi.getter + def organization(self) -> _builtins.str: + return pulumi.get(self, "organization") + + @_builtins.property + @pulumi.getter(name="termsOfUseConsent") + def terms_of_use_consent(self) -> _builtins.bool: + return pulumi.get(self, "terms_of_use_consent") + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> _builtins.float: + return pulumi.get(self, "user_id") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + +class AwaitableGetUserResult(GetUserResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetUserResult( + avatar=self.avatar, + avatar_id=self.avatar_id, + date_created=self.date_created, + default_workspace_id=self.default_workspace_id, + deleted=self.deleted, + description=self.description, + email=self.email, + first_name=self.first_name, + id=self.id, + last_access=self.last_access, + last_name=self.last_name, + last_updated=self.last_updated, + marketing_consent=self.marketing_consent, + need_consent=self.need_consent, + notification=self.notification, + organization=self.organization, + terms_of_use_consent=self.terms_of_use_consent, + user_id=self.user_id, + user_name=self.user_name) + + +def get_user(user_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetUserResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['userId'] = user_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getUser:getUser', __args__, opts=opts, typ=GetUserResult, package_ref=_utilities.get_package()).value + + return AwaitableGetUserResult( + avatar=pulumi.get(__ret__, 'avatar'), + avatar_id=pulumi.get(__ret__, 'avatar_id'), + date_created=pulumi.get(__ret__, 'date_created'), + default_workspace_id=pulumi.get(__ret__, 'default_workspace_id'), + deleted=pulumi.get(__ret__, 'deleted'), + description=pulumi.get(__ret__, 'description'), + email=pulumi.get(__ret__, 'email'), + first_name=pulumi.get(__ret__, 'first_name'), + id=pulumi.get(__ret__, 'id'), + last_access=pulumi.get(__ret__, 'last_access'), + last_name=pulumi.get(__ret__, 'last_name'), + last_updated=pulumi.get(__ret__, 'last_updated'), + marketing_consent=pulumi.get(__ret__, 'marketing_consent'), + need_consent=pulumi.get(__ret__, 'need_consent'), + notification=pulumi.get(__ret__, 'notification'), + organization=pulumi.get(__ret__, 'organization'), + terms_of_use_consent=pulumi.get(__ret__, 'terms_of_use_consent'), + user_id=pulumi.get(__ret__, 'user_id'), + user_name=pulumi.get(__ret__, 'user_name')) +def get_user_output(user_id: Optional[pulumi.Input[_builtins.float]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetUserResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['userId'] = user_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getUser:getUser', __args__, opts=opts, typ=GetUserResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetUserResult( + avatar=pulumi.get(__response__, 'avatar'), + avatar_id=pulumi.get(__response__, 'avatar_id'), + date_created=pulumi.get(__response__, 'date_created'), + default_workspace_id=pulumi.get(__response__, 'default_workspace_id'), + deleted=pulumi.get(__response__, 'deleted'), + description=pulumi.get(__response__, 'description'), + email=pulumi.get(__response__, 'email'), + first_name=pulumi.get(__response__, 'first_name'), + id=pulumi.get(__response__, 'id'), + last_access=pulumi.get(__response__, 'last_access'), + last_name=pulumi.get(__response__, 'last_name'), + last_updated=pulumi.get(__response__, 'last_updated'), + marketing_consent=pulumi.get(__response__, 'marketing_consent'), + need_consent=pulumi.get(__response__, 'need_consent'), + notification=pulumi.get(__response__, 'notification'), + organization=pulumi.get(__response__, 'organization'), + terms_of_use_consent=pulumi.get(__response__, 'terms_of_use_consent'), + user_id=pulumi.get(__response__, 'user_id'), + user_name=pulumi.get(__response__, 'user_name'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_user_workspaces.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_user_workspaces.py new file mode 100644 index 00000000..afb7ad38 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_user_workspaces.py @@ -0,0 +1,97 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetUserWorkspacesResult', + 'AwaitableGetUserWorkspacesResult', + 'get_user_workspaces', + 'get_user_workspaces_output', +] + +@pulumi.output_type +class GetUserWorkspacesResult: + """ + A collection of values returned by getUserWorkspaces. + """ + def __init__(__self__, id=None, orgs_and_workspaces=None, user_id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if orgs_and_workspaces and not isinstance(orgs_and_workspaces, list): + raise TypeError("Expected argument 'orgs_and_workspaces' to be a list") + pulumi.set(__self__, "orgs_and_workspaces", orgs_and_workspaces) + if user_id and not isinstance(user_id, float): + raise TypeError("Expected argument 'user_id' to be a float") + pulumi.set(__self__, "user_id", user_id) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="orgsAndWorkspaces") + def orgs_and_workspaces(self) -> Sequence['outputs.GetUserWorkspacesOrgsAndWorkspaceResult']: + return pulumi.get(self, "orgs_and_workspaces") + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> _builtins.float: + return pulumi.get(self, "user_id") + + +class AwaitableGetUserWorkspacesResult(GetUserWorkspacesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetUserWorkspacesResult( + id=self.id, + orgs_and_workspaces=self.orgs_and_workspaces, + user_id=self.user_id) + + +def get_user_workspaces(user_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetUserWorkspacesResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['userId'] = user_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getUserWorkspaces:getUserWorkspaces', __args__, opts=opts, typ=GetUserWorkspacesResult, package_ref=_utilities.get_package()).value + + return AwaitableGetUserWorkspacesResult( + id=pulumi.get(__ret__, 'id'), + orgs_and_workspaces=pulumi.get(__ret__, 'orgs_and_workspaces'), + user_id=pulumi.get(__ret__, 'user_id')) +def get_user_workspaces_output(user_id: Optional[pulumi.Input[_builtins.float]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetUserWorkspacesResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['userId'] = user_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getUserWorkspaces:getUserWorkspaces', __args__, opts=opts, typ=GetUserWorkspacesResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetUserWorkspacesResult( + id=pulumi.get(__response__, 'id'), + orgs_and_workspaces=pulumi.get(__response__, 'orgs_and_workspaces'), + user_id=pulumi.get(__response__, 'user_id'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workflows.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workflows.py new file mode 100644 index 00000000..d6917d59 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workflows.py @@ -0,0 +1,226 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetWorkflowsResult', + 'AwaitableGetWorkflowsResult', + 'get_workflows', + 'get_workflows_output', +] + +@pulumi.output_type +class GetWorkflowsResult: + """ + A collection of values returned by getWorkflows. + """ + def __init__(__self__, attributes=None, id=None, job_info=None, labels=None, messages=None, optimized=None, org_id=None, org_name=None, platform=None, progress=None, workflow=None, workflow_id=None, workspace_id=None, workspace_name=None): + if attributes and not isinstance(attributes, list): + raise TypeError("Expected argument 'attributes' to be a list") + pulumi.set(__self__, "attributes", attributes) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if job_info and not isinstance(job_info, dict): + raise TypeError("Expected argument 'job_info' to be a dict") + pulumi.set(__self__, "job_info", job_info) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if messages and not isinstance(messages, list): + raise TypeError("Expected argument 'messages' to be a list") + pulumi.set(__self__, "messages", messages) + if optimized and not isinstance(optimized, bool): + raise TypeError("Expected argument 'optimized' to be a bool") + pulumi.set(__self__, "optimized", optimized) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if org_name and not isinstance(org_name, str): + raise TypeError("Expected argument 'org_name' to be a str") + pulumi.set(__self__, "org_name", org_name) + if platform and not isinstance(platform, dict): + raise TypeError("Expected argument 'platform' to be a dict") + pulumi.set(__self__, "platform", platform) + if progress and not isinstance(progress, dict): + raise TypeError("Expected argument 'progress' to be a dict") + pulumi.set(__self__, "progress", progress) + if workflow and not isinstance(workflow, dict): + raise TypeError("Expected argument 'workflow' to be a dict") + pulumi.set(__self__, "workflow", workflow) + if workflow_id and not isinstance(workflow_id, str): + raise TypeError("Expected argument 'workflow_id' to be a str") + pulumi.set(__self__, "workflow_id", workflow_id) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + if workspace_name and not isinstance(workspace_name, str): + raise TypeError("Expected argument 'workspace_name' to be a str") + pulumi.set(__self__, "workspace_name", workspace_name) + + @_builtins.property + @pulumi.getter + def attributes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "attributes") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="jobInfo") + def job_info(self) -> 'outputs.GetWorkflowsJobInfoResult': + return pulumi.get(self, "job_info") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetWorkflowsLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def messages(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "messages") + + @_builtins.property + @pulumi.getter + def optimized(self) -> _builtins.bool: + return pulumi.get(self, "optimized") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> _builtins.str: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter + def platform(self) -> 'outputs.GetWorkflowsPlatformResult': + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def progress(self) -> 'outputs.GetWorkflowsProgressResult': + return pulumi.get(self, "progress") + + @_builtins.property + @pulumi.getter + def workflow(self) -> 'outputs.GetWorkflowsWorkflowResult': + return pulumi.get(self, "workflow") + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> _builtins.str: + return pulumi.get(self, "workflow_id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> _builtins.str: + return pulumi.get(self, "workspace_name") + + +class AwaitableGetWorkflowsResult(GetWorkflowsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetWorkflowsResult( + attributes=self.attributes, + id=self.id, + job_info=self.job_info, + labels=self.labels, + messages=self.messages, + optimized=self.optimized, + org_id=self.org_id, + org_name=self.org_name, + platform=self.platform, + progress=self.progress, + workflow=self.workflow, + workflow_id=self.workflow_id, + workspace_id=self.workspace_id, + workspace_name=self.workspace_name) + + +def get_workflows(attributes: Optional[Sequence[_builtins.str]] = None, + workflow_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetWorkflowsResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['workflowId'] = workflow_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getWorkflows:getWorkflows', __args__, opts=opts, typ=GetWorkflowsResult, package_ref=_utilities.get_package()).value + + return AwaitableGetWorkflowsResult( + attributes=pulumi.get(__ret__, 'attributes'), + id=pulumi.get(__ret__, 'id'), + job_info=pulumi.get(__ret__, 'job_info'), + labels=pulumi.get(__ret__, 'labels'), + messages=pulumi.get(__ret__, 'messages'), + optimized=pulumi.get(__ret__, 'optimized'), + org_id=pulumi.get(__ret__, 'org_id'), + org_name=pulumi.get(__ret__, 'org_name'), + platform=pulumi.get(__ret__, 'platform'), + progress=pulumi.get(__ret__, 'progress'), + workflow=pulumi.get(__ret__, 'workflow'), + workflow_id=pulumi.get(__ret__, 'workflow_id'), + workspace_id=pulumi.get(__ret__, 'workspace_id'), + workspace_name=pulumi.get(__ret__, 'workspace_name')) +def get_workflows_output(attributes: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None, + workflow_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetWorkflowsResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['workflowId'] = workflow_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getWorkflows:getWorkflows', __args__, opts=opts, typ=GetWorkflowsResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetWorkflowsResult( + attributes=pulumi.get(__response__, 'attributes'), + id=pulumi.get(__response__, 'id'), + job_info=pulumi.get(__response__, 'job_info'), + labels=pulumi.get(__response__, 'labels'), + messages=pulumi.get(__response__, 'messages'), + optimized=pulumi.get(__response__, 'optimized'), + org_id=pulumi.get(__response__, 'org_id'), + org_name=pulumi.get(__response__, 'org_name'), + platform=pulumi.get(__response__, 'platform'), + progress=pulumi.get(__response__, 'progress'), + workflow=pulumi.get(__response__, 'workflow'), + workflow_id=pulumi.get(__response__, 'workflow_id'), + workspace_id=pulumi.get(__response__, 'workspace_id'), + workspace_name=pulumi.get(__response__, 'workspace_name'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workspace.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workspace.py new file mode 100644 index 00000000..dea4d112 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workspace.py @@ -0,0 +1,164 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetWorkspaceResult', + 'AwaitableGetWorkspaceResult', + 'get_workspace', + 'get_workspace_output', +] + +@pulumi.output_type +class GetWorkspaceResult: + """ + A collection of values returned by getWorkspace. + """ + def __init__(__self__, date_created=None, description=None, full_name=None, id=None, last_updated=None, name=None, org_id=None, visibility=None): + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if full_name and not isinstance(full_name, str): + raise TypeError("Expected argument 'full_name' to be a str") + pulumi.set(__self__, "full_name", full_name) + if id and not isinstance(id, float): + raise TypeError("Expected argument 'id' to be a float") + pulumi.set(__self__, "id", id) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if visibility and not isinstance(visibility, str): + raise TypeError("Expected argument 'visibility' to be a str") + pulumi.set(__self__, "visibility", visibility) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> _builtins.str: + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def visibility(self) -> _builtins.str: + return pulumi.get(self, "visibility") + + +class AwaitableGetWorkspaceResult(GetWorkspaceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetWorkspaceResult( + date_created=self.date_created, + description=self.description, + full_name=self.full_name, + id=self.id, + last_updated=self.last_updated, + name=self.name, + org_id=self.org_id, + visibility=self.visibility) + + +def get_workspace(description: Optional[_builtins.str] = None, + full_name: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + name: Optional[_builtins.str] = None, + org_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetWorkspaceResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['description'] = description + __args__['fullName'] = full_name + __args__['id'] = id + __args__['name'] = name + __args__['orgId'] = org_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getWorkspace:getWorkspace', __args__, opts=opts, typ=GetWorkspaceResult, package_ref=_utilities.get_package()).value + + return AwaitableGetWorkspaceResult( + date_created=pulumi.get(__ret__, 'date_created'), + description=pulumi.get(__ret__, 'description'), + full_name=pulumi.get(__ret__, 'full_name'), + id=pulumi.get(__ret__, 'id'), + last_updated=pulumi.get(__ret__, 'last_updated'), + name=pulumi.get(__ret__, 'name'), + org_id=pulumi.get(__ret__, 'org_id'), + visibility=pulumi.get(__ret__, 'visibility')) +def get_workspace_output(description: Optional[pulumi.Input[Optional[_builtins.str]]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetWorkspaceResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['description'] = description + __args__['fullName'] = full_name + __args__['id'] = id + __args__['name'] = name + __args__['orgId'] = org_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getWorkspace:getWorkspace', __args__, opts=opts, typ=GetWorkspaceResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetWorkspaceResult( + date_created=pulumi.get(__response__, 'date_created'), + description=pulumi.get(__response__, 'description'), + full_name=pulumi.get(__response__, 'full_name'), + id=pulumi.get(__response__, 'id'), + last_updated=pulumi.get(__response__, 'last_updated'), + name=pulumi.get(__response__, 'name'), + org_id=pulumi.get(__response__, 'org_id'), + visibility=pulumi.get(__response__, 'visibility'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workspaces.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workspaces.py new file mode 100644 index 00000000..947c0491 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/get_workspaces.py @@ -0,0 +1,97 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetWorkspacesResult', + 'AwaitableGetWorkspacesResult', + 'get_workspaces', + 'get_workspaces_output', +] + +@pulumi.output_type +class GetWorkspacesResult: + """ + A collection of values returned by getWorkspaces. + """ + def __init__(__self__, id=None, org_id=None, workspaces=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if workspaces and not isinstance(workspaces, list): + raise TypeError("Expected argument 'workspaces' to be a list") + pulumi.set(__self__, "workspaces", workspaces) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def workspaces(self) -> Sequence['outputs.GetWorkspacesWorkspaceResult']: + return pulumi.get(self, "workspaces") + + +class AwaitableGetWorkspacesResult(GetWorkspacesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetWorkspacesResult( + id=self.id, + org_id=self.org_id, + workspaces=self.workspaces) + + +def get_workspaces(org_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetWorkspacesResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getWorkspaces:getWorkspaces', __args__, opts=opts, typ=GetWorkspacesResult, package_ref=_utilities.get_package()).value + + return AwaitableGetWorkspacesResult( + id=pulumi.get(__ret__, 'id'), + org_id=pulumi.get(__ret__, 'org_id'), + workspaces=pulumi.get(__ret__, 'workspaces')) +def get_workspaces_output(org_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetWorkspacesResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getWorkspaces:getWorkspaces', __args__, opts=opts, typ=GetWorkspacesResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetWorkspacesResult( + id=pulumi.get(__response__, 'id'), + org_id=pulumi.get(__response__, 'org_id'), + workspaces=pulumi.get(__response__, 'workspaces'))) diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/labels.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/labels.py new file mode 100644 index 00000000..7200fb70 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/labels.py @@ -0,0 +1,395 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['LabelsArgs', 'Labels'] + +@pulumi.input_type +class LabelsArgs: + def __init__(__self__, *, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Labels resource. + :param pulumi.Input[_builtins.str] name: Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.bool] resource: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _LabelsState: + def __init__(__self__, *, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + label_id: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['LabelsLabelArgs']]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + total_size: Optional[pulumi.Input[_builtins.float]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Labels resources. + :param pulumi.Input[_builtins.float] label_id: Label numeric identifier + :param pulumi.Input[_builtins.str] name: Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.bool] resource: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if label_id is not None: + pulumi.set(__self__, "label_id", label_id) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if total_size is not None: + pulumi.set(__self__, "total_size", total_size) + if value is not None: + pulumi.set(__self__, "value", value) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter(name="labelId") + def label_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Label numeric identifier + """ + return pulumi.get(self, "label_id") + + @label_id.setter + def label_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "label_id", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LabelsLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LabelsLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter(name="totalSize") + def total_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "total_size") + + @total_size.setter + def total_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "total_size", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/labels:Labels") +class Labels(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Labels resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] name: Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.bool] resource: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[LabelsArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Labels resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param LabelsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(LabelsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = LabelsArgs.__new__(LabelsArgs) + + __props__.__dict__["is_default"] = is_default + __props__.__dict__["name"] = name + __props__.__dict__["resource"] = resource + __props__.__dict__["value"] = value + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["label_id"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["total_size"] = None + super(Labels, __self__).__init__( + 'seqera:index/labels:Labels', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + label_id: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LabelsLabelArgs', 'LabelsLabelArgsDict']]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + total_size: Optional[pulumi.Input[_builtins.float]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Labels': + """ + Get an existing Labels resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.float] label_id: Label numeric identifier + :param pulumi.Input[_builtins.str] name: Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.bool] resource: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _LabelsState.__new__(_LabelsState) + + __props__.__dict__["is_default"] = is_default + __props__.__dict__["label_id"] = label_id + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["resource"] = resource + __props__.__dict__["total_size"] = total_size + __props__.__dict__["value"] = value + __props__.__dict__["workspace_id"] = workspace_id + return Labels(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter(name="labelId") + def label_id(self) -> pulumi.Output[_builtins.float]: + """ + Label numeric identifier + """ + return pulumi.get(self, "label_id") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.LabelsLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> pulumi.Output[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter(name="totalSize") + def total_size(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "total_size") + + @_builtins.property + @pulumi.getter + def value(self) -> pulumi.Output[_builtins.str]: + """ + Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "value") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/orgs.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/orgs.py new file mode 100644 index 00000000..6d3652d5 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/orgs.py @@ -0,0 +1,465 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['OrgsArgs', 'Orgs'] + +@pulumi.input_type +class OrgsArgs: + def __init__(__self__, *, + full_name: pulumi.Input[_builtins.str], + description: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Orgs resource. + """ + pulumi.set(__self__, "full_name", full_name) + if description is not None: + pulumi.set(__self__, "description", description) + if location is not None: + pulumi.set(__self__, "location", location) + if logo_id is not None: + pulumi.set(__self__, "logo_id", logo_id) + if name is not None: + pulumi.set(__self__, "name", name) + if website is not None: + pulumi.set(__self__, "website", website) + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "full_name") + + @full_name.setter + def full_name(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "full_name", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="logoId") + def logo_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "logo_id") + + @logo_id.setter + def logo_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "logo_id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def website(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "website") + + @website.setter + def website(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "website", value) + + +@pulumi.input_type +class _OrgsState: + def __init__(__self__, *, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + logo_url: Optional[pulumi.Input[_builtins.str]] = None, + member_id: Optional[pulumi.Input[_builtins.float]] = None, + member_role: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + paying: Optional[pulumi.Input[_builtins.bool]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None): + """ + Input properties used for looking up and filtering Orgs resources. + :param pulumi.Input[_builtins.str] member_role: must be one of ["owner", "member", "collaborator"] + :param pulumi.Input[_builtins.float] org_id: Unique numeric identifier for the organization + :param pulumi.Input[_builtins.bool] paying: Deprecated flag indicating if organization has paid subscription + :param pulumi.Input[_builtins.str] type: must be one of ["academic", "evaluating", "pro", "basic", "internal"] + """ + if description is not None: + pulumi.set(__self__, "description", description) + if full_name is not None: + pulumi.set(__self__, "full_name", full_name) + if location is not None: + pulumi.set(__self__, "location", location) + if logo_id is not None: + pulumi.set(__self__, "logo_id", logo_id) + if logo_url is not None: + pulumi.set(__self__, "logo_url", logo_url) + if member_id is not None: + pulumi.set(__self__, "member_id", member_id) + if member_role is not None: + pulumi.set(__self__, "member_role", member_role) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if paying is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""paying is deprecated: Deprecated""") + if paying is not None: + pulumi.set(__self__, "paying", paying) + if type is not None: + pulumi.set(__self__, "type", type) + if website is not None: + pulumi.set(__self__, "website", website) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "full_name") + + @full_name.setter + def full_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "full_name", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="logoId") + def logo_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "logo_id") + + @logo_id.setter + def logo_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "logo_id", value) + + @_builtins.property + @pulumi.getter(name="logoUrl") + def logo_url(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "logo_url") + + @logo_url.setter + def logo_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "logo_url", value) + + @_builtins.property + @pulumi.getter(name="memberId") + def member_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "member_id") + + @member_id.setter + def member_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "member_id", value) + + @_builtins.property + @pulumi.getter(name="memberRole") + def member_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["owner", "member", "collaborator"] + """ + return pulumi.get(self, "member_role") + + @member_role.setter + def member_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "member_role", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the organization + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def paying(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Deprecated flag indicating if organization has paid subscription + """ + return pulumi.get(self, "paying") + + @paying.setter + def paying(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "paying", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["academic", "evaluating", "pro", "basic", "internal"] + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter + def website(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "website") + + @website.setter + def website(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "website", value) + + +@pulumi.type_token("seqera:index/orgs:Orgs") +class Orgs(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None, + __props__=None): + """ + Create a Orgs resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: OrgsArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Orgs resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param OrgsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(OrgsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = OrgsArgs.__new__(OrgsArgs) + + __props__.__dict__["description"] = description + if full_name is None and not opts.urn: + raise TypeError("Missing required property 'full_name'") + __props__.__dict__["full_name"] = full_name + __props__.__dict__["location"] = location + __props__.__dict__["logo_id"] = logo_id + __props__.__dict__["name"] = name + __props__.__dict__["website"] = website + __props__.__dict__["logo_url"] = None + __props__.__dict__["member_id"] = None + __props__.__dict__["member_role"] = None + __props__.__dict__["org_id"] = None + __props__.__dict__["paying"] = None + __props__.__dict__["type"] = None + super(Orgs, __self__).__init__( + 'seqera:index/orgs:Orgs', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + logo_url: Optional[pulumi.Input[_builtins.str]] = None, + member_id: Optional[pulumi.Input[_builtins.float]] = None, + member_role: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + paying: Optional[pulumi.Input[_builtins.bool]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None) -> 'Orgs': + """ + Get an existing Orgs resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] member_role: must be one of ["owner", "member", "collaborator"] + :param pulumi.Input[_builtins.float] org_id: Unique numeric identifier for the organization + :param pulumi.Input[_builtins.bool] paying: Deprecated flag indicating if organization has paid subscription + :param pulumi.Input[_builtins.str] type: must be one of ["academic", "evaluating", "pro", "basic", "internal"] + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _OrgsState.__new__(_OrgsState) + + __props__.__dict__["description"] = description + __props__.__dict__["full_name"] = full_name + __props__.__dict__["location"] = location + __props__.__dict__["logo_id"] = logo_id + __props__.__dict__["logo_url"] = logo_url + __props__.__dict__["member_id"] = member_id + __props__.__dict__["member_role"] = member_role + __props__.__dict__["name"] = name + __props__.__dict__["org_id"] = org_id + __props__.__dict__["paying"] = paying + __props__.__dict__["type"] = type + __props__.__dict__["website"] = website + return Orgs(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter + def location(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="logoId") + def logo_id(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "logo_id") + + @_builtins.property + @pulumi.getter(name="logoUrl") + def logo_url(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "logo_url") + + @_builtins.property + @pulumi.getter(name="memberId") + def member_id(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "member_id") + + @_builtins.property + @pulumi.getter(name="memberRole") + def member_role(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["owner", "member", "collaborator"] + """ + return pulumi.get(self, "member_role") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the organization + """ + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def paying(self) -> pulumi.Output[_builtins.bool]: + """ + Deprecated flag indicating if organization has paid subscription + """ + return pulumi.get(self, "paying") + + @_builtins.property + @pulumi.getter + def type(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["academic", "evaluating", "pro", "basic", "internal"] + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter + def website(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "website") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/outputs.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/outputs.py new file mode 100644 index 00000000..b2e321b7 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/outputs.py @@ -0,0 +1,25334 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'ActionConfig', + 'ActionConfigGithub', + 'ActionConfigTower', + 'ActionEvent', + 'ActionEventGithub', + 'ActionEventTower', + 'ActionLabel', + 'ActionLaunch', + 'ActionLaunchComputeEnv', + 'ActionLaunchComputeEnvConfig', + 'ActionLaunchComputeEnvConfigAltairPlatform', + 'ActionLaunchComputeEnvConfigAltairPlatformEnvironment', + 'ActionLaunchComputeEnvConfigAwsBatch', + 'ActionLaunchComputeEnvConfigAwsBatchEnvironment', + 'ActionLaunchComputeEnvConfigAwsBatchForge', + 'ActionLaunchComputeEnvConfigAwsCloud', + 'ActionLaunchComputeEnvConfigAwsCloudEnvironment', + 'ActionLaunchComputeEnvConfigAzureBatch', + 'ActionLaunchComputeEnvConfigAzureBatchEnvironment', + 'ActionLaunchComputeEnvConfigAzureBatchForge', + 'ActionLaunchComputeEnvConfigEksPlatform', + 'ActionLaunchComputeEnvConfigEksPlatformEnvironment', + 'ActionLaunchComputeEnvConfigGkePlatform', + 'ActionLaunchComputeEnvConfigGkePlatformEnvironment', + 'ActionLaunchComputeEnvConfigGoogleBatch', + 'ActionLaunchComputeEnvConfigGoogleBatchEnvironment', + 'ActionLaunchComputeEnvConfigGoogleLifesciences', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironment', + 'ActionLaunchComputeEnvConfigK8sPlatform', + 'ActionLaunchComputeEnvConfigK8sPlatformEnvironment', + 'ActionLaunchComputeEnvConfigLsfPlatform', + 'ActionLaunchComputeEnvConfigLsfPlatformEnvironment', + 'ActionLaunchComputeEnvConfigMoabPlatform', + 'ActionLaunchComputeEnvConfigMoabPlatformEnvironment', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatform', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironment', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformForge', + 'ActionLaunchComputeEnvConfigSlurmPlatform', + 'ActionLaunchComputeEnvConfigSlurmPlatformEnvironment', + 'ActionLaunchComputeEnvConfigUgePlatform', + 'ActionLaunchComputeEnvConfigUgePlatformEnvironment', + 'ComputeEnvComputeEnv', + 'ComputeEnvComputeEnvConfig', + 'ComputeEnvComputeEnvConfigAltairPlatform', + 'ComputeEnvComputeEnvConfigAltairPlatformEnvironment', + 'ComputeEnvComputeEnvConfigAwsBatch', + 'ComputeEnvComputeEnvConfigAwsBatchEnvironment', + 'ComputeEnvComputeEnvConfigAwsBatchForge', + 'ComputeEnvComputeEnvConfigAwsCloud', + 'ComputeEnvComputeEnvConfigAwsCloudEnvironment', + 'ComputeEnvComputeEnvConfigAzureBatch', + 'ComputeEnvComputeEnvConfigAzureBatchEnvironment', + 'ComputeEnvComputeEnvConfigAzureBatchForge', + 'ComputeEnvComputeEnvConfigEksPlatform', + 'ComputeEnvComputeEnvConfigEksPlatformEnvironment', + 'ComputeEnvComputeEnvConfigGkePlatform', + 'ComputeEnvComputeEnvConfigGkePlatformEnvironment', + 'ComputeEnvComputeEnvConfigGoogleBatch', + 'ComputeEnvComputeEnvConfigGoogleBatchEnvironment', + 'ComputeEnvComputeEnvConfigGoogleLifesciences', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironment', + 'ComputeEnvComputeEnvConfigK8sPlatform', + 'ComputeEnvComputeEnvConfigK8sPlatformEnvironment', + 'ComputeEnvComputeEnvConfigLsfPlatform', + 'ComputeEnvComputeEnvConfigLsfPlatformEnvironment', + 'ComputeEnvComputeEnvConfigMoabPlatform', + 'ComputeEnvComputeEnvConfigMoabPlatformEnvironment', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatform', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironment', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformForge', + 'ComputeEnvComputeEnvConfigSlurmPlatform', + 'ComputeEnvComputeEnvConfigSlurmPlatformEnvironment', + 'ComputeEnvComputeEnvConfigUgePlatform', + 'ComputeEnvComputeEnvConfigUgePlatformEnvironment', + 'ComputeEnvComputeEnvLabel', + 'CredentialKeys', + 'CredentialKeysAws', + 'CredentialKeysAzure', + 'CredentialKeysAzureEntra', + 'CredentialKeysAzurerepos', + 'CredentialKeysBitbucket', + 'CredentialKeysCodecommit', + 'CredentialKeysContainerReg', + 'CredentialKeysGitea', + 'CredentialKeysGithub', + 'CredentialKeysGitlab', + 'CredentialKeysGoogle', + 'CredentialKeysK8s', + 'CredentialKeysSeqeracompute', + 'CredentialKeysSsh', + 'CredentialKeysTwAgent', + 'DataLinkCredential', + 'LabelsLabel', + 'PipelineComputeEnv', + 'PipelineLabel', + 'PipelineLaunch', + 'StudiosActiveConnection', + 'StudiosComputeEnv', + 'StudiosConfiguration', + 'StudiosLabel', + 'StudiosMountedDataLink', + 'StudiosMountedDataLinkCredential', + 'StudiosParentCheckpoint', + 'StudiosProgress', + 'StudiosStatusInfo', + 'StudiosTemplate', + 'StudiosUser', + 'TokensToken', + 'WorkflowsJobInfo', + 'WorkflowsLabel', + 'WorkflowsPlatform', + 'WorkflowsProgress', + 'WorkflowsProgressProcessesProgress', + 'WorkflowsProgressWorkflowProgress', + 'WorkflowsWorkflow', + 'WorkflowsWorkflowManifest', + 'WorkflowsWorkflowNextflow', + 'WorkflowsWorkflowStats', + 'GetActionConfigResult', + 'GetActionConfigGithubResult', + 'GetActionConfigTowerResult', + 'GetActionEventResult', + 'GetActionEventGithubResult', + 'GetActionEventTowerResult', + 'GetActionLabelResult', + 'GetActionLaunchResult', + 'GetActionLaunchComputeEnvResult', + 'GetActionLaunchComputeEnvConfigResult', + 'GetActionLaunchComputeEnvConfigAltairPlatformResult', + 'GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigAwsBatchResult', + 'GetActionLaunchComputeEnvConfigAwsBatchEnvironmentResult', + 'GetActionLaunchComputeEnvConfigAwsBatchForgeResult', + 'GetActionLaunchComputeEnvConfigAwsCloudResult', + 'GetActionLaunchComputeEnvConfigAwsCloudEnvironmentResult', + 'GetActionLaunchComputeEnvConfigAzureBatchResult', + 'GetActionLaunchComputeEnvConfigAzureBatchEnvironmentResult', + 'GetActionLaunchComputeEnvConfigAzureBatchForgeResult', + 'GetActionLaunchComputeEnvConfigEksPlatformResult', + 'GetActionLaunchComputeEnvConfigEksPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigGkePlatformResult', + 'GetActionLaunchComputeEnvConfigGkePlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigGoogleBatchResult', + 'GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentResult', + 'GetActionLaunchComputeEnvConfigGoogleLifesciencesResult', + 'GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentResult', + 'GetActionLaunchComputeEnvConfigK8sPlatformResult', + 'GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigLsfPlatformResult', + 'GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigMoabPlatformResult', + 'GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigSeqeracomputePlatformResult', + 'GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigSeqeracomputePlatformForgeResult', + 'GetActionLaunchComputeEnvConfigSlurmPlatformResult', + 'GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigUgePlatformResult', + 'GetActionLaunchComputeEnvConfigUgePlatformEnvironmentResult', + 'GetComputeEnvComputeEnvResult', + 'GetComputeEnvComputeEnvConfigResult', + 'GetComputeEnvComputeEnvConfigAltairPlatformResult', + 'GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigAwsBatchResult', + 'GetComputeEnvComputeEnvConfigAwsBatchEnvironmentResult', + 'GetComputeEnvComputeEnvConfigAwsBatchForgeResult', + 'GetComputeEnvComputeEnvConfigAwsCloudResult', + 'GetComputeEnvComputeEnvConfigAwsCloudEnvironmentResult', + 'GetComputeEnvComputeEnvConfigAzureBatchResult', + 'GetComputeEnvComputeEnvConfigAzureBatchEnvironmentResult', + 'GetComputeEnvComputeEnvConfigAzureBatchForgeResult', + 'GetComputeEnvComputeEnvConfigEksPlatformResult', + 'GetComputeEnvComputeEnvConfigEksPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigGkePlatformResult', + 'GetComputeEnvComputeEnvConfigGkePlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigGoogleBatchResult', + 'GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentResult', + 'GetComputeEnvComputeEnvConfigGoogleLifesciencesResult', + 'GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentResult', + 'GetComputeEnvComputeEnvConfigK8sPlatformResult', + 'GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigLsfPlatformResult', + 'GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigMoabPlatformResult', + 'GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigSeqeracomputePlatformResult', + 'GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigSeqeracomputePlatformForgeResult', + 'GetComputeEnvComputeEnvConfigSlurmPlatformResult', + 'GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigUgePlatformResult', + 'GetComputeEnvComputeEnvConfigUgePlatformEnvironmentResult', + 'GetComputeEnvComputeEnvLabelResult', + 'GetCredentialKeysResult', + 'GetCredentialKeysAwsResult', + 'GetCredentialKeysAzureResult', + 'GetCredentialKeysAzureEntraResult', + 'GetCredentialKeysAzurereposResult', + 'GetCredentialKeysBitbucketResult', + 'GetCredentialKeysCodecommitResult', + 'GetCredentialKeysContainerRegResult', + 'GetCredentialKeysGiteaResult', + 'GetCredentialKeysGithubResult', + 'GetCredentialKeysGitlabResult', + 'GetCredentialKeysGoogleResult', + 'GetCredentialKeysK8sResult', + 'GetCredentialKeysSeqeracomputeResult', + 'GetCredentialKeysSshResult', + 'GetCredentialKeysTwAgentResult', + 'GetDataLinkCredentialResult', + 'GetDatasetDatasetResult', + 'GetLabelsLabelResult', + 'GetPipelineComputeEnvResult', + 'GetPipelineLabelResult', + 'GetStudiosActiveConnectionResult', + 'GetStudiosComputeEnvResult', + 'GetStudiosConfigurationResult', + 'GetStudiosLabelResult', + 'GetStudiosMountedDataLinkResult', + 'GetStudiosMountedDataLinkCredentialResult', + 'GetStudiosParentCheckpointResult', + 'GetStudiosProgressResult', + 'GetStudiosStatusInfoResult', + 'GetStudiosTemplateResult', + 'GetStudiosUserResult', + 'GetUserWorkspacesOrgsAndWorkspaceResult', + 'GetWorkflowsJobInfoResult', + 'GetWorkflowsLabelResult', + 'GetWorkflowsPlatformResult', + 'GetWorkflowsProgressResult', + 'GetWorkflowsProgressProcessesProgressResult', + 'GetWorkflowsProgressWorkflowProgressResult', + 'GetWorkflowsWorkflowResult', + 'GetWorkflowsWorkflowManifestResult', + 'GetWorkflowsWorkflowNextflowResult', + 'GetWorkflowsWorkflowStatsResult', + 'GetWorkspacesWorkspaceResult', +] + +@pulumi.output_type +class ActionConfig(dict): + def __init__(__self__, *, + github: Optional['outputs.ActionConfigGithub'] = None, + tower: Optional['outputs.ActionConfigTower'] = None): + if github is not None: + pulumi.set(__self__, "github", github) + if tower is not None: + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional['outputs.ActionConfigGithub']: + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def tower(self) -> Optional['outputs.ActionConfigTower']: + return pulumi.get(self, "tower") + + +@pulumi.output_type +class ActionConfigGithub(dict): + def __init__(__self__, *, + discriminator: Optional[_builtins.str] = None, + events: Optional[Sequence[_builtins.str]] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if events is not None: + pulumi.set(__self__, "events", events) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[_builtins.str]: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter + def events(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "events") + + +@pulumi.output_type +class ActionConfigTower(dict): + def __init__(__self__, *, + discriminator: Optional[_builtins.str] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[_builtins.str]: + return pulumi.get(self, "discriminator") + + +@pulumi.output_type +class ActionEvent(dict): + def __init__(__self__, *, + github: Optional['outputs.ActionEventGithub'] = None, + tower: Optional['outputs.ActionEventTower'] = None): + if github is not None: + pulumi.set(__self__, "github", github) + if tower is not None: + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional['outputs.ActionEventGithub']: + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def tower(self) -> Optional['outputs.ActionEventTower']: + return pulumi.get(self, "tower") + + +@pulumi.output_type +class ActionEventGithub(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "commitId": + suggest = "commit_id" + elif key == "commitMessage": + suggest = "commit_message" + elif key == "pusherEmail": + suggest = "pusher_email" + elif key == "pusherName": + suggest = "pusher_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionEventGithub. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionEventGithub.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionEventGithub.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + commit_id: Optional[_builtins.str] = None, + commit_message: Optional[_builtins.str] = None, + discriminator: Optional[_builtins.str] = None, + pusher_email: Optional[_builtins.str] = None, + pusher_name: Optional[_builtins.str] = None, + ref: Optional[_builtins.str] = None, + timestamp: Optional[_builtins.str] = None): + if commit_id is not None: + pulumi.set(__self__, "commit_id", commit_id) + if commit_message is not None: + pulumi.set(__self__, "commit_message", commit_message) + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if pusher_email is not None: + pulumi.set(__self__, "pusher_email", pusher_email) + if pusher_name is not None: + pulumi.set(__self__, "pusher_name", pusher_name) + if ref is not None: + pulumi.set(__self__, "ref", ref) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "commit_id") + + @_builtins.property + @pulumi.getter(name="commitMessage") + def commit_message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "commit_message") + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[_builtins.str]: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter(name="pusherEmail") + def pusher_email(self) -> Optional[_builtins.str]: + return pulumi.get(self, "pusher_email") + + @_builtins.property + @pulumi.getter(name="pusherName") + def pusher_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "pusher_name") + + @_builtins.property + @pulumi.getter + def ref(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ref") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[_builtins.str]: + return pulumi.get(self, "timestamp") + + +@pulumi.output_type +class ActionEventTower(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "workflowId": + suggest = "workflow_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionEventTower. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionEventTower.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionEventTower.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + discriminator: Optional[_builtins.str] = None, + timestamp: Optional[_builtins.str] = None, + workflow_id: Optional[_builtins.str] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + if workflow_id is not None: + pulumi.set(__self__, "workflow_id", workflow_id) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[_builtins.str]: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[_builtins.str]: + return pulumi.get(self, "timestamp") + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "workflow_id") + + +@pulumi.output_type +class ActionLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeEnvId": + suggest = "compute_env_id" + elif key == "workDir": + suggest = "work_dir" + elif key == "computeEnv": + suggest = "compute_env" + elif key == "configProfiles": + suggest = "config_profiles" + elif key == "configText": + suggest = "config_text" + elif key == "dateCreated": + suggest = "date_created" + elif key == "entryName": + suggest = "entry_name" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "labelIds": + suggest = "label_ids" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "launchContainer": + suggest = "launch_container" + elif key == "mainScript": + suggest = "main_script" + elif key == "optimizationId": + suggest = "optimization_id" + elif key == "optimizationTargets": + suggest = "optimization_targets" + elif key == "paramsText": + suggest = "params_text" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "pullLatest": + suggest = "pull_latest" + elif key == "resumeLaunchId": + suggest = "resume_launch_id" + elif key == "runName": + suggest = "run_name" + elif key == "schemaName": + suggest = "schema_name" + elif key == "sessionId": + suggest = "session_id" + elif key == "stubRun": + suggest = "stub_run" + elif key == "towerConfig": + suggest = "tower_config" + elif key == "userSecrets": + suggest = "user_secrets" + elif key == "workspaceSecrets": + suggest = "workspace_secrets" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_env_id: _builtins.str, + pipeline: _builtins.str, + work_dir: _builtins.str, + compute_env: Optional['outputs.ActionLaunchComputeEnv'] = None, + config_profiles: Optional[Sequence[_builtins.str]] = None, + config_text: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + entry_name: Optional[_builtins.str] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + id: Optional[_builtins.str] = None, + label_ids: Optional[Sequence[_builtins.float]] = None, + last_updated: Optional[_builtins.str] = None, + launch_container: Optional[_builtins.str] = None, + main_script: Optional[_builtins.str] = None, + optimization_id: Optional[_builtins.str] = None, + optimization_targets: Optional[_builtins.str] = None, + params_text: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + pull_latest: Optional[_builtins.bool] = None, + resume: Optional[_builtins.bool] = None, + resume_launch_id: Optional[_builtins.str] = None, + revision: Optional[_builtins.str] = None, + run_name: Optional[_builtins.str] = None, + schema_name: Optional[_builtins.str] = None, + session_id: Optional[_builtins.str] = None, + stub_run: Optional[_builtins.bool] = None, + tower_config: Optional[_builtins.str] = None, + user_secrets: Optional[Sequence[_builtins.str]] = None, + workspace_secrets: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str compute_env_id: Requires replacement if changed. + :param _builtins.str pipeline: Requires replacement if changed. + :param _builtins.str work_dir: Requires replacement if changed. + :param Sequence[_builtins.str] config_profiles: Requires replacement if changed. + :param _builtins.str config_text: Requires replacement if changed. + :param _builtins.str date_created: Requires replacement if changed. + :param _builtins.str entry_name: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param Sequence[_builtins.float] label_ids: Requires replacement if changed. + :param _builtins.str launch_container: Requires replacement if changed. + :param _builtins.str main_script: Requires replacement if changed. + :param _builtins.str optimization_id: Requires replacement if changed. + :param _builtins.str optimization_targets: Requires replacement if changed. + :param _builtins.str params_text: Requires replacement if changed. + :param _builtins.str post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + :param _builtins.str pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + :param _builtins.bool pull_latest: Requires replacement if changed. + :param _builtins.bool resume: Requires replacement if changed. + :param _builtins.str revision: Requires replacement if changed. + :param _builtins.str run_name: Requires replacement if changed. + :param _builtins.str schema_name: Requires replacement if changed. + :param _builtins.str session_id: Requires replacement if changed. + :param _builtins.bool stub_run: Requires replacement if changed. + :param _builtins.str tower_config: Requires replacement if changed. + :param Sequence[_builtins.str] user_secrets: Requires replacement if changed. + :param Sequence[_builtins.str] workspace_secrets: Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if id is not None: + pulumi.set(__self__, "id", id) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if resume_launch_id is not None: + pulumi.set(__self__, "resume_launch_id", resume_launch_id) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def pipeline(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional['outputs.ActionLaunchComputeEnv']: + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[Sequence[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter(name="resumeLaunchId") + def resume_launch_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "resume_launch_id") + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + + +@pulumi.output_type +class ActionLaunchComputeEnv(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeEnvId": + suggest = "compute_env_id" + elif key == "credentialsId": + suggest = "credentials_id" + elif key == "dateCreated": + suggest = "date_created" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "lastUsed": + suggest = "last_used" + elif key == "orgId": + suggest = "org_id" + elif key == "workspaceId": + suggest = "workspace_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnv. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnv.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnv.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_env_id: Optional[_builtins.str] = None, + config: Optional['outputs.ActionLaunchComputeEnvConfig'] = None, + credentials_id: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + deleted: Optional[_builtins.bool] = None, + description: Optional[_builtins.str] = None, + last_updated: Optional[_builtins.str] = None, + last_used: Optional[_builtins.str] = None, + message: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + org_id: Optional[_builtins.float] = None, + platform: Optional[_builtins.str] = None, + primary: Optional[_builtins.bool] = None, + status: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None): + """ + :param 'ActionLaunchComputeEnvConfigArgs' config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + :param _builtins.str platform: must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + :param _builtins.str status: must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if config is not None: + pulumi.set(__self__, "config", config) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if primary is not None: + pulumi.set(__self__, "primary", primary) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def config(self) -> Optional['outputs.ActionLaunchComputeEnvConfig']: + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[_builtins.str]: + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + """ + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def primary(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "primary") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "altairPlatform": + suggest = "altair_platform" + elif key == "awsBatch": + suggest = "aws_batch" + elif key == "awsCloud": + suggest = "aws_cloud" + elif key == "azureBatch": + suggest = "azure_batch" + elif key == "eksPlatform": + suggest = "eks_platform" + elif key == "gkePlatform": + suggest = "gke_platform" + elif key == "googleBatch": + suggest = "google_batch" + elif key == "googleLifesciences": + suggest = "google_lifesciences" + elif key == "k8sPlatform": + suggest = "k8s_platform" + elif key == "lsfPlatform": + suggest = "lsf_platform" + elif key == "moabPlatform": + suggest = "moab_platform" + elif key == "seqeracomputePlatform": + suggest = "seqeracompute_platform" + elif key == "slurmPlatform": + suggest = "slurm_platform" + elif key == "ugePlatform": + suggest = "uge_platform" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + altair_platform: Optional['outputs.ActionLaunchComputeEnvConfigAltairPlatform'] = None, + aws_batch: Optional['outputs.ActionLaunchComputeEnvConfigAwsBatch'] = None, + aws_cloud: Optional['outputs.ActionLaunchComputeEnvConfigAwsCloud'] = None, + azure_batch: Optional['outputs.ActionLaunchComputeEnvConfigAzureBatch'] = None, + eks_platform: Optional['outputs.ActionLaunchComputeEnvConfigEksPlatform'] = None, + gke_platform: Optional['outputs.ActionLaunchComputeEnvConfigGkePlatform'] = None, + google_batch: Optional['outputs.ActionLaunchComputeEnvConfigGoogleBatch'] = None, + google_lifesciences: Optional['outputs.ActionLaunchComputeEnvConfigGoogleLifesciences'] = None, + k8s_platform: Optional['outputs.ActionLaunchComputeEnvConfigK8sPlatform'] = None, + lsf_platform: Optional['outputs.ActionLaunchComputeEnvConfigLsfPlatform'] = None, + moab_platform: Optional['outputs.ActionLaunchComputeEnvConfigMoabPlatform'] = None, + seqeracompute_platform: Optional['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatform'] = None, + slurm_platform: Optional['outputs.ActionLaunchComputeEnvConfigSlurmPlatform'] = None, + uge_platform: Optional['outputs.ActionLaunchComputeEnvConfigUgePlatform'] = None): + if altair_platform is not None: + pulumi.set(__self__, "altair_platform", altair_platform) + if aws_batch is not None: + pulumi.set(__self__, "aws_batch", aws_batch) + if aws_cloud is not None: + pulumi.set(__self__, "aws_cloud", aws_cloud) + if azure_batch is not None: + pulumi.set(__self__, "azure_batch", azure_batch) + if eks_platform is not None: + pulumi.set(__self__, "eks_platform", eks_platform) + if gke_platform is not None: + pulumi.set(__self__, "gke_platform", gke_platform) + if google_batch is not None: + pulumi.set(__self__, "google_batch", google_batch) + if google_lifesciences is not None: + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + if k8s_platform is not None: + pulumi.set(__self__, "k8s_platform", k8s_platform) + if lsf_platform is not None: + pulumi.set(__self__, "lsf_platform", lsf_platform) + if moab_platform is not None: + pulumi.set(__self__, "moab_platform", moab_platform) + if seqeracompute_platform is not None: + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + if slurm_platform is not None: + pulumi.set(__self__, "slurm_platform", slurm_platform) + if uge_platform is not None: + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAltairPlatform']: + return pulumi.get(self, "altair_platform") + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAwsBatch']: + return pulumi.get(self, "aws_batch") + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAwsCloud']: + return pulumi.get(self, "aws_cloud") + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAzureBatch']: + return pulumi.get(self, "azure_batch") + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigEksPlatform']: + return pulumi.get(self, "eks_platform") + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigGkePlatform']: + return pulumi.get(self, "gke_platform") + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> Optional['outputs.ActionLaunchComputeEnvConfigGoogleBatch']: + return pulumi.get(self, "google_batch") + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> Optional['outputs.ActionLaunchComputeEnvConfigGoogleLifesciences']: + return pulumi.get(self, "google_lifesciences") + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigK8sPlatform']: + return pulumi.get(self, "k8s_platform") + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigLsfPlatform']: + return pulumi.get(self, "lsf_platform") + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigMoabPlatform']: + return pulumi.get(self, "moab_platform") + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatform']: + return pulumi.get(self, "seqeracompute_platform") + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigSlurmPlatform']: + return pulumi.get(self, "slurm_platform") + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigUgePlatform']: + return pulumi.get(self, "uge_platform") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAltairPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAltairPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAltairPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAltairPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAltairPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAltairPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAltairPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cliPath": + suggest = "cli_path" + elif key == "computeJobRole": + suggest = "compute_job_role" + elif key == "computeQueue": + suggest = "compute_queue" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "dragenQueue": + suggest = "dragen_queue" + elif key == "executionRole": + suggest = "execution_role" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "fusionSnapshots": + suggest = "fusion_snapshots" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headJobRole": + suggest = "head_job_role" + elif key == "headQueue": + suggest = "head_queue" + elif key == "logGroup": + suggest = "log_group" + elif key == "lustreId": + suggest = "lustre_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nvnmeStorageEnabled": + suggest = "nvnme_storage_enabled" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "storageType": + suggest = "storage_type" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAwsBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAwsBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAwsBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cli_path: Optional[_builtins.str] = None, + compute_job_role: Optional[_builtins.str] = None, + compute_queue: Optional[_builtins.str] = None, + dragen_instance_type: Optional[_builtins.str] = None, + dragen_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAwsBatchEnvironment']] = None, + execution_role: Optional[_builtins.str] = None, + forge: Optional['outputs.ActionLaunchComputeEnvConfigAwsBatchForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + fusion_snapshots: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_job_role: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + lustre_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nvnme_storage_enabled: Optional[_builtins.bool] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + storage_type: Optional[_builtins.str] = None, + volumes: Optional[Sequence[_builtins.str]] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAwsBatchEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAwsBatchForge']: + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsBatchForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allocStrategy": + suggest = "alloc_strategy" + elif key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "bidPercentage": + suggest = "bid_percentage" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "dragenAmiId": + suggest = "dragen_ami_id" + elif key == "dragenEnabled": + suggest = "dragen_enabled" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "ebsAutoScale": + suggest = "ebs_auto_scale" + elif key == "ebsBlockSize": + suggest = "ebs_block_size" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "ecsConfig": + suggest = "ecs_config" + elif key == "efsCreate": + suggest = "efs_create" + elif key == "efsId": + suggest = "efs_id" + elif key == "efsMount": + suggest = "efs_mount" + elif key == "fargateHeadEnabled": + suggest = "fargate_head_enabled" + elif key == "fsxMount": + suggest = "fsx_mount" + elif key == "fsxName": + suggest = "fsx_name" + elif key == "fsxSize": + suggest = "fsx_size" + elif key == "fusionEnabled": + suggest = "fusion_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceTypes": + suggest = "instance_types" + elif key == "maxCpus": + suggest = "max_cpus" + elif key == "minCpus": + suggest = "min_cpus" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "vpcId": + suggest = "vpc_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAwsBatchForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAwsBatchForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAwsBatchForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alloc_strategy: Optional[_builtins.str] = None, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + bid_percentage: Optional[_builtins.float] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + dragen_ami_id: Optional[_builtins.str] = None, + dragen_enabled: Optional[_builtins.bool] = None, + dragen_instance_type: Optional[_builtins.str] = None, + ebs_auto_scale: Optional[_builtins.bool] = None, + ebs_block_size: Optional[_builtins.float] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + ecs_config: Optional[_builtins.str] = None, + efs_create: Optional[_builtins.bool] = None, + efs_id: Optional[_builtins.str] = None, + efs_mount: Optional[_builtins.str] = None, + fargate_head_enabled: Optional[_builtins.bool] = None, + fsx_mount: Optional[_builtins.str] = None, + fsx_name: Optional[_builtins.str] = None, + fsx_size: Optional[_builtins.float] = None, + fusion_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_types: Optional[Sequence[_builtins.str]] = None, + max_cpus: Optional[_builtins.float] = None, + min_cpus: Optional[_builtins.float] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnets: Optional[Sequence[_builtins.str]] = None, + type: Optional[_builtins.str] = None, + vpc_id: Optional[_builtins.str] = None): + """ + :param _builtins.str alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + :param _builtins.str type: must be one of ["SPOT", "EC2"] + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[_builtins.str]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[_builtins.float]: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + must be one of ["SPOT", "EC2"] + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsCloud(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceProfileArn": + suggest = "instance_profile_arn" + elif key == "instanceType": + suggest = "instance_type" + elif key == "logGroup": + suggest = "log_group" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "subnetId": + suggest = "subnet_id" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAwsCloud. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAwsCloud.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAwsCloud.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAwsCloudEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_profile_arn: Optional[_builtins.str] = None, + instance_type: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnet_id: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_profile_arn is not None: + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + if instance_type is not None: + pulumi.set(__self__, "instance_type", instance_type) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnet_id is not None: + pulumi.set(__self__, "subnet_id", subnet_id) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAwsCloudEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> Optional[_builtins.str]: + return pulumi.get(self, "instance_profile_arn") + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "instance_type") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "subnet_id") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsCloudEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAzureBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "autoPoolMode": + suggest = "auto_pool_mode" + elif key == "deleteJobsOnCompletion": + suggest = "delete_jobs_on_completion" + elif key == "deletePoolsOnCompletion": + suggest = "delete_pools_on_completion" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headPool": + suggest = "head_pool" + elif key == "managedIdentityClientId": + suggest = "managed_identity_client_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "tokenDuration": + suggest = "token_duration" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAzureBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAzureBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAzureBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auto_pool_mode: Optional[_builtins.bool] = None, + delete_jobs_on_completion: Optional[_builtins.str] = None, + delete_pools_on_completion: Optional[_builtins.bool] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAzureBatchEnvironment']] = None, + forge: Optional['outputs.ActionLaunchComputeEnvConfigAzureBatchForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_pool: Optional[_builtins.str] = None, + managed_identity_client_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + token_duration: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str delete_jobs_on_completion: must be one of ["on_success", "always", "never"] + :param Sequence['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if auto_pool_mode is not None: + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + if delete_jobs_on_completion is not None: + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + if delete_pools_on_completion is not None: + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_pool is not None: + pulumi.set(__self__, "head_pool", head_pool) + if managed_identity_client_id is not None: + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if token_duration is not None: + pulumi.set(__self__, "token_duration", token_duration) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "auto_pool_mode") + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "delete_jobs_on_completion") + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "delete_pools_on_completion") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAzureBatchEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAzureBatchForge']: + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_pool") + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "managed_identity_client_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> Optional[_builtins.str]: + return pulumi.get(self, "token_duration") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAzureBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAzureBatchForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "autoScale": + suggest = "auto_scale" + elif key == "containerRegIds": + suggest = "container_reg_ids" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "vmCount": + suggest = "vm_count" + elif key == "vmType": + suggest = "vm_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAzureBatchForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAzureBatchForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAzureBatchForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auto_scale: Optional[_builtins.bool] = None, + container_reg_ids: Optional[Sequence[_builtins.str]] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + vm_count: Optional[_builtins.float] = None, + vm_type: Optional[_builtins.str] = None): + if auto_scale is not None: + pulumi.set(__self__, "auto_scale", auto_scale) + if container_reg_ids is not None: + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if vm_count is not None: + pulumi.set(__self__, "vm_count", vm_count) + if vm_type is not None: + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "auto_scale") + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "container_reg_ids") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "vm_count") + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "vm_type") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigEksPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterName": + suggest = "cluster_name" + elif key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigEksPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigEksPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigEksPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_name: Optional[_builtins.str] = None, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigEksPlatformEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cluster_name: The AWS EKS cluster name + :param Sequence['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"] + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: AWS region + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[_builtins.str]: + """ + The AWS EKS cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigEksPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + AWS region + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigEksPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGkePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterName": + suggest = "cluster_name" + elif key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigGkePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigGkePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigGkePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_name: Optional[_builtins.str] = None, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGkePlatformEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cluster_name: The GKE cluster name + :param Sequence['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"] + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: The GKE cluster region - or - zone + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[_builtins.str]: + """ + The GKE cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGkePlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + The GKE cluster region - or - zone + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGkePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGoogleBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootDiskSizeGb": + suggest = "boot_disk_size_gb" + elif key == "computeJobsInstanceTemplate": + suggest = "compute_jobs_instance_template" + elif key == "copyImage": + suggest = "copy_image" + elif key == "cpuPlatform": + suggest = "cpu_platform" + elif key == "debugMode": + suggest = "debug_mode" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobInstanceTemplate": + suggest = "head_job_instance_template" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "machineType": + suggest = "machine_type" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nfsMount": + suggest = "nfs_mount" + elif key == "nfsTarget": + suggest = "nfs_target" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "projectId": + suggest = "project_id" + elif key == "serviceAccount": + suggest = "service_account" + elif key == "sshDaemon": + suggest = "ssh_daemon" + elif key == "sshImage": + suggest = "ssh_image" + elif key == "usePrivateAddress": + suggest = "use_private_address" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigGoogleBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigGoogleBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigGoogleBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_disk_size_gb: Optional[_builtins.float] = None, + compute_jobs_instance_template: Optional[_builtins.str] = None, + copy_image: Optional[_builtins.str] = None, + cpu_platform: Optional[_builtins.str] = None, + debug_mode: Optional[_builtins.float] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGoogleBatchEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_instance_template: Optional[_builtins.str] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + location: Optional[_builtins.str] = None, + machine_type: Optional[_builtins.str] = None, + network: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nfs_mount: Optional[_builtins.str] = None, + nfs_target: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + project_id: Optional[_builtins.str] = None, + service_account: Optional[_builtins.str] = None, + spot: Optional[_builtins.bool] = None, + ssh_daemon: Optional[_builtins.bool] = None, + ssh_image: Optional[_builtins.str] = None, + subnetwork: Optional[_builtins.str] = None, + use_private_address: Optional[_builtins.bool] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if compute_jobs_instance_template is not None: + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if cpu_platform is not None: + pulumi.set(__self__, "cpu_platform", cpu_platform) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_instance_template is not None: + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if network is not None: + pulumi.set(__self__, "network", network) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if subnetwork is not None: + pulumi.set(__self__, "subnetwork", subnetwork) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_jobs_instance_template") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[_builtins.str]: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> Optional[_builtins.str]: + return pulumi.get(self, "cpu_platform") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[_builtins.float]: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGoogleBatchEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_instance_template") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[_builtins.str]: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "machine_type") + + @_builtins.property + @pulumi.getter + def network(self) -> Optional[_builtins.str]: + return pulumi.get(self, "network") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "service_account") + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> Optional[_builtins.str]: + return pulumi.get(self, "subnetwork") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGoogleBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGoogleLifesciences(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootDiskSizeGb": + suggest = "boot_disk_size_gb" + elif key == "copyImage": + suggest = "copy_image" + elif key == "debugMode": + suggest = "debug_mode" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nfsMount": + suggest = "nfs_mount" + elif key == "nfsTarget": + suggest = "nfs_target" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "projectId": + suggest = "project_id" + elif key == "sshDaemon": + suggest = "ssh_daemon" + elif key == "sshImage": + suggest = "ssh_image" + elif key == "usePrivateAddress": + suggest = "use_private_address" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigGoogleLifesciences. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigGoogleLifesciences.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigGoogleLifesciences.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_disk_size_gb: Optional[_builtins.float] = None, + copy_image: Optional[_builtins.str] = None, + debug_mode: Optional[_builtins.float] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironment']] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + location: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nfs_mount: Optional[_builtins.str] = None, + nfs_target: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + preemptible: Optional[_builtins.bool] = None, + project_id: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + ssh_daemon: Optional[_builtins.bool] = None, + ssh_image: Optional[_builtins.str] = None, + use_private_address: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None, + zones: Optional[Sequence[_builtins.str]] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if preemptible is not None: + pulumi.set(__self__, "preemptible", preemptible) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[_builtins.str]: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[_builtins.float]: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[_builtins.str]: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def preemptible(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "preemptible") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def zones(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "zones") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigK8sPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigK8sPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigK8sPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigK8sPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigK8sPlatformEnvironment']] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"] + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigK8sPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigK8sPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigLsfPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "perJobMemLimit": + suggest = "per_job_mem_limit" + elif key == "perTaskReserve": + suggest = "per_task_reserve" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "unitForLimits": + suggest = "unit_for_limits" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigLsfPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigLsfPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigLsfPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigLsfPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + per_job_mem_limit: Optional[_builtins.bool] = None, + per_task_reserve: Optional[_builtins.bool] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + unit_for_limits: Optional[_builtins.str] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if per_job_mem_limit is not None: + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + if per_task_reserve is not None: + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if unit_for_limits is not None: + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigLsfPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "per_job_mem_limit") + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "per_task_reserve") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> Optional[_builtins.str]: + return pulumi.get(self, "unit_for_limits") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigLsfPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigMoabPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigMoabPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigMoabPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigMoabPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigMoabPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigMoabPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigMoabPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cliPath": + suggest = "cli_path" + elif key == "computeJobRole": + suggest = "compute_job_role" + elif key == "computeQueue": + suggest = "compute_queue" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "dragenQueue": + suggest = "dragen_queue" + elif key == "executionRole": + suggest = "execution_role" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "fusionSnapshots": + suggest = "fusion_snapshots" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headJobRole": + suggest = "head_job_role" + elif key == "headQueue": + suggest = "head_queue" + elif key == "logGroup": + suggest = "log_group" + elif key == "lustreId": + suggest = "lustre_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nvnmeStorageEnabled": + suggest = "nvnme_storage_enabled" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "storageType": + suggest = "storage_type" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigSeqeracomputePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigSeqeracomputePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigSeqeracomputePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cli_path: Optional[_builtins.str] = None, + compute_job_role: Optional[_builtins.str] = None, + compute_queue: Optional[_builtins.str] = None, + dragen_instance_type: Optional[_builtins.str] = None, + dragen_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironment']] = None, + execution_role: Optional[_builtins.str] = None, + forge: Optional['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatformForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + fusion_snapshots: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_job_role: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + lustre_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nvnme_storage_enabled: Optional[_builtins.bool] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + storage_type: Optional[_builtins.str] = None, + volumes: Optional[Sequence[_builtins.str]] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatformForge']: + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allocStrategy": + suggest = "alloc_strategy" + elif key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "bidPercentage": + suggest = "bid_percentage" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "dragenAmiId": + suggest = "dragen_ami_id" + elif key == "dragenEnabled": + suggest = "dragen_enabled" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "ebsAutoScale": + suggest = "ebs_auto_scale" + elif key == "ebsBlockSize": + suggest = "ebs_block_size" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "ecsConfig": + suggest = "ecs_config" + elif key == "efsCreate": + suggest = "efs_create" + elif key == "efsId": + suggest = "efs_id" + elif key == "efsMount": + suggest = "efs_mount" + elif key == "fargateHeadEnabled": + suggest = "fargate_head_enabled" + elif key == "fsxMount": + suggest = "fsx_mount" + elif key == "fsxName": + suggest = "fsx_name" + elif key == "fsxSize": + suggest = "fsx_size" + elif key == "fusionEnabled": + suggest = "fusion_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceTypes": + suggest = "instance_types" + elif key == "maxCpus": + suggest = "max_cpus" + elif key == "minCpus": + suggest = "min_cpus" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "vpcId": + suggest = "vpc_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigSeqeracomputePlatformForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigSeqeracomputePlatformForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigSeqeracomputePlatformForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alloc_strategy: Optional[_builtins.str] = None, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + bid_percentage: Optional[_builtins.float] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + dragen_ami_id: Optional[_builtins.str] = None, + dragen_enabled: Optional[_builtins.bool] = None, + dragen_instance_type: Optional[_builtins.str] = None, + ebs_auto_scale: Optional[_builtins.bool] = None, + ebs_block_size: Optional[_builtins.float] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + ecs_config: Optional[_builtins.str] = None, + efs_create: Optional[_builtins.bool] = None, + efs_id: Optional[_builtins.str] = None, + efs_mount: Optional[_builtins.str] = None, + fargate_head_enabled: Optional[_builtins.bool] = None, + fsx_mount: Optional[_builtins.str] = None, + fsx_name: Optional[_builtins.str] = None, + fsx_size: Optional[_builtins.float] = None, + fusion_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_types: Optional[Sequence[_builtins.str]] = None, + max_cpus: Optional[_builtins.float] = None, + min_cpus: Optional[_builtins.float] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnets: Optional[Sequence[_builtins.str]] = None, + type: Optional[_builtins.str] = None, + vpc_id: Optional[_builtins.str] = None): + """ + :param _builtins.str alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + :param _builtins.str type: must be one of ["SPOT", "EC2"] + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[_builtins.str]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[_builtins.float]: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + must be one of ["SPOT", "EC2"] + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSlurmPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigSlurmPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigSlurmPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigSlurmPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigSlurmPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigSlurmPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSlurmPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigUgePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigUgePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigUgePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigUgePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigUgePlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigUgePlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigUgePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnv(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "credentialsId": + suggest = "credentials_id" + elif key == "computeEnvId": + suggest = "compute_env_id" + elif key == "dateCreated": + suggest = "date_created" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "lastUsed": + suggest = "last_used" + elif key == "managedIdentityId": + suggest = "managed_identity_id" + elif key == "orgId": + suggest = "org_id" + elif key == "workspaceId": + suggest = "workspace_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnv. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnv.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnv.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + config: 'outputs.ComputeEnvComputeEnvConfig', + credentials_id: _builtins.str, + name: _builtins.str, + platform: _builtins.str, + compute_env_id: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + deleted: Optional[_builtins.bool] = None, + description: Optional[_builtins.str] = None, + labels: Optional[Sequence['outputs.ComputeEnvComputeEnvLabel']] = None, + last_updated: Optional[_builtins.str] = None, + last_used: Optional[_builtins.str] = None, + managed_identity_id: Optional[_builtins.str] = None, + message: Optional[_builtins.str] = None, + org_id: Optional[_builtins.float] = None, + primary: Optional[_builtins.bool] = None, + status: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None): + """ + :param 'ComputeEnvComputeEnvConfigArgs' config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + :param _builtins.str credentials_id: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str platform: must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + :param _builtins.str description: Requires replacement if changed. + :param _builtins.str message: Requires replacement if changed. + :param _builtins.str status: must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "platform", platform) + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if managed_identity_id is not None: + pulumi.set(__self__, "managed_identity_id", managed_identity_id) + if message is not None: + pulumi.set(__self__, "message", message) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if primary is not None: + pulumi.set(__self__, "primary", primary) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def config(self) -> 'outputs.ComputeEnvComputeEnvConfig': + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + """ + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + """ + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter(name="managedIdentityId") + def managed_identity_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "managed_identity_id") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def primary(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "primary") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "altairPlatform": + suggest = "altair_platform" + elif key == "awsBatch": + suggest = "aws_batch" + elif key == "awsCloud": + suggest = "aws_cloud" + elif key == "azureBatch": + suggest = "azure_batch" + elif key == "eksPlatform": + suggest = "eks_platform" + elif key == "gkePlatform": + suggest = "gke_platform" + elif key == "googleBatch": + suggest = "google_batch" + elif key == "googleLifesciences": + suggest = "google_lifesciences" + elif key == "k8sPlatform": + suggest = "k8s_platform" + elif key == "lsfPlatform": + suggest = "lsf_platform" + elif key == "moabPlatform": + suggest = "moab_platform" + elif key == "seqeracomputePlatform": + suggest = "seqeracompute_platform" + elif key == "slurmPlatform": + suggest = "slurm_platform" + elif key == "ugePlatform": + suggest = "uge_platform" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + altair_platform: Optional['outputs.ComputeEnvComputeEnvConfigAltairPlatform'] = None, + aws_batch: Optional['outputs.ComputeEnvComputeEnvConfigAwsBatch'] = None, + aws_cloud: Optional['outputs.ComputeEnvComputeEnvConfigAwsCloud'] = None, + azure_batch: Optional['outputs.ComputeEnvComputeEnvConfigAzureBatch'] = None, + eks_platform: Optional['outputs.ComputeEnvComputeEnvConfigEksPlatform'] = None, + gke_platform: Optional['outputs.ComputeEnvComputeEnvConfigGkePlatform'] = None, + google_batch: Optional['outputs.ComputeEnvComputeEnvConfigGoogleBatch'] = None, + google_lifesciences: Optional['outputs.ComputeEnvComputeEnvConfigGoogleLifesciences'] = None, + k8s_platform: Optional['outputs.ComputeEnvComputeEnvConfigK8sPlatform'] = None, + lsf_platform: Optional['outputs.ComputeEnvComputeEnvConfigLsfPlatform'] = None, + moab_platform: Optional['outputs.ComputeEnvComputeEnvConfigMoabPlatform'] = None, + seqeracompute_platform: Optional['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatform'] = None, + slurm_platform: Optional['outputs.ComputeEnvComputeEnvConfigSlurmPlatform'] = None, + uge_platform: Optional['outputs.ComputeEnvComputeEnvConfigUgePlatform'] = None): + """ + :param 'ComputeEnvComputeEnvConfigAltairPlatformArgs' altair_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAwsBatchArgs' aws_batch: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAwsCloudArgs' aws_cloud: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAzureBatchArgs' azure_batch: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigEksPlatformArgs' eks_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigGkePlatformArgs' gke_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigGoogleBatchArgs' google_batch: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigGoogleLifesciencesArgs' google_lifesciences: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigK8sPlatformArgs' k8s_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigLsfPlatformArgs' lsf_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigMoabPlatformArgs' moab_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs' seqeracompute_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigSlurmPlatformArgs' slurm_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigUgePlatformArgs' uge_platform: Requires replacement if changed. + """ + if altair_platform is not None: + pulumi.set(__self__, "altair_platform", altair_platform) + if aws_batch is not None: + pulumi.set(__self__, "aws_batch", aws_batch) + if aws_cloud is not None: + pulumi.set(__self__, "aws_cloud", aws_cloud) + if azure_batch is not None: + pulumi.set(__self__, "azure_batch", azure_batch) + if eks_platform is not None: + pulumi.set(__self__, "eks_platform", eks_platform) + if gke_platform is not None: + pulumi.set(__self__, "gke_platform", gke_platform) + if google_batch is not None: + pulumi.set(__self__, "google_batch", google_batch) + if google_lifesciences is not None: + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + if k8s_platform is not None: + pulumi.set(__self__, "k8s_platform", k8s_platform) + if lsf_platform is not None: + pulumi.set(__self__, "lsf_platform", lsf_platform) + if moab_platform is not None: + pulumi.set(__self__, "moab_platform", moab_platform) + if seqeracompute_platform is not None: + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + if slurm_platform is not None: + pulumi.set(__self__, "slurm_platform", slurm_platform) + if uge_platform is not None: + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAltairPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "altair_platform") + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAwsBatch']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "aws_batch") + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAwsCloud']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "aws_cloud") + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAzureBatch']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "azure_batch") + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigEksPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "eks_platform") + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigGkePlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gke_platform") + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> Optional['outputs.ComputeEnvComputeEnvConfigGoogleBatch']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "google_batch") + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> Optional['outputs.ComputeEnvComputeEnvConfigGoogleLifesciences']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "google_lifesciences") + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigK8sPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "k8s_platform") + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigLsfPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lsf_platform") + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigMoabPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "moab_platform") + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "seqeracompute_platform") + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigSlurmPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "slurm_platform") + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigUgePlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "uge_platform") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAltairPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAltairPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAltairPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAltairPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAltairPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAltairPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAltairPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cliPath": + suggest = "cli_path" + elif key == "computeJobRole": + suggest = "compute_job_role" + elif key == "computeQueue": + suggest = "compute_queue" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "dragenQueue": + suggest = "dragen_queue" + elif key == "executionRole": + suggest = "execution_role" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "fusionSnapshots": + suggest = "fusion_snapshots" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headJobRole": + suggest = "head_job_role" + elif key == "headQueue": + suggest = "head_queue" + elif key == "logGroup": + suggest = "log_group" + elif key == "lustreId": + suggest = "lustre_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nvnmeStorageEnabled": + suggest = "nvnme_storage_enabled" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "storageType": + suggest = "storage_type" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAwsBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAwsBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAwsBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cli_path: Optional[_builtins.str] = None, + compute_job_role: Optional[_builtins.str] = None, + compute_queue: Optional[_builtins.str] = None, + dragen_instance_type: Optional[_builtins.str] = None, + dragen_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAwsBatchEnvironment']] = None, + execution_role: Optional[_builtins.str] = None, + forge: Optional['outputs.ComputeEnvComputeEnvConfigAwsBatchForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + fusion_snapshots: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_job_role: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + lustre_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nvnme_storage_enabled: Optional[_builtins.bool] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + storage_type: Optional[_builtins.str] = None, + volumes: Optional[Sequence[_builtins.str]] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cli_path: Requires replacement if changed. + :param _builtins.str compute_job_role: Requires replacement if changed. + :param _builtins.str compute_queue: Requires replacement if changed. + :param _builtins.str dragen_instance_type: Requires replacement if changed. + :param _builtins.str dragen_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str execution_role: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAwsBatchForgeArgs' forge: Not Null; Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.bool fusion_snapshots: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_job_role: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str log_group: Requires replacement if changed. + :param _builtins.str lustre_id: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.bool nvnme_storage_enabled: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: Not Null; Requires replacement if changed. + :param _builtins.str storage_type: Requires replacement if changed. + :param Sequence[_builtins.str] volumes: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAwsBatchEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAwsBatchForge']: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsBatchForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allocStrategy": + suggest = "alloc_strategy" + elif key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "bidPercentage": + suggest = "bid_percentage" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "dragenAmiId": + suggest = "dragen_ami_id" + elif key == "dragenEnabled": + suggest = "dragen_enabled" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "ebsAutoScale": + suggest = "ebs_auto_scale" + elif key == "ebsBlockSize": + suggest = "ebs_block_size" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "ecsConfig": + suggest = "ecs_config" + elif key == "efsCreate": + suggest = "efs_create" + elif key == "efsId": + suggest = "efs_id" + elif key == "efsMount": + suggest = "efs_mount" + elif key == "fargateHeadEnabled": + suggest = "fargate_head_enabled" + elif key == "fsxMount": + suggest = "fsx_mount" + elif key == "fsxName": + suggest = "fsx_name" + elif key == "fsxSize": + suggest = "fsx_size" + elif key == "fusionEnabled": + suggest = "fusion_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceTypes": + suggest = "instance_types" + elif key == "maxCpus": + suggest = "max_cpus" + elif key == "minCpus": + suggest = "min_cpus" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "vpcId": + suggest = "vpc_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAwsBatchForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAwsBatchForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAwsBatchForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alloc_strategy: Optional[_builtins.str] = None, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + bid_percentage: Optional[_builtins.float] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + dragen_ami_id: Optional[_builtins.str] = None, + dragen_enabled: Optional[_builtins.bool] = None, + dragen_instance_type: Optional[_builtins.str] = None, + ebs_auto_scale: Optional[_builtins.bool] = None, + ebs_block_size: Optional[_builtins.float] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + ecs_config: Optional[_builtins.str] = None, + efs_create: Optional[_builtins.bool] = None, + efs_id: Optional[_builtins.str] = None, + efs_mount: Optional[_builtins.str] = None, + fargate_head_enabled: Optional[_builtins.bool] = None, + fsx_mount: Optional[_builtins.str] = None, + fsx_name: Optional[_builtins.str] = None, + fsx_size: Optional[_builtins.float] = None, + fusion_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_types: Optional[Sequence[_builtins.str]] = None, + max_cpus: Optional[_builtins.float] = None, + min_cpus: Optional[_builtins.float] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnets: Optional[Sequence[_builtins.str]] = None, + type: Optional[_builtins.str] = None, + vpc_id: Optional[_builtins.str] = None): + """ + :param _builtins.str alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + :param Sequence[_builtins.str] allow_buckets: Requires replacement if changed. + :param _builtins.bool arm64_enabled: Requires replacement if changed. + :param _builtins.float bid_percentage: Requires replacement if changed. + :param _builtins.bool dispose_on_deletion: Requires replacement if changed. + :param _builtins.str dragen_ami_id: Requires replacement if changed. + :param _builtins.bool dragen_enabled: Requires replacement if changed. + :param _builtins.str dragen_instance_type: Requires replacement if changed. + :param _builtins.bool ebs_auto_scale: Requires replacement if changed. + :param _builtins.float ebs_block_size: Requires replacement if changed. + :param _builtins.float ebs_boot_size: Requires replacement if changed. + :param _builtins.str ec2_key_pair: Requires replacement if changed. + :param _builtins.str ecs_config: Requires replacement if changed. + :param _builtins.bool efs_create: Requires replacement if changed. + :param _builtins.str efs_id: Requires replacement if changed. + :param _builtins.str efs_mount: Requires replacement if changed. + :param _builtins.bool fargate_head_enabled: Requires replacement if changed. + :param _builtins.str fsx_mount: Requires replacement if changed. + :param _builtins.str fsx_name: Requires replacement if changed. + :param _builtins.float fsx_size: Requires replacement if changed. + :param _builtins.bool fusion_enabled: Requires replacement if changed. + :param _builtins.bool gpu_enabled: Requires replacement if changed. + :param _builtins.str image_id: Requires replacement if changed. + :param Sequence[_builtins.str] instance_types: Requires replacement if changed. + :param _builtins.float max_cpus: Not Null; Requires replacement if changed. + :param _builtins.float min_cpus: Not Null; Requires replacement if changed. + :param Sequence[_builtins.str] security_groups: Requires replacement if changed. + :param Sequence[_builtins.str] subnets: Requires replacement if changed. + :param _builtins.str type: Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + :param _builtins.str vpc_id: Requires replacement if changed. + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[_builtins.str]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsCloud(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceProfileArn": + suggest = "instance_profile_arn" + elif key == "instanceType": + suggest = "instance_type" + elif key == "logGroup": + suggest = "log_group" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "subnetId": + suggest = "subnet_id" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAwsCloud. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAwsCloud.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAwsCloud.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAwsCloudEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_profile_arn: Optional[_builtins.str] = None, + instance_type: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnet_id: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence[_builtins.str] allow_buckets: Requires replacement if changed. + :param _builtins.bool arm64_enabled: Requires replacement if changed. + :param _builtins.float ebs_boot_size: Requires replacement if changed. + :param _builtins.str ec2_key_pair: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.bool gpu_enabled: Requires replacement if changed. + :param _builtins.str image_id: Requires replacement if changed. + :param _builtins.str instance_profile_arn: Requires replacement if changed. + :param _builtins.str instance_type: Requires replacement if changed. + :param _builtins.str log_group: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: Not Null; Requires replacement if changed. + :param Sequence[_builtins.str] security_groups: Requires replacement if changed. + :param _builtins.str subnet_id: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_profile_arn is not None: + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + if instance_type is not None: + pulumi.set(__self__, "instance_type", instance_type) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnet_id is not None: + pulumi.set(__self__, "subnet_id", subnet_id) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAwsCloudEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_profile_arn") + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_type") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnet_id") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsCloudEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAzureBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "autoPoolMode": + suggest = "auto_pool_mode" + elif key == "deleteJobsOnCompletion": + suggest = "delete_jobs_on_completion" + elif key == "deletePoolsOnCompletion": + suggest = "delete_pools_on_completion" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headPool": + suggest = "head_pool" + elif key == "managedIdentityClientId": + suggest = "managed_identity_client_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "tokenDuration": + suggest = "token_duration" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAzureBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAzureBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAzureBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auto_pool_mode: Optional[_builtins.bool] = None, + delete_jobs_on_completion: Optional[_builtins.str] = None, + delete_pools_on_completion: Optional[_builtins.bool] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAzureBatchEnvironment']] = None, + forge: Optional['outputs.ComputeEnvComputeEnvConfigAzureBatchForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_pool: Optional[_builtins.str] = None, + managed_identity_client_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + token_duration: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.bool auto_pool_mode: Requires replacement if changed. + :param _builtins.str delete_jobs_on_completion: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param _builtins.bool delete_pools_on_completion: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAzureBatchForgeArgs' forge: Not Null; Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.str head_pool: Requires replacement if changed. + :param _builtins.str managed_identity_client_id: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: Not Null; Requires replacement if changed. + :param _builtins.str token_duration: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if auto_pool_mode is not None: + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + if delete_jobs_on_completion is not None: + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + if delete_pools_on_completion is not None: + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_pool is not None: + pulumi.set(__self__, "head_pool", head_pool) + if managed_identity_client_id is not None: + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if token_duration is not None: + pulumi.set(__self__, "token_duration", token_duration) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "auto_pool_mode") + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "delete_jobs_on_completion") + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "delete_pools_on_completion") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAzureBatchEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAzureBatchForge']: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pool") + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "managed_identity_client_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "token_duration") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAzureBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAzureBatchForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "autoScale": + suggest = "auto_scale" + elif key == "containerRegIds": + suggest = "container_reg_ids" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "vmCount": + suggest = "vm_count" + elif key == "vmType": + suggest = "vm_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAzureBatchForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAzureBatchForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAzureBatchForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auto_scale: Optional[_builtins.bool] = None, + container_reg_ids: Optional[Sequence[_builtins.str]] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + vm_count: Optional[_builtins.float] = None, + vm_type: Optional[_builtins.str] = None): + """ + :param _builtins.bool auto_scale: Requires replacement if changed. + :param Sequence[_builtins.str] container_reg_ids: Requires replacement if changed. + :param _builtins.bool dispose_on_deletion: Requires replacement if changed. + :param _builtins.float vm_count: Not Null; Requires replacement if changed. + :param _builtins.str vm_type: Requires replacement if changed. + """ + if auto_scale is not None: + pulumi.set(__self__, "auto_scale", auto_scale) + if container_reg_ids is not None: + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if vm_count is not None: + pulumi.set(__self__, "vm_count", vm_count) + if vm_type is not None: + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "auto_scale") + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "container_reg_ids") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "vm_count") + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vm_type") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigEksPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterName": + suggest = "cluster_name" + elif key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigEksPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigEksPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigEksPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_name: Optional[_builtins.str] = None, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigEksPlatformEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cluster_name: The AWS EKS cluster name. Not Null; Requires replacement if changed. + :param _builtins.str compute_service_account: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_pod_spec: Requires replacement if changed. + :param _builtins.str head_service_account: Not Null; Requires replacement if changed. + :param _builtins.str namespace: Not Null; Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: AWS region. Not Null; Requires replacement if changed. + :param _builtins.str server: Not Null; Requires replacement if changed. + :param _builtins.str service_pod_spec: Requires replacement if changed. + :param _builtins.str ssl_cert: Not Null; Requires replacement if changed. + :param _builtins.str storage_claim_name: Not Null; Requires replacement if changed. + :param _builtins.str storage_mount_path: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[_builtins.str]: + """ + The AWS EKS cluster name. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigEksPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + AWS region. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigEksPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGkePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterName": + suggest = "cluster_name" + elif key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigGkePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigGkePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigGkePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_name: Optional[_builtins.str] = None, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGkePlatformEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cluster_name: The GKE cluster name. Not Null; Requires replacement if changed. + :param _builtins.str compute_service_account: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_pod_spec: Requires replacement if changed. + :param _builtins.str head_service_account: Not Null; Requires replacement if changed. + :param _builtins.str namespace: Not Null; Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + :param _builtins.str server: Not Null; Requires replacement if changed. + :param _builtins.str service_pod_spec: Requires replacement if changed. + :param _builtins.str ssl_cert: Not Null; Requires replacement if changed. + :param _builtins.str storage_claim_name: Not Null; Requires replacement if changed. + :param _builtins.str storage_mount_path: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[_builtins.str]: + """ + The GKE cluster name. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGkePlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGkePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGoogleBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootDiskSizeGb": + suggest = "boot_disk_size_gb" + elif key == "computeJobsInstanceTemplate": + suggest = "compute_jobs_instance_template" + elif key == "copyImage": + suggest = "copy_image" + elif key == "cpuPlatform": + suggest = "cpu_platform" + elif key == "debugMode": + suggest = "debug_mode" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobInstanceTemplate": + suggest = "head_job_instance_template" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "machineType": + suggest = "machine_type" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nfsMount": + suggest = "nfs_mount" + elif key == "nfsTarget": + suggest = "nfs_target" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "projectId": + suggest = "project_id" + elif key == "serviceAccount": + suggest = "service_account" + elif key == "sshDaemon": + suggest = "ssh_daemon" + elif key == "sshImage": + suggest = "ssh_image" + elif key == "usePrivateAddress": + suggest = "use_private_address" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigGoogleBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigGoogleBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigGoogleBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_disk_size_gb: Optional[_builtins.float] = None, + compute_jobs_instance_template: Optional[_builtins.str] = None, + copy_image: Optional[_builtins.str] = None, + cpu_platform: Optional[_builtins.str] = None, + debug_mode: Optional[_builtins.float] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGoogleBatchEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_instance_template: Optional[_builtins.str] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + location: Optional[_builtins.str] = None, + machine_type: Optional[_builtins.str] = None, + network: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nfs_mount: Optional[_builtins.str] = None, + nfs_target: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + project_id: Optional[_builtins.str] = None, + service_account: Optional[_builtins.str] = None, + spot: Optional[_builtins.bool] = None, + ssh_daemon: Optional[_builtins.bool] = None, + ssh_image: Optional[_builtins.str] = None, + subnetwork: Optional[_builtins.str] = None, + use_private_address: Optional[_builtins.bool] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.float boot_disk_size_gb: Requires replacement if changed. + :param _builtins.str compute_jobs_instance_template: Requires replacement if changed. + :param _builtins.str copy_image: Requires replacement if changed. + :param _builtins.str cpu_platform: Requires replacement if changed. + :param _builtins.float debug_mode: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.str head_job_instance_template: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param Mapping[str, _builtins.str] labels: Requires replacement if changed. + :param _builtins.str location: Requires replacement if changed. + :param _builtins.str machine_type: Requires replacement if changed. + :param _builtins.str network: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str nfs_mount: Requires replacement if changed. + :param _builtins.str nfs_target: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str project_id: Requires replacement if changed. + :param _builtins.str service_account: Requires replacement if changed. + :param _builtins.bool spot: Requires replacement if changed. + :param _builtins.bool ssh_daemon: Requires replacement if changed. + :param _builtins.str ssh_image: Requires replacement if changed. + :param _builtins.str subnetwork: Requires replacement if changed. + :param _builtins.bool use_private_address: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if compute_jobs_instance_template is not None: + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if cpu_platform is not None: + pulumi.set(__self__, "cpu_platform", cpu_platform) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_instance_template is not None: + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if network is not None: + pulumi.set(__self__, "network", network) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if subnetwork is not None: + pulumi.set(__self__, "subnetwork", subnetwork) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_jobs_instance_template") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cpu_platform") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGoogleBatchEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_instance_template") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "machine_type") + + @_builtins.property + @pulumi.getter + def network(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "network") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_account") + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnetwork") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGoogleBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGoogleLifesciences(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootDiskSizeGb": + suggest = "boot_disk_size_gb" + elif key == "copyImage": + suggest = "copy_image" + elif key == "debugMode": + suggest = "debug_mode" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nfsMount": + suggest = "nfs_mount" + elif key == "nfsTarget": + suggest = "nfs_target" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "projectId": + suggest = "project_id" + elif key == "sshDaemon": + suggest = "ssh_daemon" + elif key == "sshImage": + suggest = "ssh_image" + elif key == "usePrivateAddress": + suggest = "use_private_address" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigGoogleLifesciences. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigGoogleLifesciences.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigGoogleLifesciences.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_disk_size_gb: Optional[_builtins.float] = None, + copy_image: Optional[_builtins.str] = None, + debug_mode: Optional[_builtins.float] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironment']] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + location: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nfs_mount: Optional[_builtins.str] = None, + nfs_target: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + preemptible: Optional[_builtins.bool] = None, + project_id: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + ssh_daemon: Optional[_builtins.bool] = None, + ssh_image: Optional[_builtins.str] = None, + use_private_address: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None, + zones: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.float boot_disk_size_gb: Requires replacement if changed. + :param _builtins.str copy_image: Requires replacement if changed. + :param _builtins.float debug_mode: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param Mapping[str, _builtins.str] labels: Requires replacement if changed. + :param _builtins.str location: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str nfs_mount: Requires replacement if changed. + :param _builtins.str nfs_target: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool preemptible: Requires replacement if changed. + :param _builtins.str project_id: Requires replacement if changed. + :param _builtins.str region: Requires replacement if changed. + :param _builtins.bool ssh_daemon: Requires replacement if changed. + :param _builtins.str ssh_image: Requires replacement if changed. + :param _builtins.bool use_private_address: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + :param Sequence[_builtins.str] zones: Requires replacement if changed. + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if preemptible is not None: + pulumi.set(__self__, "preemptible", preemptible) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def preemptible(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "preemptible") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def zones(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "zones") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigK8sPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigK8sPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigK8sPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigK8sPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigK8sPlatformEnvironment']] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_service_account: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_pod_spec: Requires replacement if changed. + :param _builtins.str head_service_account: Not Null; Requires replacement if changed. + :param _builtins.str namespace: Not Null; Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str server: Not Null; Requires replacement if changed. + :param _builtins.str service_pod_spec: Requires replacement if changed. + :param _builtins.str ssl_cert: Not Null; Requires replacement if changed. + :param _builtins.str storage_claim_name: Not Null; Requires replacement if changed. + :param _builtins.str storage_mount_path: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigK8sPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigK8sPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigLsfPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "perJobMemLimit": + suggest = "per_job_mem_limit" + elif key == "perTaskReserve": + suggest = "per_task_reserve" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "unitForLimits": + suggest = "unit_for_limits" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigLsfPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigLsfPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigLsfPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigLsfPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + per_job_mem_limit: Optional[_builtins.bool] = None, + per_task_reserve: Optional[_builtins.bool] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + unit_for_limits: Optional[_builtins.str] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.bool per_job_mem_limit: Requires replacement if changed. + :param _builtins.bool per_task_reserve: Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str unit_for_limits: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if per_job_mem_limit is not None: + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + if per_task_reserve is not None: + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if unit_for_limits is not None: + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigLsfPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "per_job_mem_limit") + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "per_task_reserve") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "unit_for_limits") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigLsfPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigMoabPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigMoabPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigMoabPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigMoabPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigMoabPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigMoabPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigMoabPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cliPath": + suggest = "cli_path" + elif key == "computeJobRole": + suggest = "compute_job_role" + elif key == "computeQueue": + suggest = "compute_queue" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "dragenQueue": + suggest = "dragen_queue" + elif key == "executionRole": + suggest = "execution_role" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "fusionSnapshots": + suggest = "fusion_snapshots" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headJobRole": + suggest = "head_job_role" + elif key == "headQueue": + suggest = "head_queue" + elif key == "logGroup": + suggest = "log_group" + elif key == "lustreId": + suggest = "lustre_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nvnmeStorageEnabled": + suggest = "nvnme_storage_enabled" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "storageType": + suggest = "storage_type" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigSeqeracomputePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigSeqeracomputePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigSeqeracomputePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cli_path: Optional[_builtins.str] = None, + compute_job_role: Optional[_builtins.str] = None, + compute_queue: Optional[_builtins.str] = None, + dragen_instance_type: Optional[_builtins.str] = None, + dragen_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironment']] = None, + execution_role: Optional[_builtins.str] = None, + forge: Optional['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatformForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + fusion_snapshots: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_job_role: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + lustre_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nvnme_storage_enabled: Optional[_builtins.bool] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + storage_type: Optional[_builtins.str] = None, + volumes: Optional[Sequence[_builtins.str]] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cli_path: Requires replacement if changed. + :param _builtins.str compute_job_role: Requires replacement if changed. + :param _builtins.str compute_queue: Requires replacement if changed. + :param _builtins.str dragen_instance_type: Requires replacement if changed. + :param _builtins.str dragen_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str execution_role: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs' forge: Not Null; Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.bool fusion_snapshots: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_job_role: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str log_group: Requires replacement if changed. + :param _builtins.str lustre_id: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.bool nvnme_storage_enabled: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: Not Null; Requires replacement if changed. + :param _builtins.str storage_type: Requires replacement if changed. + :param Sequence[_builtins.str] volumes: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatformForge']: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allocStrategy": + suggest = "alloc_strategy" + elif key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "bidPercentage": + suggest = "bid_percentage" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "dragenAmiId": + suggest = "dragen_ami_id" + elif key == "dragenEnabled": + suggest = "dragen_enabled" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "ebsAutoScale": + suggest = "ebs_auto_scale" + elif key == "ebsBlockSize": + suggest = "ebs_block_size" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "ecsConfig": + suggest = "ecs_config" + elif key == "efsCreate": + suggest = "efs_create" + elif key == "efsId": + suggest = "efs_id" + elif key == "efsMount": + suggest = "efs_mount" + elif key == "fargateHeadEnabled": + suggest = "fargate_head_enabled" + elif key == "fsxMount": + suggest = "fsx_mount" + elif key == "fsxName": + suggest = "fsx_name" + elif key == "fsxSize": + suggest = "fsx_size" + elif key == "fusionEnabled": + suggest = "fusion_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceTypes": + suggest = "instance_types" + elif key == "maxCpus": + suggest = "max_cpus" + elif key == "minCpus": + suggest = "min_cpus" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "vpcId": + suggest = "vpc_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigSeqeracomputePlatformForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigSeqeracomputePlatformForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigSeqeracomputePlatformForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alloc_strategy: Optional[_builtins.str] = None, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + bid_percentage: Optional[_builtins.float] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + dragen_ami_id: Optional[_builtins.str] = None, + dragen_enabled: Optional[_builtins.bool] = None, + dragen_instance_type: Optional[_builtins.str] = None, + ebs_auto_scale: Optional[_builtins.bool] = None, + ebs_block_size: Optional[_builtins.float] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + ecs_config: Optional[_builtins.str] = None, + efs_create: Optional[_builtins.bool] = None, + efs_id: Optional[_builtins.str] = None, + efs_mount: Optional[_builtins.str] = None, + fargate_head_enabled: Optional[_builtins.bool] = None, + fsx_mount: Optional[_builtins.str] = None, + fsx_name: Optional[_builtins.str] = None, + fsx_size: Optional[_builtins.float] = None, + fusion_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_types: Optional[Sequence[_builtins.str]] = None, + max_cpus: Optional[_builtins.float] = None, + min_cpus: Optional[_builtins.float] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnets: Optional[Sequence[_builtins.str]] = None, + type: Optional[_builtins.str] = None, + vpc_id: Optional[_builtins.str] = None): + """ + :param _builtins.str alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + :param Sequence[_builtins.str] allow_buckets: Requires replacement if changed. + :param _builtins.bool arm64_enabled: Requires replacement if changed. + :param _builtins.float bid_percentage: Requires replacement if changed. + :param _builtins.bool dispose_on_deletion: Requires replacement if changed. + :param _builtins.str dragen_ami_id: Requires replacement if changed. + :param _builtins.bool dragen_enabled: Requires replacement if changed. + :param _builtins.str dragen_instance_type: Requires replacement if changed. + :param _builtins.bool ebs_auto_scale: Requires replacement if changed. + :param _builtins.float ebs_block_size: Requires replacement if changed. + :param _builtins.float ebs_boot_size: Requires replacement if changed. + :param _builtins.str ec2_key_pair: Requires replacement if changed. + :param _builtins.str ecs_config: Requires replacement if changed. + :param _builtins.bool efs_create: Requires replacement if changed. + :param _builtins.str efs_id: Requires replacement if changed. + :param _builtins.str efs_mount: Requires replacement if changed. + :param _builtins.bool fargate_head_enabled: Requires replacement if changed. + :param _builtins.str fsx_mount: Requires replacement if changed. + :param _builtins.str fsx_name: Requires replacement if changed. + :param _builtins.float fsx_size: Requires replacement if changed. + :param _builtins.bool fusion_enabled: Requires replacement if changed. + :param _builtins.bool gpu_enabled: Requires replacement if changed. + :param _builtins.str image_id: Requires replacement if changed. + :param Sequence[_builtins.str] instance_types: Requires replacement if changed. + :param _builtins.float max_cpus: Not Null; Requires replacement if changed. + :param _builtins.float min_cpus: Not Null; Requires replacement if changed. + :param Sequence[_builtins.str] security_groups: Requires replacement if changed. + :param Sequence[_builtins.str] subnets: Requires replacement if changed. + :param _builtins.str type: Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + :param _builtins.str vpc_id: Requires replacement if changed. + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[_builtins.str]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSlurmPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigSlurmPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigSlurmPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigSlurmPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigSlurmPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigSlurmPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSlurmPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigUgePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigUgePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigUgePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigUgePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigUgePlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigUgePlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigUgePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class CredentialKeys(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "azureEntra": + suggest = "azure_entra" + elif key == "containerReg": + suggest = "container_reg" + elif key == "twAgent": + suggest = "tw_agent" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeys. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeys.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeys.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + aws: Optional['outputs.CredentialKeysAws'] = None, + azure: Optional['outputs.CredentialKeysAzure'] = None, + azure_entra: Optional['outputs.CredentialKeysAzureEntra'] = None, + azurerepos: Optional['outputs.CredentialKeysAzurerepos'] = None, + bitbucket: Optional['outputs.CredentialKeysBitbucket'] = None, + codecommit: Optional['outputs.CredentialKeysCodecommit'] = None, + container_reg: Optional['outputs.CredentialKeysContainerReg'] = None, + gitea: Optional['outputs.CredentialKeysGitea'] = None, + github: Optional['outputs.CredentialKeysGithub'] = None, + gitlab: Optional['outputs.CredentialKeysGitlab'] = None, + google: Optional['outputs.CredentialKeysGoogle'] = None, + k8s: Optional['outputs.CredentialKeysK8s'] = None, + seqeracompute: Optional['outputs.CredentialKeysSeqeracompute'] = None, + ssh: Optional['outputs.CredentialKeysSsh'] = None, + tw_agent: Optional['outputs.CredentialKeysTwAgent'] = None): + if aws is not None: + pulumi.set(__self__, "aws", aws) + if azure is not None: + pulumi.set(__self__, "azure", azure) + if azure_entra is not None: + pulumi.set(__self__, "azure_entra", azure_entra) + if azurerepos is not None: + pulumi.set(__self__, "azurerepos", azurerepos) + if bitbucket is not None: + pulumi.set(__self__, "bitbucket", bitbucket) + if codecommit is not None: + pulumi.set(__self__, "codecommit", codecommit) + if container_reg is not None: + pulumi.set(__self__, "container_reg", container_reg) + if gitea is not None: + pulumi.set(__self__, "gitea", gitea) + if github is not None: + pulumi.set(__self__, "github", github) + if gitlab is not None: + pulumi.set(__self__, "gitlab", gitlab) + if google is not None: + pulumi.set(__self__, "google", google) + if k8s is not None: + pulumi.set(__self__, "k8s", k8s) + if seqeracompute is not None: + pulumi.set(__self__, "seqeracompute", seqeracompute) + if ssh is not None: + pulumi.set(__self__, "ssh", ssh) + if tw_agent is not None: + pulumi.set(__self__, "tw_agent", tw_agent) + + @_builtins.property + @pulumi.getter + def aws(self) -> Optional['outputs.CredentialKeysAws']: + return pulumi.get(self, "aws") + + @_builtins.property + @pulumi.getter + def azure(self) -> Optional['outputs.CredentialKeysAzure']: + return pulumi.get(self, "azure") + + @_builtins.property + @pulumi.getter(name="azureEntra") + def azure_entra(self) -> Optional['outputs.CredentialKeysAzureEntra']: + return pulumi.get(self, "azure_entra") + + @_builtins.property + @pulumi.getter + def azurerepos(self) -> Optional['outputs.CredentialKeysAzurerepos']: + return pulumi.get(self, "azurerepos") + + @_builtins.property + @pulumi.getter + def bitbucket(self) -> Optional['outputs.CredentialKeysBitbucket']: + return pulumi.get(self, "bitbucket") + + @_builtins.property + @pulumi.getter + def codecommit(self) -> Optional['outputs.CredentialKeysCodecommit']: + return pulumi.get(self, "codecommit") + + @_builtins.property + @pulumi.getter(name="containerReg") + def container_reg(self) -> Optional['outputs.CredentialKeysContainerReg']: + return pulumi.get(self, "container_reg") + + @_builtins.property + @pulumi.getter + def gitea(self) -> Optional['outputs.CredentialKeysGitea']: + return pulumi.get(self, "gitea") + + @_builtins.property + @pulumi.getter + def github(self) -> Optional['outputs.CredentialKeysGithub']: + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def gitlab(self) -> Optional['outputs.CredentialKeysGitlab']: + return pulumi.get(self, "gitlab") + + @_builtins.property + @pulumi.getter + def google(self) -> Optional['outputs.CredentialKeysGoogle']: + return pulumi.get(self, "google") + + @_builtins.property + @pulumi.getter + def k8s(self) -> Optional['outputs.CredentialKeysK8s']: + return pulumi.get(self, "k8s") + + @_builtins.property + @pulumi.getter + def seqeracompute(self) -> Optional['outputs.CredentialKeysSeqeracompute']: + return pulumi.get(self, "seqeracompute") + + @_builtins.property + @pulumi.getter + def ssh(self) -> Optional['outputs.CredentialKeysSsh']: + return pulumi.get(self, "ssh") + + @_builtins.property + @pulumi.getter(name="twAgent") + def tw_agent(self) -> Optional['outputs.CredentialKeysTwAgent']: + return pulumi.get(self, "tw_agent") + + +@pulumi.output_type +class CredentialKeysAws(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "accessKey": + suggest = "access_key" + elif key == "assumeRoleArn": + suggest = "assume_role_arn" + elif key == "secretKey": + suggest = "secret_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysAws. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysAws.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysAws.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + access_key: Optional[_builtins.str] = None, + assume_role_arn: Optional[_builtins.str] = None, + secret_key: Optional[_builtins.str] = None): + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if assume_role_arn is not None: + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> Optional[_builtins.str]: + return pulumi.get(self, "assume_role_arn") + + @_builtins.property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "secret_key") + + +@pulumi.output_type +class CredentialKeysAzure(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "batchKey": + suggest = "batch_key" + elif key == "batchName": + suggest = "batch_name" + elif key == "storageKey": + suggest = "storage_key" + elif key == "storageName": + suggest = "storage_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysAzure. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysAzure.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysAzure.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + batch_key: Optional[_builtins.str] = None, + batch_name: Optional[_builtins.str] = None, + storage_key: Optional[_builtins.str] = None, + storage_name: Optional[_builtins.str] = None): + if batch_key is not None: + pulumi.set(__self__, "batch_key", batch_key) + if batch_name is not None: + pulumi.set(__self__, "batch_name", batch_name) + if storage_key is not None: + pulumi.set(__self__, "storage_key", storage_key) + if storage_name is not None: + pulumi.set(__self__, "storage_name", storage_name) + + @_builtins.property + @pulumi.getter(name="batchKey") + def batch_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "batch_key") + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "batch_name") + + @_builtins.property + @pulumi.getter(name="storageKey") + def storage_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_key") + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_name") + + +@pulumi.output_type +class CredentialKeysAzureEntra(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "batchKey": + suggest = "batch_key" + elif key == "batchName": + suggest = "batch_name" + elif key == "clientId": + suggest = "client_id" + elif key == "clientSecret": + suggest = "client_secret" + elif key == "storageKey": + suggest = "storage_key" + elif key == "storageName": + suggest = "storage_name" + elif key == "tenantId": + suggest = "tenant_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysAzureEntra. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysAzureEntra.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysAzureEntra.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + batch_key: Optional[_builtins.str] = None, + batch_name: Optional[_builtins.str] = None, + client_id: Optional[_builtins.str] = None, + client_secret: Optional[_builtins.str] = None, + storage_key: Optional[_builtins.str] = None, + storage_name: Optional[_builtins.str] = None, + tenant_id: Optional[_builtins.str] = None): + if batch_key is not None: + pulumi.set(__self__, "batch_key", batch_key) + if batch_name is not None: + pulumi.set(__self__, "batch_name", batch_name) + if client_id is not None: + pulumi.set(__self__, "client_id", client_id) + if client_secret is not None: + pulumi.set(__self__, "client_secret", client_secret) + if storage_key is not None: + pulumi.set(__self__, "storage_key", storage_key) + if storage_name is not None: + pulumi.set(__self__, "storage_name", storage_name) + if tenant_id is not None: + pulumi.set(__self__, "tenant_id", tenant_id) + + @_builtins.property + @pulumi.getter(name="batchKey") + def batch_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "batch_key") + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "batch_name") + + @_builtins.property + @pulumi.getter(name="clientId") + def client_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "client_id") + + @_builtins.property + @pulumi.getter(name="clientSecret") + def client_secret(self) -> Optional[_builtins.str]: + return pulumi.get(self, "client_secret") + + @_builtins.property + @pulumi.getter(name="storageKey") + def storage_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_key") + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_name") + + @_builtins.property + @pulumi.getter(name="tenantId") + def tenant_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "tenant_id") + + +@pulumi.output_type +class CredentialKeysAzurerepos(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysBitbucket(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysCodecommit(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysContainerReg(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "userName": + suggest = "user_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysContainerReg. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysContainerReg.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysContainerReg.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + registry: Optional[_builtins.str] = None, + user_name: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if registry is not None: + pulumi.set(__self__, "registry", registry) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def registry(self) -> Optional[_builtins.str]: + return pulumi.get(self, "registry") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class CredentialKeysGitea(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysGithub(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysGitlab(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + token: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if token is not None: + pulumi.set(__self__, "token", token) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[_builtins.str]: + return pulumi.get(self, "token") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysGoogle(dict): + def __init__(__self__, *, + data: Optional[_builtins.str] = None): + if data is not None: + pulumi.set(__self__, "data", data) + + @_builtins.property + @pulumi.getter + def data(self) -> Optional[_builtins.str]: + return pulumi.get(self, "data") + + +@pulumi.output_type +class CredentialKeysK8s(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "privateKey": + suggest = "private_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysK8s. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysK8s.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysK8s.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + certificate: Optional[_builtins.str] = None, + private_key: Optional[_builtins.str] = None, + token: Optional[_builtins.str] = None): + if certificate is not None: + pulumi.set(__self__, "certificate", certificate) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + if token is not None: + pulumi.set(__self__, "token", token) + + @_builtins.property + @pulumi.getter + def certificate(self) -> Optional[_builtins.str]: + return pulumi.get(self, "certificate") + + @_builtins.property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "private_key") + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[_builtins.str]: + return pulumi.get(self, "token") + + +@pulumi.output_type +class CredentialKeysSeqeracompute(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "accessKey": + suggest = "access_key" + elif key == "assumeRoleArn": + suggest = "assume_role_arn" + elif key == "secretKey": + suggest = "secret_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysSeqeracompute. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysSeqeracompute.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysSeqeracompute.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + access_key: Optional[_builtins.str] = None, + assume_role_arn: Optional[_builtins.str] = None, + secret_key: Optional[_builtins.str] = None): + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if assume_role_arn is not None: + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> Optional[_builtins.str]: + return pulumi.get(self, "assume_role_arn") + + @_builtins.property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "secret_key") + + +@pulumi.output_type +class CredentialKeysSsh(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "privateKey": + suggest = "private_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysSsh. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysSsh.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysSsh.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + passphrase: Optional[_builtins.str] = None, + private_key: Optional[_builtins.str] = None): + if passphrase is not None: + pulumi.set(__self__, "passphrase", passphrase) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + + @_builtins.property + @pulumi.getter + def passphrase(self) -> Optional[_builtins.str]: + return pulumi.get(self, "passphrase") + + @_builtins.property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "private_key") + + +@pulumi.output_type +class CredentialKeysTwAgent(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "connectionId": + suggest = "connection_id" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysTwAgent. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysTwAgent.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysTwAgent.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + connection_id: Optional[_builtins.str] = None, + shared: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + if connection_id is not None: + pulumi.set(__self__, "connection_id", connection_id) + if shared is not None: + pulumi.set(__self__, "shared", shared) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="connectionId") + def connection_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "connection_id") + + @_builtins.property + @pulumi.getter + def shared(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "shared") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class DataLinkCredential(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "providerType": + suggest = "provider_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DataLinkCredential. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DataLinkCredential.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DataLinkCredential.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + provider_type: Optional[_builtins.str] = None): + """ + :param _builtins.str provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + +@pulumi.output_type +class LabelsLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LabelsLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LabelsLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LabelsLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class PipelineComputeEnv(dict): + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + platform: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None): + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if region is not None: + pulumi.set(__self__, "region", region) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[_builtins.str]: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + +@pulumi.output_type +class PipelineLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in PipelineLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + PipelineLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + PipelineLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class PipelineLaunch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeEnvId": + suggest = "compute_env_id" + elif key == "workDir": + suggest = "work_dir" + elif key == "configProfiles": + suggest = "config_profiles" + elif key == "configText": + suggest = "config_text" + elif key == "dateCreated": + suggest = "date_created" + elif key == "entryName": + suggest = "entry_name" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "labelIds": + suggest = "label_ids" + elif key == "launchContainer": + suggest = "launch_container" + elif key == "mainScript": + suggest = "main_script" + elif key == "optimizationId": + suggest = "optimization_id" + elif key == "optimizationTargets": + suggest = "optimization_targets" + elif key == "paramsText": + suggest = "params_text" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "pullLatest": + suggest = "pull_latest" + elif key == "runName": + suggest = "run_name" + elif key == "schemaName": + suggest = "schema_name" + elif key == "sessionId": + suggest = "session_id" + elif key == "stubRun": + suggest = "stub_run" + elif key == "towerConfig": + suggest = "tower_config" + elif key == "userSecrets": + suggest = "user_secrets" + elif key == "workspaceSecrets": + suggest = "workspace_secrets" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in PipelineLaunch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + PipelineLaunch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + PipelineLaunch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_env_id: _builtins.str, + pipeline: _builtins.str, + work_dir: _builtins.str, + config_profiles: Optional[Sequence[_builtins.str]] = None, + config_text: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + entry_name: Optional[_builtins.str] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + label_ids: Optional[Sequence[_builtins.float]] = None, + launch_container: Optional[_builtins.str] = None, + main_script: Optional[_builtins.str] = None, + optimization_id: Optional[_builtins.str] = None, + optimization_targets: Optional[_builtins.str] = None, + params_text: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + pull_latest: Optional[_builtins.bool] = None, + resume: Optional[_builtins.bool] = None, + revision: Optional[_builtins.str] = None, + run_name: Optional[_builtins.str] = None, + schema_name: Optional[_builtins.str] = None, + session_id: Optional[_builtins.str] = None, + stub_run: Optional[_builtins.bool] = None, + tower_config: Optional[_builtins.str] = None, + user_secrets: Optional[Sequence[_builtins.str]] = None, + workspace_secrets: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + :param _builtins.str pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def pipeline(self) -> _builtins.str: + return pulumi.get(self, "pipeline") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "config_profiles") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[_builtins.str]: + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "entry_name") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[Sequence[_builtins.float]]: + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_container") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[_builtins.str]: + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[_builtins.str]: + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[_builtins.str]: + return pulumi.get(self, "params_text") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "pull_latest") + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[_builtins.str]: + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "schema_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "stub_run") + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[_builtins.str]: + return pulumi.get(self, "tower_config") + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "user_secrets") + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "workspace_secrets") + + +@pulumi.output_type +class StudiosActiveConnection(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "lastActive": + suggest = "last_active" + elif key == "userName": + suggest = "user_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosActiveConnection. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosActiveConnection.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosActiveConnection.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + avatar: Optional[_builtins.str] = None, + email: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + last_active: Optional[_builtins.str] = None, + user_name: Optional[_builtins.str] = None): + if avatar is not None: + pulumi.set(__self__, "avatar", avatar) + if email is not None: + pulumi.set(__self__, "email", email) + if id is not None: + pulumi.set(__self__, "id", id) + if last_active is not None: + pulumi.set(__self__, "last_active", last_active) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> Optional[_builtins.str]: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter + def email(self) -> Optional[_builtins.str]: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastActive") + def last_active(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_active") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class StudiosComputeEnv(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "credentialsId": + suggest = "credentials_id" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosComputeEnv. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosComputeEnv.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosComputeEnv.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + credentials_id: Optional[_builtins.str] = None, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + platform: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if region is not None: + pulumi.set(__self__, "region", region) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[_builtins.str]: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class StudiosConfiguration(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "condaEnvironment": + suggest = "conda_environment" + elif key == "lifespanHours": + suggest = "lifespan_hours" + elif key == "mountDatas": + suggest = "mount_datas" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + conda_environment: Optional[_builtins.str] = None, + cpu: Optional[_builtins.float] = None, + gpu: Optional[_builtins.float] = None, + lifespan_hours: Optional[_builtins.float] = None, + memory: Optional[_builtins.float] = None, + mount_datas: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str conda_environment: Requires replacement if changed. + :param _builtins.float cpu: Requires replacement if changed. + :param _builtins.float gpu: Requires replacement if changed. + :param _builtins.float lifespan_hours: Requires replacement if changed. + :param _builtins.float memory: Requires replacement if changed. + :param Sequence[_builtins.str] mount_datas: Requires replacement if changed. + """ + if conda_environment is not None: + pulumi.set(__self__, "conda_environment", conda_environment) + if cpu is not None: + pulumi.set(__self__, "cpu", cpu) + if gpu is not None: + pulumi.set(__self__, "gpu", gpu) + if lifespan_hours is not None: + pulumi.set(__self__, "lifespan_hours", lifespan_hours) + if memory is not None: + pulumi.set(__self__, "memory", memory) + if mount_datas is not None: + pulumi.set(__self__, "mount_datas", mount_datas) + + @_builtins.property + @pulumi.getter(name="condaEnvironment") + def conda_environment(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "conda_environment") + + @_builtins.property + @pulumi.getter + def cpu(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cpu") + + @_builtins.property + @pulumi.getter + def gpu(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu") + + @_builtins.property + @pulumi.getter(name="lifespanHours") + def lifespan_hours(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lifespan_hours") + + @_builtins.property + @pulumi.getter + def memory(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "memory") + + @_builtins.property + @pulumi.getter(name="mountDatas") + def mount_datas(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "mount_datas") + + +@pulumi.output_type +class StudiosLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class StudiosMountedDataLink(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dataLinkId": + suggest = "data_link_id" + elif key == "providerType": + suggest = "provider_type" + elif key == "publicAccessible": + suggest = "public_accessible" + elif key == "resourceRef": + suggest = "resource_ref" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosMountedDataLink. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosMountedDataLink.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosMountedDataLink.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + credentials: Optional[Sequence['outputs.StudiosMountedDataLinkCredential']] = None, + data_link_id: Optional[_builtins.str] = None, + description: Optional[_builtins.str] = None, + hidden: Optional[_builtins.bool] = None, + message: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + provider_type: Optional[_builtins.str] = None, + public_accessible: Optional[_builtins.bool] = None, + region: Optional[_builtins.str] = None, + resource_ref: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None, + type: Optional[_builtins.str] = None): + """ + :param Sequence['StudiosMountedDataLinkCredentialArgs'] credentials: Array of credentials required to access the data link + :param _builtins.str data_link_id: Unique identifier for the data link + :param _builtins.str description: Description of the data link's purpose and contents + :param _builtins.str name: Display name for the data link connection + :param _builtins.str provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + :param _builtins.str region: Geographic region where the data link is hosted + :param _builtins.str resource_ref: Reference identifier for the external resource + :param _builtins.str status: must be one of ["VALID", "INVALID"] + :param _builtins.str type: must be "bucket" + """ + if credentials is not None: + pulumi.set(__self__, "credentials", credentials) + if data_link_id is not None: + pulumi.set(__self__, "data_link_id", data_link_id) + if description is not None: + pulumi.set(__self__, "description", description) + if hidden is not None: + pulumi.set(__self__, "hidden", hidden) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + if public_accessible is not None: + pulumi.set(__self__, "public_accessible", public_accessible) + if region is not None: + pulumi.set(__self__, "region", region) + if resource_ref is not None: + pulumi.set(__self__, "resource_ref", resource_ref) + if status is not None: + pulumi.set(__self__, "status", status) + if type is not None: + pulumi.set(__self__, "type", type) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Optional[Sequence['outputs.StudiosMountedDataLinkCredential']]: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> Optional[_builtins.str]: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[_builtins.str]: + """ + Description of the data link's purpose and contents + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def hidden(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "hidden") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Display name for the data link connection + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "public_accessible") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> Optional[_builtins.str]: + """ + Reference identifier for the external resource + """ + return pulumi.get(self, "resource_ref") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["VALID", "INVALID"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + must be "bucket" + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class StudiosMountedDataLinkCredential(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "providerType": + suggest = "provider_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosMountedDataLinkCredential. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosMountedDataLinkCredential.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosMountedDataLinkCredential.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + provider_type: Optional[_builtins.str] = None): + """ + :param _builtins.str provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + +@pulumi.output_type +class StudiosParentCheckpoint(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "checkpointId": + suggest = "checkpoint_id" + elif key == "checkpointName": + suggest = "checkpoint_name" + elif key == "sessionId": + suggest = "session_id" + elif key == "studioName": + suggest = "studio_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosParentCheckpoint. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosParentCheckpoint.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosParentCheckpoint.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + checkpoint_id: Optional[_builtins.float] = None, + checkpoint_name: Optional[_builtins.str] = None, + session_id: Optional[_builtins.str] = None, + studio_name: Optional[_builtins.str] = None): + if checkpoint_id is not None: + pulumi.set(__self__, "checkpoint_id", checkpoint_id) + if checkpoint_name is not None: + pulumi.set(__self__, "checkpoint_name", checkpoint_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if studio_name is not None: + pulumi.set(__self__, "studio_name", studio_name) + + @_builtins.property + @pulumi.getter(name="checkpointId") + def checkpoint_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "checkpoint_id") + + @_builtins.property + @pulumi.getter(name="checkpointName") + def checkpoint_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "checkpoint_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="studioName") + def studio_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "studio_name") + + +@pulumi.output_type +class StudiosProgress(dict): + def __init__(__self__, *, + message: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None, + warnings: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str status: must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + if message is not None: + pulumi.set(__self__, "message", message) + if status is not None: + pulumi.set(__self__, "status", status) + if warnings is not None: + pulumi.set(__self__, "warnings", warnings) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def warnings(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "warnings") + + +@pulumi.output_type +class StudiosStatusInfo(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "lastUpdate": + suggest = "last_update" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosStatusInfo. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosStatusInfo.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosStatusInfo.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + last_update: Optional[_builtins.str] = None, + message: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None): + """ + :param _builtins.str status: must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ + if last_update is not None: + pulumi.set(__self__, "last_update", last_update) + if message is not None: + pulumi.set(__self__, "message", message) + if status is not None: + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="lastUpdate") + def last_update(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_update") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ + return pulumi.get(self, "status") + + +@pulumi.output_type +class StudiosTemplate(dict): + def __init__(__self__, *, + icon: Optional[_builtins.str] = None, + repository: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None, + tool: Optional[_builtins.str] = None): + """ + :param _builtins.str status: must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + if icon is not None: + pulumi.set(__self__, "icon", icon) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if status is not None: + pulumi.set(__self__, "status", status) + if tool is not None: + pulumi.set(__self__, "tool", tool) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[_builtins.str]: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[_builtins.str]: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def tool(self) -> Optional[_builtins.str]: + return pulumi.get(self, "tool") + + +@pulumi.output_type +class StudiosUser(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "userName": + suggest = "user_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosUser. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosUser.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosUser.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + avatar: Optional[_builtins.str] = None, + email: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + user_name: Optional[_builtins.str] = None): + if avatar is not None: + pulumi.set(__self__, "avatar", avatar) + if email is not None: + pulumi.set(__self__, "email", email) + if id is not None: + pulumi.set(__self__, "id", id) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> Optional[_builtins.str]: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter + def email(self) -> Optional[_builtins.str]: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class TokensToken(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "basicAuth": + suggest = "basic_auth" + elif key == "dateCreated": + suggest = "date_created" + elif key == "lastUsed": + suggest = "last_used" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TokensToken. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TokensToken.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TokensToken.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + basic_auth: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + last_used: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None): + """ + :param _builtins.str basic_auth: Deprecated basic authentication string + :param _builtins.str date_created: Timestamp when the token was created + :param _builtins.float id: Unique numeric identifier for the access token (nullable) + :param _builtins.str last_used: Timestamp when the token was last used for authentication + :param _builtins.str name: Display name for the token (1-50 characters) + """ + if basic_auth is not None: + pulumi.set(__self__, "basic_auth", basic_auth) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> Optional[_builtins.str]: + """ + Deprecated basic authentication string + """ + return pulumi.get(self, "basic_auth") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the token was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the access token (nullable) + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[_builtins.str]: + """ + Timestamp when the token was last used for authentication + """ + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Display name for the token (1-50 characters) + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class WorkflowsJobInfo(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "exitCode": + suggest = "exit_code" + elif key == "operationId": + suggest = "operation_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsJobInfo. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsJobInfo.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsJobInfo.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + exit_code: Optional[_builtins.float] = None, + id: Optional[_builtins.float] = None, + message: Optional[_builtins.str] = None, + operation_id: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None): + if exit_code is not None: + pulumi.set(__self__, "exit_code", exit_code) + if id is not None: + pulumi.set(__self__, "id", id) + if message is not None: + pulumi.set(__self__, "message", message) + if operation_id is not None: + pulumi.set(__self__, "operation_id", operation_id) + if status is not None: + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="exitCode") + def exit_code(self) -> Optional[_builtins.float]: + return pulumi.get(self, "exit_code") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "operation_id") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + return pulumi.get(self, "status") + + +@pulumi.output_type +class WorkflowsLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class WorkflowsPlatform(dict): + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None): + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + +@pulumi.output_type +class WorkflowsProgress(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "processesProgresses": + suggest = "processes_progresses" + elif key == "totalProcesses": + suggest = "total_processes" + elif key == "workflowProgress": + suggest = "workflow_progress" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsProgress. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsProgress.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsProgress.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + processes_progresses: Optional[Sequence['outputs.WorkflowsProgressProcessesProgress']] = None, + total_processes: Optional[_builtins.float] = None, + workflow_progress: Optional['outputs.WorkflowsProgressWorkflowProgress'] = None): + if processes_progresses is not None: + pulumi.set(__self__, "processes_progresses", processes_progresses) + if total_processes is not None: + pulumi.set(__self__, "total_processes", total_processes) + if workflow_progress is not None: + pulumi.set(__self__, "workflow_progress", workflow_progress) + + @_builtins.property + @pulumi.getter(name="processesProgresses") + def processes_progresses(self) -> Optional[Sequence['outputs.WorkflowsProgressProcessesProgress']]: + return pulumi.get(self, "processes_progresses") + + @_builtins.property + @pulumi.getter(name="totalProcesses") + def total_processes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "total_processes") + + @_builtins.property + @pulumi.getter(name="workflowProgress") + def workflow_progress(self) -> Optional['outputs.WorkflowsProgressWorkflowProgress']: + return pulumi.get(self, "workflow_progress") + + +@pulumi.output_type +class WorkflowsProgressProcessesProgress(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cpuEfficiency": + suggest = "cpu_efficiency" + elif key == "cpuLoad": + suggest = "cpu_load" + elif key == "cpuTime": + suggest = "cpu_time" + elif key == "dateCreated": + suggest = "date_created" + elif key == "invCtxSwitch": + suggest = "inv_ctx_switch" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "loadCpus": + suggest = "load_cpus" + elif key == "loadMemory": + suggest = "load_memory" + elif key == "loadTasks": + suggest = "load_tasks" + elif key == "memoryEfficiency": + suggest = "memory_efficiency" + elif key == "memoryReq": + suggest = "memory_req" + elif key == "memoryRss": + suggest = "memory_rss" + elif key == "peakCpus": + suggest = "peak_cpus" + elif key == "peakMemory": + suggest = "peak_memory" + elif key == "peakTasks": + suggest = "peak_tasks" + elif key == "readBytes": + suggest = "read_bytes" + elif key == "volCtxSwitch": + suggest = "vol_ctx_switch" + elif key == "writeBytes": + suggest = "write_bytes" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsProgressProcessesProgress. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsProgressProcessesProgress.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsProgressProcessesProgress.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + aborted: Optional[_builtins.float] = None, + cached: Optional[_builtins.float] = None, + cpu_efficiency: Optional[_builtins.float] = None, + cpu_load: Optional[_builtins.float] = None, + cpu_time: Optional[_builtins.float] = None, + cpus: Optional[_builtins.float] = None, + date_created: Optional[_builtins.str] = None, + failed: Optional[_builtins.float] = None, + inv_ctx_switch: Optional[_builtins.float] = None, + last_updated: Optional[_builtins.str] = None, + load_cpus: Optional[_builtins.float] = None, + load_memory: Optional[_builtins.float] = None, + load_tasks: Optional[_builtins.float] = None, + memory_efficiency: Optional[_builtins.float] = None, + memory_req: Optional[_builtins.float] = None, + memory_rss: Optional[_builtins.float] = None, + peak_cpus: Optional[_builtins.float] = None, + peak_memory: Optional[_builtins.float] = None, + peak_tasks: Optional[_builtins.float] = None, + pending: Optional[_builtins.float] = None, + process: Optional[_builtins.str] = None, + read_bytes: Optional[_builtins.float] = None, + running: Optional[_builtins.float] = None, + submitted: Optional[_builtins.float] = None, + succeeded: Optional[_builtins.float] = None, + vol_ctx_switch: Optional[_builtins.float] = None, + write_bytes: Optional[_builtins.float] = None): + if aborted is not None: + pulumi.set(__self__, "aborted", aborted) + if cached is not None: + pulumi.set(__self__, "cached", cached) + if cpu_efficiency is not None: + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + if cpu_load is not None: + pulumi.set(__self__, "cpu_load", cpu_load) + if cpu_time is not None: + pulumi.set(__self__, "cpu_time", cpu_time) + if cpus is not None: + pulumi.set(__self__, "cpus", cpus) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if failed is not None: + pulumi.set(__self__, "failed", failed) + if inv_ctx_switch is not None: + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if load_cpus is not None: + pulumi.set(__self__, "load_cpus", load_cpus) + if load_memory is not None: + pulumi.set(__self__, "load_memory", load_memory) + if load_tasks is not None: + pulumi.set(__self__, "load_tasks", load_tasks) + if memory_efficiency is not None: + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + if memory_req is not None: + pulumi.set(__self__, "memory_req", memory_req) + if memory_rss is not None: + pulumi.set(__self__, "memory_rss", memory_rss) + if peak_cpus is not None: + pulumi.set(__self__, "peak_cpus", peak_cpus) + if peak_memory is not None: + pulumi.set(__self__, "peak_memory", peak_memory) + if peak_tasks is not None: + pulumi.set(__self__, "peak_tasks", peak_tasks) + if pending is not None: + pulumi.set(__self__, "pending", pending) + if process is not None: + pulumi.set(__self__, "process", process) + if read_bytes is not None: + pulumi.set(__self__, "read_bytes", read_bytes) + if running is not None: + pulumi.set(__self__, "running", running) + if submitted is not None: + pulumi.set(__self__, "submitted", submitted) + if succeeded is not None: + pulumi.set(__self__, "succeeded", succeeded) + if vol_ctx_switch is not None: + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + if write_bytes is not None: + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> Optional[_builtins.float]: + return pulumi.get(self, "aborted") + + @_builtins.property + @pulumi.getter + def cached(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached") + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_efficiency") + + @_builtins.property + @pulumi.getter(name="cpuLoad") + @_utilities.deprecated("""Deprecated""") + def cpu_load(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_load") + + @_builtins.property + @pulumi.getter(name="cpuTime") + @_utilities.deprecated("""Deprecated""") + def cpu_time(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_time") + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpus") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def failed(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed") + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def inv_ctx_switch(self) -> Optional[_builtins.float]: + return pulumi.get(self, "inv_ctx_switch") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_cpus") + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_memory") + + @_builtins.property + @pulumi.getter(name="loadTasks") + @_utilities.deprecated("""Deprecated""") + def load_tasks(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_tasks") + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_efficiency") + + @_builtins.property + @pulumi.getter(name="memoryReq") + @_utilities.deprecated("""Deprecated""") + def memory_req(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_req") + + @_builtins.property + @pulumi.getter(name="memoryRss") + @_utilities.deprecated("""Deprecated""") + def memory_rss(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_rss") + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_cpus") + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_memory") + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_tasks") + + @_builtins.property + @pulumi.getter + def pending(self) -> Optional[_builtins.float]: + return pulumi.get(self, "pending") + + @_builtins.property + @pulumi.getter + def process(self) -> Optional[_builtins.str]: + return pulumi.get(self, "process") + + @_builtins.property + @pulumi.getter(name="readBytes") + @_utilities.deprecated("""Deprecated""") + def read_bytes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "read_bytes") + + @_builtins.property + @pulumi.getter + def running(self) -> Optional[_builtins.float]: + return pulumi.get(self, "running") + + @_builtins.property + @pulumi.getter + def submitted(self) -> Optional[_builtins.float]: + return pulumi.get(self, "submitted") + + @_builtins.property + @pulumi.getter + def succeeded(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeeded") + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def vol_ctx_switch(self) -> Optional[_builtins.float]: + return pulumi.get(self, "vol_ctx_switch") + + @_builtins.property + @pulumi.getter(name="writeBytes") + @_utilities.deprecated("""Deprecated""") + def write_bytes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "write_bytes") + + +@pulumi.output_type +class WorkflowsProgressWorkflowProgress(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cpuEfficiency": + suggest = "cpu_efficiency" + elif key == "cpuLoad": + suggest = "cpu_load" + elif key == "cpuTime": + suggest = "cpu_time" + elif key == "dateCreated": + suggest = "date_created" + elif key == "invCtxSwitch": + suggest = "inv_ctx_switch" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "loadCpus": + suggest = "load_cpus" + elif key == "loadMemory": + suggest = "load_memory" + elif key == "loadTasks": + suggest = "load_tasks" + elif key == "memoryEfficiency": + suggest = "memory_efficiency" + elif key == "memoryReq": + suggest = "memory_req" + elif key == "memoryRss": + suggest = "memory_rss" + elif key == "peakCpus": + suggest = "peak_cpus" + elif key == "peakMemory": + suggest = "peak_memory" + elif key == "peakTasks": + suggest = "peak_tasks" + elif key == "readBytes": + suggest = "read_bytes" + elif key == "volCtxSwitch": + suggest = "vol_ctx_switch" + elif key == "writeBytes": + suggest = "write_bytes" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsProgressWorkflowProgress. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsProgressWorkflowProgress.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsProgressWorkflowProgress.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + aborted: Optional[_builtins.float] = None, + cached: Optional[_builtins.float] = None, + cost: Optional[_builtins.float] = None, + cpu_efficiency: Optional[_builtins.float] = None, + cpu_load: Optional[_builtins.float] = None, + cpu_time: Optional[_builtins.float] = None, + cpus: Optional[_builtins.float] = None, + date_created: Optional[_builtins.str] = None, + executors: Optional[Sequence[_builtins.str]] = None, + failed: Optional[_builtins.float] = None, + inv_ctx_switch: Optional[_builtins.float] = None, + last_updated: Optional[_builtins.str] = None, + load_cpus: Optional[_builtins.float] = None, + load_memory: Optional[_builtins.float] = None, + load_tasks: Optional[_builtins.float] = None, + memory_efficiency: Optional[_builtins.float] = None, + memory_req: Optional[_builtins.float] = None, + memory_rss: Optional[_builtins.float] = None, + peak_cpus: Optional[_builtins.float] = None, + peak_memory: Optional[_builtins.float] = None, + peak_tasks: Optional[_builtins.float] = None, + pending: Optional[_builtins.float] = None, + read_bytes: Optional[_builtins.float] = None, + running: Optional[_builtins.float] = None, + submitted: Optional[_builtins.float] = None, + succeeded: Optional[_builtins.float] = None, + vol_ctx_switch: Optional[_builtins.float] = None, + write_bytes: Optional[_builtins.float] = None): + if aborted is not None: + pulumi.set(__self__, "aborted", aborted) + if cached is not None: + pulumi.set(__self__, "cached", cached) + if cost is not None: + pulumi.set(__self__, "cost", cost) + if cpu_efficiency is not None: + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + if cpu_load is not None: + pulumi.set(__self__, "cpu_load", cpu_load) + if cpu_time is not None: + pulumi.set(__self__, "cpu_time", cpu_time) + if cpus is not None: + pulumi.set(__self__, "cpus", cpus) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if executors is not None: + pulumi.set(__self__, "executors", executors) + if failed is not None: + pulumi.set(__self__, "failed", failed) + if inv_ctx_switch is not None: + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if load_cpus is not None: + pulumi.set(__self__, "load_cpus", load_cpus) + if load_memory is not None: + pulumi.set(__self__, "load_memory", load_memory) + if load_tasks is not None: + pulumi.set(__self__, "load_tasks", load_tasks) + if memory_efficiency is not None: + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + if memory_req is not None: + pulumi.set(__self__, "memory_req", memory_req) + if memory_rss is not None: + pulumi.set(__self__, "memory_rss", memory_rss) + if peak_cpus is not None: + pulumi.set(__self__, "peak_cpus", peak_cpus) + if peak_memory is not None: + pulumi.set(__self__, "peak_memory", peak_memory) + if peak_tasks is not None: + pulumi.set(__self__, "peak_tasks", peak_tasks) + if pending is not None: + pulumi.set(__self__, "pending", pending) + if read_bytes is not None: + pulumi.set(__self__, "read_bytes", read_bytes) + if running is not None: + pulumi.set(__self__, "running", running) + if submitted is not None: + pulumi.set(__self__, "submitted", submitted) + if succeeded is not None: + pulumi.set(__self__, "succeeded", succeeded) + if vol_ctx_switch is not None: + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + if write_bytes is not None: + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> Optional[_builtins.float]: + return pulumi.get(self, "aborted") + + @_builtins.property + @pulumi.getter + def cached(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached") + + @_builtins.property + @pulumi.getter + def cost(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cost") + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_efficiency") + + @_builtins.property + @pulumi.getter(name="cpuLoad") + def cpu_load(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_load") + + @_builtins.property + @pulumi.getter(name="cpuTime") + def cpu_time(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_time") + + @_builtins.property + @pulumi.getter + def cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpus") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def executors(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "executors") + + @_builtins.property + @pulumi.getter + def failed(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed") + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + def inv_ctx_switch(self) -> Optional[_builtins.float]: + return pulumi.get(self, "inv_ctx_switch") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_cpus") + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_memory") + + @_builtins.property + @pulumi.getter(name="loadTasks") + def load_tasks(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_tasks") + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_efficiency") + + @_builtins.property + @pulumi.getter(name="memoryReq") + def memory_req(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_req") + + @_builtins.property + @pulumi.getter(name="memoryRss") + def memory_rss(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_rss") + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_cpus") + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_memory") + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_tasks") + + @_builtins.property + @pulumi.getter + def pending(self) -> Optional[_builtins.float]: + return pulumi.get(self, "pending") + + @_builtins.property + @pulumi.getter(name="readBytes") + def read_bytes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "read_bytes") + + @_builtins.property + @pulumi.getter + def running(self) -> Optional[_builtins.float]: + return pulumi.get(self, "running") + + @_builtins.property + @pulumi.getter + def submitted(self) -> Optional[_builtins.float]: + return pulumi.get(self, "submitted") + + @_builtins.property + @pulumi.getter + def succeeded(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeeded") + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + def vol_ctx_switch(self) -> Optional[_builtins.float]: + return pulumi.get(self, "vol_ctx_switch") + + @_builtins.property + @pulumi.getter(name="writeBytes") + def write_bytes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "write_bytes") + + +@pulumi.output_type +class WorkflowsWorkflow(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "commandLine": + suggest = "command_line" + elif key == "commitId": + suggest = "commit_id" + elif key == "configFiles": + suggest = "config_files" + elif key == "configText": + suggest = "config_text" + elif key == "containerEngine": + suggest = "container_engine" + elif key == "dateCreated": + suggest = "date_created" + elif key == "errorMessage": + suggest = "error_message" + elif key == "errorReport": + suggest = "error_report" + elif key == "exitStatus": + suggest = "exit_status" + elif key == "homeDir": + suggest = "home_dir" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "launchId": + suggest = "launch_id" + elif key == "logFile": + suggest = "log_file" + elif key == "operationId": + suggest = "operation_id" + elif key == "outFile": + suggest = "out_file" + elif key == "ownerId": + suggest = "owner_id" + elif key == "projectDir": + suggest = "project_dir" + elif key == "projectName": + suggest = "project_name" + elif key == "requiresAttention": + suggest = "requires_attention" + elif key == "runName": + suggest = "run_name" + elif key == "scriptFile": + suggest = "script_file" + elif key == "scriptId": + suggest = "script_id" + elif key == "scriptName": + suggest = "script_name" + elif key == "sessionId": + suggest = "session_id" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsWorkflow. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsWorkflow.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsWorkflow.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + command_line: Optional[_builtins.str] = None, + commit_id: Optional[_builtins.str] = None, + complete: Optional[_builtins.str] = None, + config_files: Optional[Sequence[_builtins.str]] = None, + config_text: Optional[_builtins.str] = None, + container: Optional[_builtins.str] = None, + container_engine: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + deleted: Optional[_builtins.bool] = None, + duration: Optional[_builtins.float] = None, + error_message: Optional[_builtins.str] = None, + error_report: Optional[_builtins.str] = None, + exit_status: Optional[_builtins.float] = None, + home_dir: Optional[_builtins.str] = None, + id: Optional[_builtins.str] = None, + last_updated: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + launch_id: Optional[_builtins.str] = None, + log_file: Optional[_builtins.str] = None, + manifest: Optional['outputs.WorkflowsWorkflowManifest'] = None, + nextflow: Optional['outputs.WorkflowsWorkflowNextflow'] = None, + operation_id: Optional[_builtins.str] = None, + out_file: Optional[_builtins.str] = None, + owner_id: Optional[_builtins.float] = None, + params: Optional[Mapping[str, _builtins.str]] = None, + profile: Optional[_builtins.str] = None, + project_dir: Optional[_builtins.str] = None, + project_name: Optional[_builtins.str] = None, + repository: Optional[_builtins.str] = None, + requires_attention: Optional[_builtins.bool] = None, + resume: Optional[_builtins.bool] = None, + revision: Optional[_builtins.str] = None, + run_name: Optional[_builtins.str] = None, + script_file: Optional[_builtins.str] = None, + script_id: Optional[_builtins.str] = None, + script_name: Optional[_builtins.str] = None, + session_id: Optional[_builtins.str] = None, + start: Optional[_builtins.str] = None, + stats: Optional['outputs.WorkflowsWorkflowStats'] = None, + status: Optional[_builtins.str] = None, + submit: Optional[_builtins.str] = None, + success: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str status: must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + if command_line is not None: + pulumi.set(__self__, "command_line", command_line) + if commit_id is not None: + pulumi.set(__self__, "commit_id", commit_id) + if complete is not None: + pulumi.set(__self__, "complete", complete) + if config_files is not None: + pulumi.set(__self__, "config_files", config_files) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if container is not None: + pulumi.set(__self__, "container", container) + if container_engine is not None: + pulumi.set(__self__, "container_engine", container_engine) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error_message is not None: + pulumi.set(__self__, "error_message", error_message) + if error_report is not None: + pulumi.set(__self__, "error_report", error_report) + if exit_status is not None: + pulumi.set(__self__, "exit_status", exit_status) + if home_dir is not None: + pulumi.set(__self__, "home_dir", home_dir) + if id is not None: + pulumi.set(__self__, "id", id) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if launch_id is not None: + pulumi.set(__self__, "launch_id", launch_id) + if log_file is not None: + pulumi.set(__self__, "log_file", log_file) + if manifest is not None: + pulumi.set(__self__, "manifest", manifest) + if nextflow is not None: + pulumi.set(__self__, "nextflow", nextflow) + if operation_id is not None: + pulumi.set(__self__, "operation_id", operation_id) + if out_file is not None: + pulumi.set(__self__, "out_file", out_file) + if owner_id is not None: + pulumi.set(__self__, "owner_id", owner_id) + if params is not None: + pulumi.set(__self__, "params", params) + if profile is not None: + pulumi.set(__self__, "profile", profile) + if project_dir is not None: + pulumi.set(__self__, "project_dir", project_dir) + if project_name is not None: + pulumi.set(__self__, "project_name", project_name) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if requires_attention is not None: + pulumi.set(__self__, "requires_attention", requires_attention) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if script_file is not None: + pulumi.set(__self__, "script_file", script_file) + if script_id is not None: + pulumi.set(__self__, "script_id", script_id) + if script_name is not None: + pulumi.set(__self__, "script_name", script_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if start is not None: + pulumi.set(__self__, "start", start) + if stats is not None: + pulumi.set(__self__, "stats", stats) + if status is not None: + pulumi.set(__self__, "status", status) + if submit is not None: + pulumi.set(__self__, "submit", submit) + if success is not None: + pulumi.set(__self__, "success", success) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="commandLine") + def command_line(self) -> Optional[_builtins.str]: + return pulumi.get(self, "command_line") + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "commit_id") + + @_builtins.property + @pulumi.getter + def complete(self) -> Optional[_builtins.str]: + return pulumi.get(self, "complete") + + @_builtins.property + @pulumi.getter(name="configFiles") + def config_files(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "config_files") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[_builtins.str]: + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter + def container(self) -> Optional[_builtins.str]: + return pulumi.get(self, "container") + + @_builtins.property + @pulumi.getter(name="containerEngine") + def container_engine(self) -> Optional[_builtins.str]: + return pulumi.get(self, "container_engine") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def duration(self) -> Optional[_builtins.float]: + return pulumi.get(self, "duration") + + @_builtins.property + @pulumi.getter(name="errorMessage") + def error_message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "error_message") + + @_builtins.property + @pulumi.getter(name="errorReport") + def error_report(self) -> Optional[_builtins.str]: + return pulumi.get(self, "error_report") + + @_builtins.property + @pulumi.getter(name="exitStatus") + def exit_status(self) -> Optional[_builtins.float]: + return pulumi.get(self, "exit_status") + + @_builtins.property + @pulumi.getter(name="homeDir") + def home_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "home_dir") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="launchId") + def launch_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_id") + + @_builtins.property + @pulumi.getter(name="logFile") + def log_file(self) -> Optional[_builtins.str]: + return pulumi.get(self, "log_file") + + @_builtins.property + @pulumi.getter + def manifest(self) -> Optional['outputs.WorkflowsWorkflowManifest']: + return pulumi.get(self, "manifest") + + @_builtins.property + @pulumi.getter + def nextflow(self) -> Optional['outputs.WorkflowsWorkflowNextflow']: + return pulumi.get(self, "nextflow") + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "operation_id") + + @_builtins.property + @pulumi.getter(name="outFile") + def out_file(self) -> Optional[_builtins.str]: + return pulumi.get(self, "out_file") + + @_builtins.property + @pulumi.getter(name="ownerId") + def owner_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "owner_id") + + @_builtins.property + @pulumi.getter + def params(self) -> Optional[Mapping[str, _builtins.str]]: + return pulumi.get(self, "params") + + @_builtins.property + @pulumi.getter + def profile(self) -> Optional[_builtins.str]: + return pulumi.get(self, "profile") + + @_builtins.property + @pulumi.getter(name="projectDir") + def project_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "project_dir") + + @_builtins.property + @pulumi.getter(name="projectName") + def project_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "project_name") + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[_builtins.str]: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter(name="requiresAttention") + def requires_attention(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "requires_attention") + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[_builtins.str]: + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="scriptFile") + def script_file(self) -> Optional[_builtins.str]: + return pulumi.get(self, "script_file") + + @_builtins.property + @pulumi.getter(name="scriptId") + def script_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "script_id") + + @_builtins.property + @pulumi.getter(name="scriptName") + def script_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "script_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter + def start(self) -> Optional[_builtins.str]: + return pulumi.get(self, "start") + + @_builtins.property + @pulumi.getter + def stats(self) -> Optional['outputs.WorkflowsWorkflowStats']: + return pulumi.get(self, "stats") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def submit(self) -> Optional[_builtins.str]: + return pulumi.get(self, "submit") + + @_builtins.property + @pulumi.getter + def success(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "success") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class WorkflowsWorkflowManifest(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "defaultBranch": + suggest = "default_branch" + elif key == "homePage": + suggest = "home_page" + elif key == "mainScript": + suggest = "main_script" + elif key == "nextflowVersion": + suggest = "nextflow_version" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsWorkflowManifest. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsWorkflowManifest.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsWorkflowManifest.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + author: Optional[_builtins.str] = None, + default_branch: Optional[_builtins.str] = None, + description: Optional[_builtins.str] = None, + gitmodules: Optional[_builtins.str] = None, + home_page: Optional[_builtins.str] = None, + icon: Optional[_builtins.str] = None, + main_script: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + nextflow_version: Optional[_builtins.str] = None, + version: Optional[_builtins.str] = None): + if author is not None: + pulumi.set(__self__, "author", author) + if default_branch is not None: + pulumi.set(__self__, "default_branch", default_branch) + if description is not None: + pulumi.set(__self__, "description", description) + if gitmodules is not None: + pulumi.set(__self__, "gitmodules", gitmodules) + if home_page is not None: + pulumi.set(__self__, "home_page", home_page) + if icon is not None: + pulumi.set(__self__, "icon", icon) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if name is not None: + pulumi.set(__self__, "name", name) + if nextflow_version is not None: + pulumi.set(__self__, "nextflow_version", nextflow_version) + if version is not None: + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def author(self) -> Optional[_builtins.str]: + return pulumi.get(self, "author") + + @_builtins.property + @pulumi.getter(name="defaultBranch") + def default_branch(self) -> Optional[_builtins.str]: + return pulumi.get(self, "default_branch") + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def gitmodules(self) -> Optional[_builtins.str]: + return pulumi.get(self, "gitmodules") + + @_builtins.property + @pulumi.getter(name="homePage") + def home_page(self) -> Optional[_builtins.str]: + return pulumi.get(self, "home_page") + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[_builtins.str]: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[_builtins.str]: + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="nextflowVersion") + def nextflow_version(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nextflow_version") + + @_builtins.property + @pulumi.getter + def version(self) -> Optional[_builtins.str]: + return pulumi.get(self, "version") + + +@pulumi.output_type +class WorkflowsWorkflowNextflow(dict): + def __init__(__self__, *, + build: Optional[_builtins.str] = None, + timestamp: Optional[_builtins.str] = None, + version: Optional[_builtins.str] = None): + if build is not None: + pulumi.set(__self__, "build", build) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + if version is not None: + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def build(self) -> Optional[_builtins.str]: + return pulumi.get(self, "build") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[_builtins.str]: + return pulumi.get(self, "timestamp") + + @_builtins.property + @pulumi.getter + def version(self) -> Optional[_builtins.str]: + return pulumi.get(self, "version") + + +@pulumi.output_type +class WorkflowsWorkflowStats(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cachedCount": + suggest = "cached_count" + elif key == "cachedCountFmt": + suggest = "cached_count_fmt" + elif key == "cachedDuration": + suggest = "cached_duration" + elif key == "cachedPct": + suggest = "cached_pct" + elif key == "computeTimeFmt": + suggest = "compute_time_fmt" + elif key == "failedCount": + suggest = "failed_count" + elif key == "failedCountFmt": + suggest = "failed_count_fmt" + elif key == "failedDuration": + suggest = "failed_duration" + elif key == "failedPct": + suggest = "failed_pct" + elif key == "ignoredCount": + suggest = "ignored_count" + elif key == "ignoredCountFmt": + suggest = "ignored_count_fmt" + elif key == "ignoredPct": + suggest = "ignored_pct" + elif key == "succeedCount": + suggest = "succeed_count" + elif key == "succeedCountFmt": + suggest = "succeed_count_fmt" + elif key == "succeedDuration": + suggest = "succeed_duration" + elif key == "succeedPct": + suggest = "succeed_pct" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsWorkflowStats. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsWorkflowStats.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsWorkflowStats.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cached_count: Optional[_builtins.float] = None, + cached_count_fmt: Optional[_builtins.str] = None, + cached_duration: Optional[_builtins.float] = None, + cached_pct: Optional[_builtins.float] = None, + compute_time_fmt: Optional[_builtins.str] = None, + failed_count: Optional[_builtins.float] = None, + failed_count_fmt: Optional[_builtins.str] = None, + failed_duration: Optional[_builtins.float] = None, + failed_pct: Optional[_builtins.float] = None, + ignored_count: Optional[_builtins.float] = None, + ignored_count_fmt: Optional[_builtins.str] = None, + ignored_pct: Optional[_builtins.float] = None, + succeed_count: Optional[_builtins.float] = None, + succeed_count_fmt: Optional[_builtins.str] = None, + succeed_duration: Optional[_builtins.float] = None, + succeed_pct: Optional[_builtins.float] = None): + if cached_count is not None: + pulumi.set(__self__, "cached_count", cached_count) + if cached_count_fmt is not None: + pulumi.set(__self__, "cached_count_fmt", cached_count_fmt) + if cached_duration is not None: + pulumi.set(__self__, "cached_duration", cached_duration) + if cached_pct is not None: + pulumi.set(__self__, "cached_pct", cached_pct) + if compute_time_fmt is not None: + pulumi.set(__self__, "compute_time_fmt", compute_time_fmt) + if failed_count is not None: + pulumi.set(__self__, "failed_count", failed_count) + if failed_count_fmt is not None: + pulumi.set(__self__, "failed_count_fmt", failed_count_fmt) + if failed_duration is not None: + pulumi.set(__self__, "failed_duration", failed_duration) + if failed_pct is not None: + pulumi.set(__self__, "failed_pct", failed_pct) + if ignored_count is not None: + pulumi.set(__self__, "ignored_count", ignored_count) + if ignored_count_fmt is not None: + pulumi.set(__self__, "ignored_count_fmt", ignored_count_fmt) + if ignored_pct is not None: + pulumi.set(__self__, "ignored_pct", ignored_pct) + if succeed_count is not None: + pulumi.set(__self__, "succeed_count", succeed_count) + if succeed_count_fmt is not None: + pulumi.set(__self__, "succeed_count_fmt", succeed_count_fmt) + if succeed_duration is not None: + pulumi.set(__self__, "succeed_duration", succeed_duration) + if succeed_pct is not None: + pulumi.set(__self__, "succeed_pct", succeed_pct) + + @_builtins.property + @pulumi.getter(name="cachedCount") + def cached_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached_count") + + @_builtins.property + @pulumi.getter(name="cachedCountFmt") + def cached_count_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "cached_count_fmt") + + @_builtins.property + @pulumi.getter(name="cachedDuration") + def cached_duration(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached_duration") + + @_builtins.property + @pulumi.getter(name="cachedPct") + def cached_pct(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached_pct") + + @_builtins.property + @pulumi.getter(name="computeTimeFmt") + def compute_time_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_time_fmt") + + @_builtins.property + @pulumi.getter(name="failedCount") + def failed_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed_count") + + @_builtins.property + @pulumi.getter(name="failedCountFmt") + def failed_count_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "failed_count_fmt") + + @_builtins.property + @pulumi.getter(name="failedDuration") + def failed_duration(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed_duration") + + @_builtins.property + @pulumi.getter(name="failedPct") + def failed_pct(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed_pct") + + @_builtins.property + @pulumi.getter(name="ignoredCount") + def ignored_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ignored_count") + + @_builtins.property + @pulumi.getter(name="ignoredCountFmt") + def ignored_count_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ignored_count_fmt") + + @_builtins.property + @pulumi.getter(name="ignoredPct") + def ignored_pct(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ignored_pct") + + @_builtins.property + @pulumi.getter(name="succeedCount") + def succeed_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeed_count") + + @_builtins.property + @pulumi.getter(name="succeedCountFmt") + def succeed_count_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "succeed_count_fmt") + + @_builtins.property + @pulumi.getter(name="succeedDuration") + def succeed_duration(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeed_duration") + + @_builtins.property + @pulumi.getter(name="succeedPct") + def succeed_pct(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeed_pct") + + +@pulumi.output_type +class GetActionConfigResult(dict): + def __init__(__self__, *, + github: 'outputs.GetActionConfigGithubResult', + tower: 'outputs.GetActionConfigTowerResult'): + pulumi.set(__self__, "github", github) + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> 'outputs.GetActionConfigGithubResult': + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def tower(self) -> 'outputs.GetActionConfigTowerResult': + return pulumi.get(self, "tower") + + +@pulumi.output_type +class GetActionConfigGithubResult(dict): + def __init__(__self__, *, + discriminator: _builtins.str, + events: Sequence[_builtins.str]): + pulumi.set(__self__, "discriminator", discriminator) + pulumi.set(__self__, "events", events) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> _builtins.str: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter + def events(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "events") + + +@pulumi.output_type +class GetActionConfigTowerResult(dict): + def __init__(__self__, *, + discriminator: _builtins.str): + pulumi.set(__self__, "discriminator", discriminator) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> _builtins.str: + return pulumi.get(self, "discriminator") + + +@pulumi.output_type +class GetActionEventResult(dict): + def __init__(__self__, *, + github: 'outputs.GetActionEventGithubResult', + tower: 'outputs.GetActionEventTowerResult'): + pulumi.set(__self__, "github", github) + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> 'outputs.GetActionEventGithubResult': + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def tower(self) -> 'outputs.GetActionEventTowerResult': + return pulumi.get(self, "tower") + + +@pulumi.output_type +class GetActionEventGithubResult(dict): + def __init__(__self__, *, + commit_id: _builtins.str, + commit_message: _builtins.str, + discriminator: _builtins.str, + pusher_email: _builtins.str, + pusher_name: _builtins.str, + ref: _builtins.str, + timestamp: _builtins.str): + pulumi.set(__self__, "commit_id", commit_id) + pulumi.set(__self__, "commit_message", commit_message) + pulumi.set(__self__, "discriminator", discriminator) + pulumi.set(__self__, "pusher_email", pusher_email) + pulumi.set(__self__, "pusher_name", pusher_name) + pulumi.set(__self__, "ref", ref) + pulumi.set(__self__, "timestamp", timestamp) + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> _builtins.str: + return pulumi.get(self, "commit_id") + + @_builtins.property + @pulumi.getter(name="commitMessage") + def commit_message(self) -> _builtins.str: + return pulumi.get(self, "commit_message") + + @_builtins.property + @pulumi.getter + def discriminator(self) -> _builtins.str: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter(name="pusherEmail") + def pusher_email(self) -> _builtins.str: + return pulumi.get(self, "pusher_email") + + @_builtins.property + @pulumi.getter(name="pusherName") + def pusher_name(self) -> _builtins.str: + return pulumi.get(self, "pusher_name") + + @_builtins.property + @pulumi.getter + def ref(self) -> _builtins.str: + return pulumi.get(self, "ref") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> _builtins.str: + return pulumi.get(self, "timestamp") + + +@pulumi.output_type +class GetActionEventTowerResult(dict): + def __init__(__self__, *, + discriminator: _builtins.str, + timestamp: _builtins.str, + workflow_id: _builtins.str): + pulumi.set(__self__, "discriminator", discriminator) + pulumi.set(__self__, "timestamp", timestamp) + pulumi.set(__self__, "workflow_id", workflow_id) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> _builtins.str: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> _builtins.str: + return pulumi.get(self, "timestamp") + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> _builtins.str: + return pulumi.get(self, "workflow_id") + + +@pulumi.output_type +class GetActionLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchResult(dict): + def __init__(__self__, *, + compute_env: 'outputs.GetActionLaunchComputeEnvResult', + config_profiles: Sequence[_builtins.str], + config_text: _builtins.str, + date_created: _builtins.str, + entry_name: _builtins.str, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + id: _builtins.str, + last_updated: _builtins.str, + launch_container: _builtins.str, + main_script: _builtins.str, + optimization_id: _builtins.str, + optimization_targets: _builtins.str, + params_text: _builtins.str, + pipeline: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + pull_latest: _builtins.bool, + resume: _builtins.bool, + resume_launch_id: _builtins.str, + revision: _builtins.str, + run_name: _builtins.str, + schema_name: _builtins.str, + session_id: _builtins.str, + stub_run: _builtins.bool, + tower_config: _builtins.str, + user_secrets: Sequence[_builtins.str], + work_dir: _builtins.str, + workspace_secrets: Sequence[_builtins.str]): + """ + :param _builtins.str post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + :param _builtins.str pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pulumi.set(__self__, "compute_env", compute_env) + pulumi.set(__self__, "config_profiles", config_profiles) + pulumi.set(__self__, "config_text", config_text) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "entry_name", entry_name) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "launch_container", launch_container) + pulumi.set(__self__, "main_script", main_script) + pulumi.set(__self__, "optimization_id", optimization_id) + pulumi.set(__self__, "optimization_targets", optimization_targets) + pulumi.set(__self__, "params_text", params_text) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "pull_latest", pull_latest) + pulumi.set(__self__, "resume", resume) + pulumi.set(__self__, "resume_launch_id", resume_launch_id) + pulumi.set(__self__, "revision", revision) + pulumi.set(__self__, "run_name", run_name) + pulumi.set(__self__, "schema_name", schema_name) + pulumi.set(__self__, "session_id", session_id) + pulumi.set(__self__, "stub_run", stub_run) + pulumi.set(__self__, "tower_config", tower_config) + pulumi.set(__self__, "user_secrets", user_secrets) + pulumi.set(__self__, "work_dir", work_dir) + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> 'outputs.GetActionLaunchComputeEnvResult': + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "config_profiles") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> _builtins.str: + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> _builtins.str: + return pulumi.get(self, "entry_name") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> _builtins.str: + return pulumi.get(self, "launch_container") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> _builtins.str: + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> _builtins.str: + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> _builtins.str: + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> _builtins.str: + return pulumi.get(self, "params_text") + + @_builtins.property + @pulumi.getter + def pipeline(self) -> _builtins.str: + return pulumi.get(self, "pipeline") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> _builtins.bool: + return pulumi.get(self, "pull_latest") + + @_builtins.property + @pulumi.getter + def resume(self) -> _builtins.bool: + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter(name="resumeLaunchId") + def resume_launch_id(self) -> _builtins.str: + return pulumi.get(self, "resume_launch_id") + + @_builtins.property + @pulumi.getter + def revision(self) -> _builtins.str: + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> _builtins.str: + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> _builtins.str: + return pulumi.get(self, "schema_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> _builtins.str: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> _builtins.bool: + return pulumi.get(self, "stub_run") + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> _builtins.str: + return pulumi.get(self, "tower_config") + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "user_secrets") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "workspace_secrets") + + +@pulumi.output_type +class GetActionLaunchComputeEnvResult(dict): + def __init__(__self__, *, + compute_env_id: _builtins.str, + config: 'outputs.GetActionLaunchComputeEnvConfigResult', + credentials_id: _builtins.str, + date_created: _builtins.str, + deleted: _builtins.bool, + description: _builtins.str, + last_updated: _builtins.str, + last_used: _builtins.str, + message: _builtins.str, + name: _builtins.str, + org_id: _builtins.float, + platform: _builtins.str, + primary: _builtins.bool, + status: _builtins.str, + workspace_id: _builtins.float): + """ + :param 'GetActionLaunchComputeEnvConfigArgs' config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "deleted", deleted) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "last_used", last_used) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "org_id", org_id) + pulumi.set(__self__, "platform", platform) + pulumi.set(__self__, "primary", primary) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def config(self) -> 'outputs.GetActionLaunchComputeEnvConfigResult': + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def primary(self) -> _builtins.bool: + return pulumi.get(self, "primary") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigResult(dict): + def __init__(__self__, *, + altair_platform: 'outputs.GetActionLaunchComputeEnvConfigAltairPlatformResult', + aws_batch: 'outputs.GetActionLaunchComputeEnvConfigAwsBatchResult', + aws_cloud: 'outputs.GetActionLaunchComputeEnvConfigAwsCloudResult', + azure_batch: 'outputs.GetActionLaunchComputeEnvConfigAzureBatchResult', + eks_platform: 'outputs.GetActionLaunchComputeEnvConfigEksPlatformResult', + gke_platform: 'outputs.GetActionLaunchComputeEnvConfigGkePlatformResult', + google_batch: 'outputs.GetActionLaunchComputeEnvConfigGoogleBatchResult', + google_lifesciences: 'outputs.GetActionLaunchComputeEnvConfigGoogleLifesciencesResult', + k8s_platform: 'outputs.GetActionLaunchComputeEnvConfigK8sPlatformResult', + lsf_platform: 'outputs.GetActionLaunchComputeEnvConfigLsfPlatformResult', + moab_platform: 'outputs.GetActionLaunchComputeEnvConfigMoabPlatformResult', + seqeracompute_platform: 'outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformResult', + slurm_platform: 'outputs.GetActionLaunchComputeEnvConfigSlurmPlatformResult', + uge_platform: 'outputs.GetActionLaunchComputeEnvConfigUgePlatformResult'): + pulumi.set(__self__, "altair_platform", altair_platform) + pulumi.set(__self__, "aws_batch", aws_batch) + pulumi.set(__self__, "aws_cloud", aws_cloud) + pulumi.set(__self__, "azure_batch", azure_batch) + pulumi.set(__self__, "eks_platform", eks_platform) + pulumi.set(__self__, "gke_platform", gke_platform) + pulumi.set(__self__, "google_batch", google_batch) + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + pulumi.set(__self__, "k8s_platform", k8s_platform) + pulumi.set(__self__, "lsf_platform", lsf_platform) + pulumi.set(__self__, "moab_platform", moab_platform) + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + pulumi.set(__self__, "slurm_platform", slurm_platform) + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigAltairPlatformResult': + return pulumi.get(self, "altair_platform") + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> 'outputs.GetActionLaunchComputeEnvConfigAwsBatchResult': + return pulumi.get(self, "aws_batch") + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> 'outputs.GetActionLaunchComputeEnvConfigAwsCloudResult': + return pulumi.get(self, "aws_cloud") + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> 'outputs.GetActionLaunchComputeEnvConfigAzureBatchResult': + return pulumi.get(self, "azure_batch") + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigEksPlatformResult': + return pulumi.get(self, "eks_platform") + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigGkePlatformResult': + return pulumi.get(self, "gke_platform") + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> 'outputs.GetActionLaunchComputeEnvConfigGoogleBatchResult': + return pulumi.get(self, "google_batch") + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> 'outputs.GetActionLaunchComputeEnvConfigGoogleLifesciencesResult': + return pulumi.get(self, "google_lifesciences") + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigK8sPlatformResult': + return pulumi.get(self, "k8s_platform") + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigLsfPlatformResult': + return pulumi.get(self, "lsf_platform") + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigMoabPlatformResult': + return pulumi.get(self, "moab_platform") + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformResult': + return pulumi.get(self, "seqeracompute_platform") + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigSlurmPlatformResult': + return pulumi.get(self, "slurm_platform") + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigUgePlatformResult': + return pulumi.get(self, "uge_platform") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAltairPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsBatchResult(dict): + def __init__(__self__, *, + cli_path: _builtins.str, + compute_job_role: _builtins.str, + compute_queue: _builtins.str, + dragen_instance_type: _builtins.str, + dragen_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigAwsBatchEnvironmentResult'], + execution_role: _builtins.str, + forge: 'outputs.GetActionLaunchComputeEnvConfigAwsBatchForgeResult', + fusion2_enabled: _builtins.bool, + fusion_snapshots: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_job_role: _builtins.str, + head_queue: _builtins.str, + log_group: _builtins.str, + lustre_id: _builtins.str, + nextflow_config: _builtins.str, + nvnme_storage_enabled: _builtins.bool, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + storage_type: _builtins.str, + volumes: Sequence[_builtins.str], + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cli_path", cli_path) + pulumi.set(__self__, "compute_job_role", compute_job_role) + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "dragen_queue", dragen_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "execution_role", execution_role) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_job_role", head_job_role) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "lustre_id", lustre_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "storage_type", storage_type) + pulumi.set(__self__, "volumes", volumes) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> _builtins.str: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> _builtins.str: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> _builtins.str: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigAwsBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> _builtins.str: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetActionLaunchComputeEnvConfigAwsBatchForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> _builtins.bool: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> _builtins.str: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> _builtins.str: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> _builtins.bool: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> _builtins.str: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsBatchForgeResult(dict): + def __init__(__self__, *, + alloc_strategy: _builtins.str, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + bid_percentage: _builtins.float, + dispose_on_deletion: _builtins.bool, + dragen_ami_id: _builtins.str, + dragen_enabled: _builtins.bool, + dragen_instance_type: _builtins.str, + ebs_auto_scale: _builtins.bool, + ebs_block_size: _builtins.float, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + ecs_config: _builtins.str, + efs_create: _builtins.bool, + efs_id: _builtins.str, + efs_mount: _builtins.str, + fargate_head_enabled: _builtins.bool, + fsx_mount: _builtins.str, + fsx_name: _builtins.str, + fsx_size: _builtins.float, + fusion_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_types: Sequence[_builtins.str], + max_cpus: _builtins.float, + min_cpus: _builtins.float, + security_groups: Sequence[_builtins.str], + subnets: Sequence[_builtins.str], + type: _builtins.str, + vpc_id: _builtins.str): + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "bid_percentage", bid_percentage) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "ecs_config", ecs_config) + pulumi.set(__self__, "efs_create", efs_create) + pulumi.set(__self__, "efs_id", efs_id) + pulumi.set(__self__, "efs_mount", efs_mount) + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + pulumi.set(__self__, "fsx_mount", fsx_mount) + pulumi.set(__self__, "fsx_name", fsx_name) + pulumi.set(__self__, "fsx_size", fsx_size) + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_types", instance_types) + pulumi.set(__self__, "max_cpus", max_cpus) + pulumi.set(__self__, "min_cpus", min_cpus) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnets", subnets) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> _builtins.str: + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> _builtins.float: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> _builtins.str: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> _builtins.bool: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> _builtins.str: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> _builtins.bool: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> _builtins.str: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> _builtins.str: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> _builtins.str: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> _builtins.str: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> _builtins.float: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> _builtins.float: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> _builtins.float: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> _builtins.str: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsCloudResult(dict): + def __init__(__self__, *, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigAwsCloudEnvironmentResult'], + fusion2_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_profile_arn: _builtins.str, + instance_type: _builtins.str, + log_group: _builtins.str, + nextflow_config: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + security_groups: Sequence[_builtins.str], + subnet_id: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + pulumi.set(__self__, "instance_type", instance_type) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnet_id", subnet_id) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigAwsCloudEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> _builtins.str: + return pulumi.get(self, "instance_profile_arn") + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> _builtins.str: + return pulumi.get(self, "instance_type") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> _builtins.str: + return pulumi.get(self, "subnet_id") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsCloudEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAzureBatchResult(dict): + def __init__(__self__, *, + auto_pool_mode: _builtins.bool, + delete_jobs_on_completion: _builtins.str, + delete_pools_on_completion: _builtins.bool, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigAzureBatchEnvironmentResult'], + forge: 'outputs.GetActionLaunchComputeEnvConfigAzureBatchForgeResult', + fusion2_enabled: _builtins.bool, + head_pool: _builtins.str, + managed_identity_client_id: _builtins.str, + nextflow_config: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + token_duration: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_pool", head_pool) + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "token_duration", token_duration) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> _builtins.bool: + return pulumi.get(self, "auto_pool_mode") + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> _builtins.str: + return pulumi.get(self, "delete_jobs_on_completion") + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> _builtins.bool: + return pulumi.get(self, "delete_pools_on_completion") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigAzureBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetActionLaunchComputeEnvConfigAzureBatchForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> _builtins.str: + return pulumi.get(self, "head_pool") + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> _builtins.str: + return pulumi.get(self, "managed_identity_client_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> _builtins.str: + return pulumi.get(self, "token_duration") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAzureBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAzureBatchForgeResult(dict): + def __init__(__self__, *, + auto_scale: _builtins.bool, + container_reg_ids: Sequence[_builtins.str], + dispose_on_deletion: _builtins.bool, + vm_count: _builtins.float, + vm_type: _builtins.str): + pulumi.set(__self__, "auto_scale", auto_scale) + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "vm_count", vm_count) + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "auto_scale") + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "container_reg_ids") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> _builtins.float: + return pulumi.get(self, "vm_count") + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> _builtins.str: + return pulumi.get(self, "vm_type") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigEksPlatformResult(dict): + def __init__(__self__, *, + cluster_name: _builtins.str, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigEksPlatformEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param _builtins.str cluster_name: The AWS EKS cluster name + :param Sequence['GetActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: AWS region + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> _builtins.str: + """ + The AWS EKS cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigEksPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + AWS region + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigEksPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGkePlatformResult(dict): + def __init__(__self__, *, + cluster_name: _builtins.str, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigGkePlatformEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param _builtins.str cluster_name: The GKE cluster name + :param Sequence['GetActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: The GKE cluster region - or - zone + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> _builtins.str: + """ + The GKE cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigGkePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + The GKE cluster region - or - zone + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGkePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGoogleBatchResult(dict): + def __init__(__self__, *, + boot_disk_size_gb: _builtins.float, + compute_jobs_instance_template: _builtins.str, + copy_image: _builtins.str, + cpu_platform: _builtins.str, + debug_mode: _builtins.float, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_instance_template: _builtins.str, + head_job_memory_mb: _builtins.float, + labels: Mapping[str, _builtins.str], + location: _builtins.str, + machine_type: _builtins.str, + network: _builtins.str, + nextflow_config: _builtins.str, + nfs_mount: _builtins.str, + nfs_target: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + project_id: _builtins.str, + service_account: _builtins.str, + spot: _builtins.bool, + ssh_daemon: _builtins.bool, + ssh_image: _builtins.str, + subnetwork: _builtins.str, + use_private_address: _builtins.bool, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + pulumi.set(__self__, "copy_image", copy_image) + pulumi.set(__self__, "cpu_platform", cpu_platform) + pulumi.set(__self__, "debug_mode", debug_mode) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "location", location) + pulumi.set(__self__, "machine_type", machine_type) + pulumi.set(__self__, "network", network) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nfs_mount", nfs_mount) + pulumi.set(__self__, "nfs_target", nfs_target) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "service_account", service_account) + pulumi.set(__self__, "spot", spot) + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + pulumi.set(__self__, "ssh_image", ssh_image) + pulumi.set(__self__, "subnetwork", subnetwork) + pulumi.set(__self__, "use_private_address", use_private_address) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> _builtins.float: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> _builtins.str: + return pulumi.get(self, "compute_jobs_instance_template") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> _builtins.str: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> _builtins.str: + return pulumi.get(self, "cpu_platform") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> _builtins.float: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> _builtins.str: + return pulumi.get(self, "head_job_instance_template") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> _builtins.str: + return pulumi.get(self, "machine_type") + + @_builtins.property + @pulumi.getter + def network(self) -> _builtins.str: + return pulumi.get(self, "network") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> _builtins.str: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> _builtins.str: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> _builtins.str: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> _builtins.str: + return pulumi.get(self, "service_account") + + @_builtins.property + @pulumi.getter + def spot(self) -> _builtins.bool: + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> _builtins.bool: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> _builtins.str: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> _builtins.str: + return pulumi.get(self, "subnetwork") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> _builtins.bool: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGoogleLifesciencesResult(dict): + def __init__(__self__, *, + boot_disk_size_gb: _builtins.float, + copy_image: _builtins.str, + debug_mode: _builtins.float, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentResult'], + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + labels: Mapping[str, _builtins.str], + location: _builtins.str, + nextflow_config: _builtins.str, + nfs_mount: _builtins.str, + nfs_target: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + preemptible: _builtins.bool, + project_id: _builtins.str, + region: _builtins.str, + ssh_daemon: _builtins.bool, + ssh_image: _builtins.str, + use_private_address: _builtins.bool, + work_dir: _builtins.str, + zones: Sequence[_builtins.str]): + """ + :param Sequence['GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + pulumi.set(__self__, "copy_image", copy_image) + pulumi.set(__self__, "debug_mode", debug_mode) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "location", location) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nfs_mount", nfs_mount) + pulumi.set(__self__, "nfs_target", nfs_target) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "preemptible", preemptible) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + pulumi.set(__self__, "ssh_image", ssh_image) + pulumi.set(__self__, "use_private_address", use_private_address) + pulumi.set(__self__, "work_dir", work_dir) + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> _builtins.float: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> _builtins.str: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> _builtins.float: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> _builtins.str: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> _builtins.str: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def preemptible(self) -> _builtins.bool: + return pulumi.get(self, "preemptible") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> _builtins.str: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> _builtins.bool: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> _builtins.str: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> _builtins.bool: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def zones(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "zones") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigK8sPlatformResult(dict): + def __init__(__self__, *, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentResult'], + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigLsfPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + per_job_mem_limit: _builtins.bool, + per_task_reserve: _builtins.bool, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + unit_for_limits: _builtins.str, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> _builtins.bool: + return pulumi.get(self, "per_job_mem_limit") + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> _builtins.bool: + return pulumi.get(self, "per_task_reserve") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> _builtins.str: + return pulumi.get(self, "unit_for_limits") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigMoabPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSeqeracomputePlatformResult(dict): + def __init__(__self__, *, + cli_path: _builtins.str, + compute_job_role: _builtins.str, + compute_queue: _builtins.str, + dragen_instance_type: _builtins.str, + dragen_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentResult'], + execution_role: _builtins.str, + forge: 'outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformForgeResult', + fusion2_enabled: _builtins.bool, + fusion_snapshots: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_job_role: _builtins.str, + head_queue: _builtins.str, + log_group: _builtins.str, + lustre_id: _builtins.str, + nextflow_config: _builtins.str, + nvnme_storage_enabled: _builtins.bool, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + storage_type: _builtins.str, + volumes: Sequence[_builtins.str], + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cli_path", cli_path) + pulumi.set(__self__, "compute_job_role", compute_job_role) + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "dragen_queue", dragen_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "execution_role", execution_role) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_job_role", head_job_role) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "lustre_id", lustre_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "storage_type", storage_type) + pulumi.set(__self__, "volumes", volumes) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> _builtins.str: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> _builtins.str: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> _builtins.str: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> _builtins.str: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> _builtins.bool: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> _builtins.str: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> _builtins.str: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> _builtins.bool: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> _builtins.str: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSeqeracomputePlatformForgeResult(dict): + def __init__(__self__, *, + alloc_strategy: _builtins.str, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + bid_percentage: _builtins.float, + dispose_on_deletion: _builtins.bool, + dragen_ami_id: _builtins.str, + dragen_enabled: _builtins.bool, + dragen_instance_type: _builtins.str, + ebs_auto_scale: _builtins.bool, + ebs_block_size: _builtins.float, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + ecs_config: _builtins.str, + efs_create: _builtins.bool, + efs_id: _builtins.str, + efs_mount: _builtins.str, + fargate_head_enabled: _builtins.bool, + fsx_mount: _builtins.str, + fsx_name: _builtins.str, + fsx_size: _builtins.float, + fusion_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_types: Sequence[_builtins.str], + max_cpus: _builtins.float, + min_cpus: _builtins.float, + security_groups: Sequence[_builtins.str], + subnets: Sequence[_builtins.str], + type: _builtins.str, + vpc_id: _builtins.str): + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "bid_percentage", bid_percentage) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "ecs_config", ecs_config) + pulumi.set(__self__, "efs_create", efs_create) + pulumi.set(__self__, "efs_id", efs_id) + pulumi.set(__self__, "efs_mount", efs_mount) + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + pulumi.set(__self__, "fsx_mount", fsx_mount) + pulumi.set(__self__, "fsx_name", fsx_name) + pulumi.set(__self__, "fsx_size", fsx_size) + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_types", instance_types) + pulumi.set(__self__, "max_cpus", max_cpus) + pulumi.set(__self__, "min_cpus", min_cpus) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnets", subnets) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> _builtins.str: + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> _builtins.float: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> _builtins.str: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> _builtins.bool: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> _builtins.str: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> _builtins.bool: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> _builtins.str: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> _builtins.str: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> _builtins.str: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> _builtins.str: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> _builtins.float: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> _builtins.float: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> _builtins.float: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> _builtins.str: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSlurmPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigUgePlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigUgePlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigUgePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigUgePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvResult(dict): + def __init__(__self__, *, + compute_env_id: _builtins.str, + config: 'outputs.GetComputeEnvComputeEnvConfigResult', + credentials_id: _builtins.str, + date_created: _builtins.str, + deleted: _builtins.bool, + description: _builtins.str, + labels: Sequence['outputs.GetComputeEnvComputeEnvLabelResult'], + last_updated: _builtins.str, + last_used: _builtins.str, + managed_identity_id: _builtins.str, + message: _builtins.str, + name: _builtins.str, + org_id: _builtins.float, + platform: _builtins.str, + primary: _builtins.bool, + status: _builtins.str, + workspace_id: _builtins.float): + """ + :param 'GetComputeEnvComputeEnvConfigArgs' config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "deleted", deleted) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "last_used", last_used) + pulumi.set(__self__, "managed_identity_id", managed_identity_id) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "org_id", org_id) + pulumi.set(__self__, "platform", platform) + pulumi.set(__self__, "primary", primary) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def config(self) -> 'outputs.GetComputeEnvComputeEnvConfigResult': + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetComputeEnvComputeEnvLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter(name="managedIdentityId") + def managed_identity_id(self) -> _builtins.str: + return pulumi.get(self, "managed_identity_id") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def primary(self) -> _builtins.bool: + return pulumi.get(self, "primary") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigResult(dict): + def __init__(__self__, *, + altair_platform: 'outputs.GetComputeEnvComputeEnvConfigAltairPlatformResult', + aws_batch: 'outputs.GetComputeEnvComputeEnvConfigAwsBatchResult', + aws_cloud: 'outputs.GetComputeEnvComputeEnvConfigAwsCloudResult', + azure_batch: 'outputs.GetComputeEnvComputeEnvConfigAzureBatchResult', + eks_platform: 'outputs.GetComputeEnvComputeEnvConfigEksPlatformResult', + gke_platform: 'outputs.GetComputeEnvComputeEnvConfigGkePlatformResult', + google_batch: 'outputs.GetComputeEnvComputeEnvConfigGoogleBatchResult', + google_lifesciences: 'outputs.GetComputeEnvComputeEnvConfigGoogleLifesciencesResult', + k8s_platform: 'outputs.GetComputeEnvComputeEnvConfigK8sPlatformResult', + lsf_platform: 'outputs.GetComputeEnvComputeEnvConfigLsfPlatformResult', + moab_platform: 'outputs.GetComputeEnvComputeEnvConfigMoabPlatformResult', + seqeracompute_platform: 'outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformResult', + slurm_platform: 'outputs.GetComputeEnvComputeEnvConfigSlurmPlatformResult', + uge_platform: 'outputs.GetComputeEnvComputeEnvConfigUgePlatformResult'): + pulumi.set(__self__, "altair_platform", altair_platform) + pulumi.set(__self__, "aws_batch", aws_batch) + pulumi.set(__self__, "aws_cloud", aws_cloud) + pulumi.set(__self__, "azure_batch", azure_batch) + pulumi.set(__self__, "eks_platform", eks_platform) + pulumi.set(__self__, "gke_platform", gke_platform) + pulumi.set(__self__, "google_batch", google_batch) + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + pulumi.set(__self__, "k8s_platform", k8s_platform) + pulumi.set(__self__, "lsf_platform", lsf_platform) + pulumi.set(__self__, "moab_platform", moab_platform) + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + pulumi.set(__self__, "slurm_platform", slurm_platform) + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigAltairPlatformResult': + return pulumi.get(self, "altair_platform") + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> 'outputs.GetComputeEnvComputeEnvConfigAwsBatchResult': + return pulumi.get(self, "aws_batch") + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> 'outputs.GetComputeEnvComputeEnvConfigAwsCloudResult': + return pulumi.get(self, "aws_cloud") + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> 'outputs.GetComputeEnvComputeEnvConfigAzureBatchResult': + return pulumi.get(self, "azure_batch") + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigEksPlatformResult': + return pulumi.get(self, "eks_platform") + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigGkePlatformResult': + return pulumi.get(self, "gke_platform") + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> 'outputs.GetComputeEnvComputeEnvConfigGoogleBatchResult': + return pulumi.get(self, "google_batch") + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> 'outputs.GetComputeEnvComputeEnvConfigGoogleLifesciencesResult': + return pulumi.get(self, "google_lifesciences") + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigK8sPlatformResult': + return pulumi.get(self, "k8s_platform") + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigLsfPlatformResult': + return pulumi.get(self, "lsf_platform") + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigMoabPlatformResult': + return pulumi.get(self, "moab_platform") + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformResult': + return pulumi.get(self, "seqeracompute_platform") + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigSlurmPlatformResult': + return pulumi.get(self, "slurm_platform") + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigUgePlatformResult': + return pulumi.get(self, "uge_platform") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAltairPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsBatchResult(dict): + def __init__(__self__, *, + cli_path: _builtins.str, + compute_job_role: _builtins.str, + compute_queue: _builtins.str, + dragen_instance_type: _builtins.str, + dragen_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigAwsBatchEnvironmentResult'], + execution_role: _builtins.str, + forge: 'outputs.GetComputeEnvComputeEnvConfigAwsBatchForgeResult', + fusion2_enabled: _builtins.bool, + fusion_snapshots: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_job_role: _builtins.str, + head_queue: _builtins.str, + log_group: _builtins.str, + lustre_id: _builtins.str, + nextflow_config: _builtins.str, + nvnme_storage_enabled: _builtins.bool, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + storage_type: _builtins.str, + volumes: Sequence[_builtins.str], + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cli_path", cli_path) + pulumi.set(__self__, "compute_job_role", compute_job_role) + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "dragen_queue", dragen_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "execution_role", execution_role) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_job_role", head_job_role) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "lustre_id", lustre_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "storage_type", storage_type) + pulumi.set(__self__, "volumes", volumes) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> _builtins.str: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> _builtins.str: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> _builtins.str: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigAwsBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> _builtins.str: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetComputeEnvComputeEnvConfigAwsBatchForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> _builtins.bool: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> _builtins.str: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> _builtins.str: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> _builtins.bool: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> _builtins.str: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsBatchForgeResult(dict): + def __init__(__self__, *, + alloc_strategy: _builtins.str, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + bid_percentage: _builtins.float, + dispose_on_deletion: _builtins.bool, + dragen_ami_id: _builtins.str, + dragen_enabled: _builtins.bool, + dragen_instance_type: _builtins.str, + ebs_auto_scale: _builtins.bool, + ebs_block_size: _builtins.float, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + ecs_config: _builtins.str, + efs_create: _builtins.bool, + efs_id: _builtins.str, + efs_mount: _builtins.str, + fargate_head_enabled: _builtins.bool, + fsx_mount: _builtins.str, + fsx_name: _builtins.str, + fsx_size: _builtins.float, + fusion_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_types: Sequence[_builtins.str], + max_cpus: _builtins.float, + min_cpus: _builtins.float, + security_groups: Sequence[_builtins.str], + subnets: Sequence[_builtins.str], + type: _builtins.str, + vpc_id: _builtins.str): + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "bid_percentage", bid_percentage) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "ecs_config", ecs_config) + pulumi.set(__self__, "efs_create", efs_create) + pulumi.set(__self__, "efs_id", efs_id) + pulumi.set(__self__, "efs_mount", efs_mount) + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + pulumi.set(__self__, "fsx_mount", fsx_mount) + pulumi.set(__self__, "fsx_name", fsx_name) + pulumi.set(__self__, "fsx_size", fsx_size) + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_types", instance_types) + pulumi.set(__self__, "max_cpus", max_cpus) + pulumi.set(__self__, "min_cpus", min_cpus) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnets", subnets) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> _builtins.str: + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> _builtins.float: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> _builtins.str: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> _builtins.bool: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> _builtins.str: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> _builtins.bool: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> _builtins.str: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> _builtins.str: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> _builtins.str: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> _builtins.str: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> _builtins.float: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> _builtins.float: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> _builtins.float: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> _builtins.str: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsCloudResult(dict): + def __init__(__self__, *, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigAwsCloudEnvironmentResult'], + fusion2_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_profile_arn: _builtins.str, + instance_type: _builtins.str, + log_group: _builtins.str, + nextflow_config: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + security_groups: Sequence[_builtins.str], + subnet_id: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + pulumi.set(__self__, "instance_type", instance_type) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnet_id", subnet_id) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigAwsCloudEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> _builtins.str: + return pulumi.get(self, "instance_profile_arn") + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> _builtins.str: + return pulumi.get(self, "instance_type") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> _builtins.str: + return pulumi.get(self, "subnet_id") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsCloudEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAzureBatchResult(dict): + def __init__(__self__, *, + auto_pool_mode: _builtins.bool, + delete_jobs_on_completion: _builtins.str, + delete_pools_on_completion: _builtins.bool, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigAzureBatchEnvironmentResult'], + forge: 'outputs.GetComputeEnvComputeEnvConfigAzureBatchForgeResult', + fusion2_enabled: _builtins.bool, + head_pool: _builtins.str, + managed_identity_client_id: _builtins.str, + nextflow_config: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + token_duration: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_pool", head_pool) + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "token_duration", token_duration) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> _builtins.bool: + return pulumi.get(self, "auto_pool_mode") + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> _builtins.str: + return pulumi.get(self, "delete_jobs_on_completion") + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> _builtins.bool: + return pulumi.get(self, "delete_pools_on_completion") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigAzureBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetComputeEnvComputeEnvConfigAzureBatchForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> _builtins.str: + return pulumi.get(self, "head_pool") + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> _builtins.str: + return pulumi.get(self, "managed_identity_client_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> _builtins.str: + return pulumi.get(self, "token_duration") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAzureBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAzureBatchForgeResult(dict): + def __init__(__self__, *, + auto_scale: _builtins.bool, + container_reg_ids: Sequence[_builtins.str], + dispose_on_deletion: _builtins.bool, + vm_count: _builtins.float, + vm_type: _builtins.str): + pulumi.set(__self__, "auto_scale", auto_scale) + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "vm_count", vm_count) + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "auto_scale") + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "container_reg_ids") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> _builtins.float: + return pulumi.get(self, "vm_count") + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> _builtins.str: + return pulumi.get(self, "vm_type") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigEksPlatformResult(dict): + def __init__(__self__, *, + cluster_name: _builtins.str, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigEksPlatformEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param _builtins.str cluster_name: The AWS EKS cluster name + :param Sequence['GetComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: AWS region + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> _builtins.str: + """ + The AWS EKS cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigEksPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + AWS region + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigEksPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGkePlatformResult(dict): + def __init__(__self__, *, + cluster_name: _builtins.str, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigGkePlatformEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param _builtins.str cluster_name: The GKE cluster name + :param Sequence['GetComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: The GKE cluster region - or - zone + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> _builtins.str: + """ + The GKE cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigGkePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + The GKE cluster region - or - zone + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGkePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGoogleBatchResult(dict): + def __init__(__self__, *, + boot_disk_size_gb: _builtins.float, + compute_jobs_instance_template: _builtins.str, + copy_image: _builtins.str, + cpu_platform: _builtins.str, + debug_mode: _builtins.float, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_instance_template: _builtins.str, + head_job_memory_mb: _builtins.float, + labels: Mapping[str, _builtins.str], + location: _builtins.str, + machine_type: _builtins.str, + network: _builtins.str, + nextflow_config: _builtins.str, + nfs_mount: _builtins.str, + nfs_target: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + project_id: _builtins.str, + service_account: _builtins.str, + spot: _builtins.bool, + ssh_daemon: _builtins.bool, + ssh_image: _builtins.str, + subnetwork: _builtins.str, + use_private_address: _builtins.bool, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + pulumi.set(__self__, "copy_image", copy_image) + pulumi.set(__self__, "cpu_platform", cpu_platform) + pulumi.set(__self__, "debug_mode", debug_mode) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "location", location) + pulumi.set(__self__, "machine_type", machine_type) + pulumi.set(__self__, "network", network) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nfs_mount", nfs_mount) + pulumi.set(__self__, "nfs_target", nfs_target) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "service_account", service_account) + pulumi.set(__self__, "spot", spot) + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + pulumi.set(__self__, "ssh_image", ssh_image) + pulumi.set(__self__, "subnetwork", subnetwork) + pulumi.set(__self__, "use_private_address", use_private_address) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> _builtins.float: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> _builtins.str: + return pulumi.get(self, "compute_jobs_instance_template") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> _builtins.str: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> _builtins.str: + return pulumi.get(self, "cpu_platform") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> _builtins.float: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> _builtins.str: + return pulumi.get(self, "head_job_instance_template") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> _builtins.str: + return pulumi.get(self, "machine_type") + + @_builtins.property + @pulumi.getter + def network(self) -> _builtins.str: + return pulumi.get(self, "network") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> _builtins.str: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> _builtins.str: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> _builtins.str: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> _builtins.str: + return pulumi.get(self, "service_account") + + @_builtins.property + @pulumi.getter + def spot(self) -> _builtins.bool: + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> _builtins.bool: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> _builtins.str: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> _builtins.str: + return pulumi.get(self, "subnetwork") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> _builtins.bool: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGoogleLifesciencesResult(dict): + def __init__(__self__, *, + boot_disk_size_gb: _builtins.float, + copy_image: _builtins.str, + debug_mode: _builtins.float, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentResult'], + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + labels: Mapping[str, _builtins.str], + location: _builtins.str, + nextflow_config: _builtins.str, + nfs_mount: _builtins.str, + nfs_target: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + preemptible: _builtins.bool, + project_id: _builtins.str, + region: _builtins.str, + ssh_daemon: _builtins.bool, + ssh_image: _builtins.str, + use_private_address: _builtins.bool, + work_dir: _builtins.str, + zones: Sequence[_builtins.str]): + """ + :param Sequence['GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + pulumi.set(__self__, "copy_image", copy_image) + pulumi.set(__self__, "debug_mode", debug_mode) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "location", location) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nfs_mount", nfs_mount) + pulumi.set(__self__, "nfs_target", nfs_target) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "preemptible", preemptible) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + pulumi.set(__self__, "ssh_image", ssh_image) + pulumi.set(__self__, "use_private_address", use_private_address) + pulumi.set(__self__, "work_dir", work_dir) + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> _builtins.float: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> _builtins.str: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> _builtins.float: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> _builtins.str: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> _builtins.str: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def preemptible(self) -> _builtins.bool: + return pulumi.get(self, "preemptible") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> _builtins.str: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> _builtins.bool: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> _builtins.str: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> _builtins.bool: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def zones(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "zones") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigK8sPlatformResult(dict): + def __init__(__self__, *, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentResult'], + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigLsfPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + per_job_mem_limit: _builtins.bool, + per_task_reserve: _builtins.bool, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + unit_for_limits: _builtins.str, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> _builtins.bool: + return pulumi.get(self, "per_job_mem_limit") + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> _builtins.bool: + return pulumi.get(self, "per_task_reserve") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> _builtins.str: + return pulumi.get(self, "unit_for_limits") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigMoabPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSeqeracomputePlatformResult(dict): + def __init__(__self__, *, + cli_path: _builtins.str, + compute_job_role: _builtins.str, + compute_queue: _builtins.str, + dragen_instance_type: _builtins.str, + dragen_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentResult'], + execution_role: _builtins.str, + forge: 'outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformForgeResult', + fusion2_enabled: _builtins.bool, + fusion_snapshots: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_job_role: _builtins.str, + head_queue: _builtins.str, + log_group: _builtins.str, + lustre_id: _builtins.str, + nextflow_config: _builtins.str, + nvnme_storage_enabled: _builtins.bool, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + storage_type: _builtins.str, + volumes: Sequence[_builtins.str], + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cli_path", cli_path) + pulumi.set(__self__, "compute_job_role", compute_job_role) + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "dragen_queue", dragen_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "execution_role", execution_role) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_job_role", head_job_role) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "lustre_id", lustre_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "storage_type", storage_type) + pulumi.set(__self__, "volumes", volumes) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> _builtins.str: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> _builtins.str: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> _builtins.str: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> _builtins.str: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> _builtins.bool: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> _builtins.str: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> _builtins.str: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> _builtins.bool: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> _builtins.str: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSeqeracomputePlatformForgeResult(dict): + def __init__(__self__, *, + alloc_strategy: _builtins.str, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + bid_percentage: _builtins.float, + dispose_on_deletion: _builtins.bool, + dragen_ami_id: _builtins.str, + dragen_enabled: _builtins.bool, + dragen_instance_type: _builtins.str, + ebs_auto_scale: _builtins.bool, + ebs_block_size: _builtins.float, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + ecs_config: _builtins.str, + efs_create: _builtins.bool, + efs_id: _builtins.str, + efs_mount: _builtins.str, + fargate_head_enabled: _builtins.bool, + fsx_mount: _builtins.str, + fsx_name: _builtins.str, + fsx_size: _builtins.float, + fusion_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_types: Sequence[_builtins.str], + max_cpus: _builtins.float, + min_cpus: _builtins.float, + security_groups: Sequence[_builtins.str], + subnets: Sequence[_builtins.str], + type: _builtins.str, + vpc_id: _builtins.str): + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "bid_percentage", bid_percentage) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "ecs_config", ecs_config) + pulumi.set(__self__, "efs_create", efs_create) + pulumi.set(__self__, "efs_id", efs_id) + pulumi.set(__self__, "efs_mount", efs_mount) + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + pulumi.set(__self__, "fsx_mount", fsx_mount) + pulumi.set(__self__, "fsx_name", fsx_name) + pulumi.set(__self__, "fsx_size", fsx_size) + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_types", instance_types) + pulumi.set(__self__, "max_cpus", max_cpus) + pulumi.set(__self__, "min_cpus", min_cpus) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnets", subnets) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> _builtins.str: + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> _builtins.float: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> _builtins.str: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> _builtins.bool: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> _builtins.str: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> _builtins.bool: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> _builtins.str: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> _builtins.str: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> _builtins.str: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> _builtins.str: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> _builtins.float: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> _builtins.float: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> _builtins.float: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> _builtins.str: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSlurmPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigUgePlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigUgePlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigUgePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigUgePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetCredentialKeysResult(dict): + def __init__(__self__, *, + aws: 'outputs.GetCredentialKeysAwsResult', + azure: 'outputs.GetCredentialKeysAzureResult', + azure_entra: 'outputs.GetCredentialKeysAzureEntraResult', + azurerepos: 'outputs.GetCredentialKeysAzurereposResult', + bitbucket: 'outputs.GetCredentialKeysBitbucketResult', + codecommit: 'outputs.GetCredentialKeysCodecommitResult', + container_reg: 'outputs.GetCredentialKeysContainerRegResult', + gitea: 'outputs.GetCredentialKeysGiteaResult', + github: 'outputs.GetCredentialKeysGithubResult', + gitlab: 'outputs.GetCredentialKeysGitlabResult', + google: 'outputs.GetCredentialKeysGoogleResult', + k8s: 'outputs.GetCredentialKeysK8sResult', + seqeracompute: 'outputs.GetCredentialKeysSeqeracomputeResult', + ssh: 'outputs.GetCredentialKeysSshResult', + tw_agent: 'outputs.GetCredentialKeysTwAgentResult'): + pulumi.set(__self__, "aws", aws) + pulumi.set(__self__, "azure", azure) + pulumi.set(__self__, "azure_entra", azure_entra) + pulumi.set(__self__, "azurerepos", azurerepos) + pulumi.set(__self__, "bitbucket", bitbucket) + pulumi.set(__self__, "codecommit", codecommit) + pulumi.set(__self__, "container_reg", container_reg) + pulumi.set(__self__, "gitea", gitea) + pulumi.set(__self__, "github", github) + pulumi.set(__self__, "gitlab", gitlab) + pulumi.set(__self__, "google", google) + pulumi.set(__self__, "k8s", k8s) + pulumi.set(__self__, "seqeracompute", seqeracompute) + pulumi.set(__self__, "ssh", ssh) + pulumi.set(__self__, "tw_agent", tw_agent) + + @_builtins.property + @pulumi.getter + def aws(self) -> 'outputs.GetCredentialKeysAwsResult': + return pulumi.get(self, "aws") + + @_builtins.property + @pulumi.getter + def azure(self) -> 'outputs.GetCredentialKeysAzureResult': + return pulumi.get(self, "azure") + + @_builtins.property + @pulumi.getter(name="azureEntra") + def azure_entra(self) -> 'outputs.GetCredentialKeysAzureEntraResult': + return pulumi.get(self, "azure_entra") + + @_builtins.property + @pulumi.getter + def azurerepos(self) -> 'outputs.GetCredentialKeysAzurereposResult': + return pulumi.get(self, "azurerepos") + + @_builtins.property + @pulumi.getter + def bitbucket(self) -> 'outputs.GetCredentialKeysBitbucketResult': + return pulumi.get(self, "bitbucket") + + @_builtins.property + @pulumi.getter + def codecommit(self) -> 'outputs.GetCredentialKeysCodecommitResult': + return pulumi.get(self, "codecommit") + + @_builtins.property + @pulumi.getter(name="containerReg") + def container_reg(self) -> 'outputs.GetCredentialKeysContainerRegResult': + return pulumi.get(self, "container_reg") + + @_builtins.property + @pulumi.getter + def gitea(self) -> 'outputs.GetCredentialKeysGiteaResult': + return pulumi.get(self, "gitea") + + @_builtins.property + @pulumi.getter + def github(self) -> 'outputs.GetCredentialKeysGithubResult': + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def gitlab(self) -> 'outputs.GetCredentialKeysGitlabResult': + return pulumi.get(self, "gitlab") + + @_builtins.property + @pulumi.getter + def google(self) -> 'outputs.GetCredentialKeysGoogleResult': + return pulumi.get(self, "google") + + @_builtins.property + @pulumi.getter + def k8s(self) -> 'outputs.GetCredentialKeysK8sResult': + return pulumi.get(self, "k8s") + + @_builtins.property + @pulumi.getter + def seqeracompute(self) -> 'outputs.GetCredentialKeysSeqeracomputeResult': + return pulumi.get(self, "seqeracompute") + + @_builtins.property + @pulumi.getter + def ssh(self) -> 'outputs.GetCredentialKeysSshResult': + return pulumi.get(self, "ssh") + + @_builtins.property + @pulumi.getter(name="twAgent") + def tw_agent(self) -> 'outputs.GetCredentialKeysTwAgentResult': + return pulumi.get(self, "tw_agent") + + +@pulumi.output_type +class GetCredentialKeysAwsResult(dict): + def __init__(__self__, *, + access_key: _builtins.str, + assume_role_arn: _builtins.str): + pulumi.set(__self__, "access_key", access_key) + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> _builtins.str: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> _builtins.str: + return pulumi.get(self, "assume_role_arn") + + +@pulumi.output_type +class GetCredentialKeysAzureResult(dict): + def __init__(__self__, *, + batch_name: _builtins.str, + storage_name: _builtins.str): + pulumi.set(__self__, "batch_name", batch_name) + pulumi.set(__self__, "storage_name", storage_name) + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> _builtins.str: + return pulumi.get(self, "batch_name") + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> _builtins.str: + return pulumi.get(self, "storage_name") + + +@pulumi.output_type +class GetCredentialKeysAzureEntraResult(dict): + def __init__(__self__, *, + batch_name: _builtins.str, + client_id: _builtins.str, + storage_name: _builtins.str, + tenant_id: _builtins.str): + pulumi.set(__self__, "batch_name", batch_name) + pulumi.set(__self__, "client_id", client_id) + pulumi.set(__self__, "storage_name", storage_name) + pulumi.set(__self__, "tenant_id", tenant_id) + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> _builtins.str: + return pulumi.get(self, "batch_name") + + @_builtins.property + @pulumi.getter(name="clientId") + def client_id(self) -> _builtins.str: + return pulumi.get(self, "client_id") + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> _builtins.str: + return pulumi.get(self, "storage_name") + + @_builtins.property + @pulumi.getter(name="tenantId") + def tenant_id(self) -> _builtins.str: + return pulumi.get(self, "tenant_id") + + +@pulumi.output_type +class GetCredentialKeysAzurereposResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysBitbucketResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysCodecommitResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysContainerRegResult(dict): + def __init__(__self__, *, + registry: _builtins.str, + user_name: _builtins.str): + pulumi.set(__self__, "registry", registry) + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def registry(self) -> _builtins.str: + return pulumi.get(self, "registry") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class GetCredentialKeysGiteaResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysGithubResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysGitlabResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysGoogleResult(dict): + def __init__(__self__): + pass + + +@pulumi.output_type +class GetCredentialKeysK8sResult(dict): + def __init__(__self__, *, + certificate: _builtins.str): + pulumi.set(__self__, "certificate", certificate) + + @_builtins.property + @pulumi.getter + def certificate(self) -> _builtins.str: + return pulumi.get(self, "certificate") + + +@pulumi.output_type +class GetCredentialKeysSeqeracomputeResult(dict): + def __init__(__self__, *, + access_key: _builtins.str, + assume_role_arn: _builtins.str): + pulumi.set(__self__, "access_key", access_key) + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> _builtins.str: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> _builtins.str: + return pulumi.get(self, "assume_role_arn") + + +@pulumi.output_type +class GetCredentialKeysSshResult(dict): + def __init__(__self__): + pass + + +@pulumi.output_type +class GetCredentialKeysTwAgentResult(dict): + def __init__(__self__, *, + connection_id: _builtins.str, + shared: _builtins.bool, + work_dir: _builtins.str): + pulumi.set(__self__, "connection_id", connection_id) + pulumi.set(__self__, "shared", shared) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="connectionId") + def connection_id(self) -> _builtins.str: + return pulumi.get(self, "connection_id") + + @_builtins.property + @pulumi.getter + def shared(self) -> _builtins.bool: + return pulumi.get(self, "shared") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetDataLinkCredentialResult(dict): + def __init__(__self__, *, + id: _builtins.str, + name: _builtins.str, + provider_type: _builtins.str): + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + +@pulumi.output_type +class GetDatasetDatasetResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + deleted: _builtins.bool, + description: _builtins.str, + id: _builtins.str, + last_updated: _builtins.str, + media_type: _builtins.str, + name: _builtins.str): + """ + :param _builtins.bool deleted: Read-only flag indicating if the dataset has been deleted + :param _builtins.str description: Detailed description of the dataset contents and purpose (max 1000 characters) + :param _builtins.str id: Unique identifier for the dataset (max 22 characters) + :param _builtins.str media_type: MIME type or media type of the dataset content (max 80 characters) + :param _builtins.str name: Dataset name following naming conventions (1-100 characters) + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "deleted", deleted) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "media_type", media_type) + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + """ + Read-only flag indicating if the dataset has been deleted + """ + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + """ + Detailed description of the dataset contents and purpose (max 1000 characters) + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + Unique identifier for the dataset (max 22 characters) + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="mediaType") + def media_type(self) -> _builtins.str: + """ + MIME type or media type of the dataset content (max 80 characters) + """ + return pulumi.get(self, "media_type") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Dataset name following naming conventions (1-100 characters) + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class GetLabelsLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetPipelineComputeEnvResult(dict): + def __init__(__self__, *, + id: _builtins.str, + name: _builtins.str, + platform: _builtins.str, + region: _builtins.str): + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "platform", platform) + pulumi.set(__self__, "region", region) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + +@pulumi.output_type +class GetPipelineLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetStudiosActiveConnectionResult(dict): + def __init__(__self__, *, + avatar: _builtins.str, + email: _builtins.str, + id: _builtins.float, + last_active: _builtins.str, + user_name: _builtins.str): + pulumi.set(__self__, "avatar", avatar) + pulumi.set(__self__, "email", email) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "last_active", last_active) + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> _builtins.str: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter + def email(self) -> _builtins.str: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastActive") + def last_active(self) -> _builtins.str: + return pulumi.get(self, "last_active") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class GetStudiosComputeEnvResult(dict): + def __init__(__self__, *, + credentials_id: _builtins.str, + id: _builtins.str, + name: _builtins.str, + platform: _builtins.str, + region: _builtins.str, + work_dir: _builtins.str): + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "platform", platform) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetStudiosConfigurationResult(dict): + def __init__(__self__, *, + conda_environment: _builtins.str, + cpu: _builtins.float, + gpu: _builtins.float, + lifespan_hours: _builtins.float, + memory: _builtins.float, + mount_datas: Sequence[_builtins.str]): + pulumi.set(__self__, "conda_environment", conda_environment) + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "gpu", gpu) + pulumi.set(__self__, "lifespan_hours", lifespan_hours) + pulumi.set(__self__, "memory", memory) + pulumi.set(__self__, "mount_datas", mount_datas) + + @_builtins.property + @pulumi.getter(name="condaEnvironment") + def conda_environment(self) -> _builtins.str: + return pulumi.get(self, "conda_environment") + + @_builtins.property + @pulumi.getter + def cpu(self) -> _builtins.float: + return pulumi.get(self, "cpu") + + @_builtins.property + @pulumi.getter + def gpu(self) -> _builtins.float: + return pulumi.get(self, "gpu") + + @_builtins.property + @pulumi.getter(name="lifespanHours") + def lifespan_hours(self) -> _builtins.float: + return pulumi.get(self, "lifespan_hours") + + @_builtins.property + @pulumi.getter + def memory(self) -> _builtins.float: + return pulumi.get(self, "memory") + + @_builtins.property + @pulumi.getter(name="mountDatas") + def mount_datas(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "mount_datas") + + +@pulumi.output_type +class GetStudiosLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetStudiosMountedDataLinkResult(dict): + def __init__(__self__, *, + credentials: Sequence['outputs.GetStudiosMountedDataLinkCredentialResult'], + data_link_id: _builtins.str, + description: _builtins.str, + hidden: _builtins.bool, + message: _builtins.str, + name: _builtins.str, + provider_type: _builtins.str, + public_accessible: _builtins.bool, + region: _builtins.str, + resource_ref: _builtins.str, + status: _builtins.str, + type: _builtins.str): + """ + :param Sequence['GetStudiosMountedDataLinkCredentialArgs'] credentials: Array of credentials required to access the data link + :param _builtins.str data_link_id: Unique identifier for the data link + :param _builtins.str description: Description of the data link's purpose and contents + :param _builtins.str name: Display name for the data link connection + :param _builtins.str region: Geographic region where the data link is hosted + :param _builtins.str resource_ref: Reference identifier for the external resource + """ + pulumi.set(__self__, "credentials", credentials) + pulumi.set(__self__, "data_link_id", data_link_id) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "hidden", hidden) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "provider_type", provider_type) + pulumi.set(__self__, "public_accessible", public_accessible) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "resource_ref", resource_ref) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "type", type) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Sequence['outputs.GetStudiosMountedDataLinkCredentialResult']: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> _builtins.str: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + """ + Description of the data link's purpose and contents + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def hidden(self) -> _builtins.bool: + return pulumi.get(self, "hidden") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Display name for the data link connection + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> _builtins.bool: + return pulumi.get(self, "public_accessible") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> _builtins.str: + """ + Reference identifier for the external resource + """ + return pulumi.get(self, "resource_ref") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + +@pulumi.output_type +class GetStudiosMountedDataLinkCredentialResult(dict): + def __init__(__self__, *, + id: _builtins.str, + name: _builtins.str, + provider_type: _builtins.str): + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + +@pulumi.output_type +class GetStudiosParentCheckpointResult(dict): + def __init__(__self__, *, + checkpoint_id: _builtins.float, + checkpoint_name: _builtins.str, + session_id: _builtins.str, + studio_name: _builtins.str): + pulumi.set(__self__, "checkpoint_id", checkpoint_id) + pulumi.set(__self__, "checkpoint_name", checkpoint_name) + pulumi.set(__self__, "session_id", session_id) + pulumi.set(__self__, "studio_name", studio_name) + + @_builtins.property + @pulumi.getter(name="checkpointId") + def checkpoint_id(self) -> _builtins.float: + return pulumi.get(self, "checkpoint_id") + + @_builtins.property + @pulumi.getter(name="checkpointName") + def checkpoint_name(self) -> _builtins.str: + return pulumi.get(self, "checkpoint_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> _builtins.str: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="studioName") + def studio_name(self) -> _builtins.str: + return pulumi.get(self, "studio_name") + + +@pulumi.output_type +class GetStudiosProgressResult(dict): + def __init__(__self__, *, + message: _builtins.str, + status: _builtins.str, + warnings: Sequence[_builtins.str]): + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "warnings", warnings) + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def warnings(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "warnings") + + +@pulumi.output_type +class GetStudiosStatusInfoResult(dict): + def __init__(__self__, *, + last_update: _builtins.str, + message: _builtins.str, + status: _builtins.str): + pulumi.set(__self__, "last_update", last_update) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="lastUpdate") + def last_update(self) -> _builtins.str: + return pulumi.get(self, "last_update") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + +@pulumi.output_type +class GetStudiosTemplateResult(dict): + def __init__(__self__, *, + icon: _builtins.str, + repository: _builtins.str, + status: _builtins.str, + tool: _builtins.str): + pulumi.set(__self__, "icon", icon) + pulumi.set(__self__, "repository", repository) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "tool", tool) + + @_builtins.property + @pulumi.getter + def icon(self) -> _builtins.str: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter + def repository(self) -> _builtins.str: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def tool(self) -> _builtins.str: + return pulumi.get(self, "tool") + + +@pulumi.output_type +class GetStudiosUserResult(dict): + def __init__(__self__, *, + avatar: _builtins.str, + email: _builtins.str, + id: _builtins.float, + user_name: _builtins.str): + pulumi.set(__self__, "avatar", avatar) + pulumi.set(__self__, "email", email) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> _builtins.str: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter + def email(self) -> _builtins.str: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class GetUserWorkspacesOrgsAndWorkspaceResult(dict): + def __init__(__self__, *, + org_id: _builtins.float, + org_logo_url: _builtins.str, + org_name: _builtins.str, + org_type: _builtins.str, + roles: Sequence[_builtins.str], + visibility: _builtins.str, + workspace_full_name: _builtins.str, + workspace_id: _builtins.float, + workspace_name: _builtins.str): + pulumi.set(__self__, "org_id", org_id) + pulumi.set(__self__, "org_logo_url", org_logo_url) + pulumi.set(__self__, "org_name", org_name) + pulumi.set(__self__, "org_type", org_type) + pulumi.set(__self__, "roles", roles) + pulumi.set(__self__, "visibility", visibility) + pulumi.set(__self__, "workspace_full_name", workspace_full_name) + pulumi.set(__self__, "workspace_id", workspace_id) + pulumi.set(__self__, "workspace_name", workspace_name) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgLogoUrl") + def org_logo_url(self) -> _builtins.str: + return pulumi.get(self, "org_logo_url") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> _builtins.str: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter(name="orgType") + def org_type(self) -> _builtins.str: + return pulumi.get(self, "org_type") + + @_builtins.property + @pulumi.getter + def roles(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "roles") + + @_builtins.property + @pulumi.getter + def visibility(self) -> _builtins.str: + return pulumi.get(self, "visibility") + + @_builtins.property + @pulumi.getter(name="workspaceFullName") + def workspace_full_name(self) -> _builtins.str: + return pulumi.get(self, "workspace_full_name") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> _builtins.str: + return pulumi.get(self, "workspace_name") + + +@pulumi.output_type +class GetWorkflowsJobInfoResult(dict): + def __init__(__self__, *, + exit_code: _builtins.float, + id: _builtins.float, + message: _builtins.str, + operation_id: _builtins.str, + status: _builtins.str): + pulumi.set(__self__, "exit_code", exit_code) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "operation_id", operation_id) + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="exitCode") + def exit_code(self) -> _builtins.float: + return pulumi.get(self, "exit_code") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> _builtins.str: + return pulumi.get(self, "operation_id") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + +@pulumi.output_type +class GetWorkflowsLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetWorkflowsPlatformResult(dict): + def __init__(__self__, *, + id: _builtins.str, + name: _builtins.str): + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + +@pulumi.output_type +class GetWorkflowsProgressResult(dict): + def __init__(__self__, *, + processes_progresses: Sequence['outputs.GetWorkflowsProgressProcessesProgressResult'], + total_processes: _builtins.float, + workflow_progress: 'outputs.GetWorkflowsProgressWorkflowProgressResult'): + pulumi.set(__self__, "processes_progresses", processes_progresses) + pulumi.set(__self__, "total_processes", total_processes) + pulumi.set(__self__, "workflow_progress", workflow_progress) + + @_builtins.property + @pulumi.getter(name="processesProgresses") + def processes_progresses(self) -> Sequence['outputs.GetWorkflowsProgressProcessesProgressResult']: + return pulumi.get(self, "processes_progresses") + + @_builtins.property + @pulumi.getter(name="totalProcesses") + def total_processes(self) -> _builtins.float: + return pulumi.get(self, "total_processes") + + @_builtins.property + @pulumi.getter(name="workflowProgress") + def workflow_progress(self) -> 'outputs.GetWorkflowsProgressWorkflowProgressResult': + return pulumi.get(self, "workflow_progress") + + +@pulumi.output_type +class GetWorkflowsProgressProcessesProgressResult(dict): + def __init__(__self__, *, + aborted: _builtins.float, + cached: _builtins.float, + cpu_efficiency: _builtins.float, + cpu_load: _builtins.float, + cpu_time: _builtins.float, + cpus: _builtins.float, + date_created: _builtins.str, + failed: _builtins.float, + inv_ctx_switch: _builtins.float, + last_updated: _builtins.str, + load_cpus: _builtins.float, + load_memory: _builtins.float, + load_tasks: _builtins.float, + memory_efficiency: _builtins.float, + memory_req: _builtins.float, + memory_rss: _builtins.float, + peak_cpus: _builtins.float, + peak_memory: _builtins.float, + peak_tasks: _builtins.float, + pending: _builtins.float, + process: _builtins.str, + read_bytes: _builtins.float, + running: _builtins.float, + submitted: _builtins.float, + succeeded: _builtins.float, + vol_ctx_switch: _builtins.float, + write_bytes: _builtins.float): + pulumi.set(__self__, "aborted", aborted) + pulumi.set(__self__, "cached", cached) + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + pulumi.set(__self__, "cpu_load", cpu_load) + pulumi.set(__self__, "cpu_time", cpu_time) + pulumi.set(__self__, "cpus", cpus) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "failed", failed) + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "load_cpus", load_cpus) + pulumi.set(__self__, "load_memory", load_memory) + pulumi.set(__self__, "load_tasks", load_tasks) + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + pulumi.set(__self__, "memory_req", memory_req) + pulumi.set(__self__, "memory_rss", memory_rss) + pulumi.set(__self__, "peak_cpus", peak_cpus) + pulumi.set(__self__, "peak_memory", peak_memory) + pulumi.set(__self__, "peak_tasks", peak_tasks) + pulumi.set(__self__, "pending", pending) + pulumi.set(__self__, "process", process) + pulumi.set(__self__, "read_bytes", read_bytes) + pulumi.set(__self__, "running", running) + pulumi.set(__self__, "submitted", submitted) + pulumi.set(__self__, "succeeded", succeeded) + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> _builtins.float: + return pulumi.get(self, "aborted") + + @_builtins.property + @pulumi.getter + def cached(self) -> _builtins.float: + return pulumi.get(self, "cached") + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> _builtins.float: + return pulumi.get(self, "cpu_efficiency") + + @_builtins.property + @pulumi.getter(name="cpuLoad") + @_utilities.deprecated("""Deprecated""") + def cpu_load(self) -> _builtins.float: + return pulumi.get(self, "cpu_load") + + @_builtins.property + @pulumi.getter(name="cpuTime") + @_utilities.deprecated("""Deprecated""") + def cpu_time(self) -> _builtins.float: + return pulumi.get(self, "cpu_time") + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def cpus(self) -> _builtins.float: + return pulumi.get(self, "cpus") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def failed(self) -> _builtins.float: + return pulumi.get(self, "failed") + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def inv_ctx_switch(self) -> _builtins.float: + return pulumi.get(self, "inv_ctx_switch") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> _builtins.float: + return pulumi.get(self, "load_cpus") + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> _builtins.float: + return pulumi.get(self, "load_memory") + + @_builtins.property + @pulumi.getter(name="loadTasks") + @_utilities.deprecated("""Deprecated""") + def load_tasks(self) -> _builtins.float: + return pulumi.get(self, "load_tasks") + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> _builtins.float: + return pulumi.get(self, "memory_efficiency") + + @_builtins.property + @pulumi.getter(name="memoryReq") + @_utilities.deprecated("""Deprecated""") + def memory_req(self) -> _builtins.float: + return pulumi.get(self, "memory_req") + + @_builtins.property + @pulumi.getter(name="memoryRss") + @_utilities.deprecated("""Deprecated""") + def memory_rss(self) -> _builtins.float: + return pulumi.get(self, "memory_rss") + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> _builtins.float: + return pulumi.get(self, "peak_cpus") + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> _builtins.float: + return pulumi.get(self, "peak_memory") + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> _builtins.float: + return pulumi.get(self, "peak_tasks") + + @_builtins.property + @pulumi.getter + def pending(self) -> _builtins.float: + return pulumi.get(self, "pending") + + @_builtins.property + @pulumi.getter + def process(self) -> _builtins.str: + return pulumi.get(self, "process") + + @_builtins.property + @pulumi.getter(name="readBytes") + @_utilities.deprecated("""Deprecated""") + def read_bytes(self) -> _builtins.float: + return pulumi.get(self, "read_bytes") + + @_builtins.property + @pulumi.getter + def running(self) -> _builtins.float: + return pulumi.get(self, "running") + + @_builtins.property + @pulumi.getter + def submitted(self) -> _builtins.float: + return pulumi.get(self, "submitted") + + @_builtins.property + @pulumi.getter + def succeeded(self) -> _builtins.float: + return pulumi.get(self, "succeeded") + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def vol_ctx_switch(self) -> _builtins.float: + return pulumi.get(self, "vol_ctx_switch") + + @_builtins.property + @pulumi.getter(name="writeBytes") + @_utilities.deprecated("""Deprecated""") + def write_bytes(self) -> _builtins.float: + return pulumi.get(self, "write_bytes") + + +@pulumi.output_type +class GetWorkflowsProgressWorkflowProgressResult(dict): + def __init__(__self__, *, + aborted: _builtins.float, + cached: _builtins.float, + cost: _builtins.float, + cpu_efficiency: _builtins.float, + cpu_load: _builtins.float, + cpu_time: _builtins.float, + cpus: _builtins.float, + date_created: _builtins.str, + executors: Sequence[_builtins.str], + failed: _builtins.float, + inv_ctx_switch: _builtins.float, + last_updated: _builtins.str, + load_cpus: _builtins.float, + load_memory: _builtins.float, + load_tasks: _builtins.float, + memory_efficiency: _builtins.float, + memory_req: _builtins.float, + memory_rss: _builtins.float, + peak_cpus: _builtins.float, + peak_memory: _builtins.float, + peak_tasks: _builtins.float, + pending: _builtins.float, + read_bytes: _builtins.float, + running: _builtins.float, + submitted: _builtins.float, + succeeded: _builtins.float, + vol_ctx_switch: _builtins.float, + write_bytes: _builtins.float): + pulumi.set(__self__, "aborted", aborted) + pulumi.set(__self__, "cached", cached) + pulumi.set(__self__, "cost", cost) + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + pulumi.set(__self__, "cpu_load", cpu_load) + pulumi.set(__self__, "cpu_time", cpu_time) + pulumi.set(__self__, "cpus", cpus) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "executors", executors) + pulumi.set(__self__, "failed", failed) + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "load_cpus", load_cpus) + pulumi.set(__self__, "load_memory", load_memory) + pulumi.set(__self__, "load_tasks", load_tasks) + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + pulumi.set(__self__, "memory_req", memory_req) + pulumi.set(__self__, "memory_rss", memory_rss) + pulumi.set(__self__, "peak_cpus", peak_cpus) + pulumi.set(__self__, "peak_memory", peak_memory) + pulumi.set(__self__, "peak_tasks", peak_tasks) + pulumi.set(__self__, "pending", pending) + pulumi.set(__self__, "read_bytes", read_bytes) + pulumi.set(__self__, "running", running) + pulumi.set(__self__, "submitted", submitted) + pulumi.set(__self__, "succeeded", succeeded) + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> _builtins.float: + return pulumi.get(self, "aborted") + + @_builtins.property + @pulumi.getter + def cached(self) -> _builtins.float: + return pulumi.get(self, "cached") + + @_builtins.property + @pulumi.getter + def cost(self) -> _builtins.float: + return pulumi.get(self, "cost") + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> _builtins.float: + return pulumi.get(self, "cpu_efficiency") + + @_builtins.property + @pulumi.getter(name="cpuLoad") + def cpu_load(self) -> _builtins.float: + return pulumi.get(self, "cpu_load") + + @_builtins.property + @pulumi.getter(name="cpuTime") + def cpu_time(self) -> _builtins.float: + return pulumi.get(self, "cpu_time") + + @_builtins.property + @pulumi.getter + def cpus(self) -> _builtins.float: + return pulumi.get(self, "cpus") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def executors(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "executors") + + @_builtins.property + @pulumi.getter + def failed(self) -> _builtins.float: + return pulumi.get(self, "failed") + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + def inv_ctx_switch(self) -> _builtins.float: + return pulumi.get(self, "inv_ctx_switch") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> _builtins.float: + return pulumi.get(self, "load_cpus") + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> _builtins.float: + return pulumi.get(self, "load_memory") + + @_builtins.property + @pulumi.getter(name="loadTasks") + def load_tasks(self) -> _builtins.float: + return pulumi.get(self, "load_tasks") + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> _builtins.float: + return pulumi.get(self, "memory_efficiency") + + @_builtins.property + @pulumi.getter(name="memoryReq") + def memory_req(self) -> _builtins.float: + return pulumi.get(self, "memory_req") + + @_builtins.property + @pulumi.getter(name="memoryRss") + def memory_rss(self) -> _builtins.float: + return pulumi.get(self, "memory_rss") + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> _builtins.float: + return pulumi.get(self, "peak_cpus") + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> _builtins.float: + return pulumi.get(self, "peak_memory") + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> _builtins.float: + return pulumi.get(self, "peak_tasks") + + @_builtins.property + @pulumi.getter + def pending(self) -> _builtins.float: + return pulumi.get(self, "pending") + + @_builtins.property + @pulumi.getter(name="readBytes") + def read_bytes(self) -> _builtins.float: + return pulumi.get(self, "read_bytes") + + @_builtins.property + @pulumi.getter + def running(self) -> _builtins.float: + return pulumi.get(self, "running") + + @_builtins.property + @pulumi.getter + def submitted(self) -> _builtins.float: + return pulumi.get(self, "submitted") + + @_builtins.property + @pulumi.getter + def succeeded(self) -> _builtins.float: + return pulumi.get(self, "succeeded") + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + def vol_ctx_switch(self) -> _builtins.float: + return pulumi.get(self, "vol_ctx_switch") + + @_builtins.property + @pulumi.getter(name="writeBytes") + def write_bytes(self) -> _builtins.float: + return pulumi.get(self, "write_bytes") + + +@pulumi.output_type +class GetWorkflowsWorkflowResult(dict): + def __init__(__self__, *, + command_line: _builtins.str, + commit_id: _builtins.str, + complete: _builtins.str, + config_files: Sequence[_builtins.str], + config_text: _builtins.str, + container: _builtins.str, + container_engine: _builtins.str, + date_created: _builtins.str, + deleted: _builtins.bool, + duration: _builtins.float, + error_message: _builtins.str, + error_report: _builtins.str, + exit_status: _builtins.float, + home_dir: _builtins.str, + id: _builtins.str, + last_updated: _builtins.str, + launch_dir: _builtins.str, + launch_id: _builtins.str, + log_file: _builtins.str, + manifest: 'outputs.GetWorkflowsWorkflowManifestResult', + nextflow: 'outputs.GetWorkflowsWorkflowNextflowResult', + operation_id: _builtins.str, + out_file: _builtins.str, + owner_id: _builtins.float, + params: Mapping[str, _builtins.str], + profile: _builtins.str, + project_dir: _builtins.str, + project_name: _builtins.str, + repository: _builtins.str, + requires_attention: _builtins.bool, + resume: _builtins.bool, + revision: _builtins.str, + run_name: _builtins.str, + script_file: _builtins.str, + script_id: _builtins.str, + script_name: _builtins.str, + session_id: _builtins.str, + start: _builtins.str, + stats: 'outputs.GetWorkflowsWorkflowStatsResult', + status: _builtins.str, + submit: _builtins.str, + success: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + pulumi.set(__self__, "command_line", command_line) + pulumi.set(__self__, "commit_id", commit_id) + pulumi.set(__self__, "complete", complete) + pulumi.set(__self__, "config_files", config_files) + pulumi.set(__self__, "config_text", config_text) + pulumi.set(__self__, "container", container) + pulumi.set(__self__, "container_engine", container_engine) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "deleted", deleted) + pulumi.set(__self__, "duration", duration) + pulumi.set(__self__, "error_message", error_message) + pulumi.set(__self__, "error_report", error_report) + pulumi.set(__self__, "exit_status", exit_status) + pulumi.set(__self__, "home_dir", home_dir) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "launch_id", launch_id) + pulumi.set(__self__, "log_file", log_file) + pulumi.set(__self__, "manifest", manifest) + pulumi.set(__self__, "nextflow", nextflow) + pulumi.set(__self__, "operation_id", operation_id) + pulumi.set(__self__, "out_file", out_file) + pulumi.set(__self__, "owner_id", owner_id) + pulumi.set(__self__, "params", params) + pulumi.set(__self__, "profile", profile) + pulumi.set(__self__, "project_dir", project_dir) + pulumi.set(__self__, "project_name", project_name) + pulumi.set(__self__, "repository", repository) + pulumi.set(__self__, "requires_attention", requires_attention) + pulumi.set(__self__, "resume", resume) + pulumi.set(__self__, "revision", revision) + pulumi.set(__self__, "run_name", run_name) + pulumi.set(__self__, "script_file", script_file) + pulumi.set(__self__, "script_id", script_id) + pulumi.set(__self__, "script_name", script_name) + pulumi.set(__self__, "session_id", session_id) + pulumi.set(__self__, "start", start) + pulumi.set(__self__, "stats", stats) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "submit", submit) + pulumi.set(__self__, "success", success) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="commandLine") + def command_line(self) -> _builtins.str: + return pulumi.get(self, "command_line") + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> _builtins.str: + return pulumi.get(self, "commit_id") + + @_builtins.property + @pulumi.getter + def complete(self) -> _builtins.str: + return pulumi.get(self, "complete") + + @_builtins.property + @pulumi.getter(name="configFiles") + def config_files(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "config_files") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> _builtins.str: + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter + def container(self) -> _builtins.str: + return pulumi.get(self, "container") + + @_builtins.property + @pulumi.getter(name="containerEngine") + def container_engine(self) -> _builtins.str: + return pulumi.get(self, "container_engine") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def duration(self) -> _builtins.float: + return pulumi.get(self, "duration") + + @_builtins.property + @pulumi.getter(name="errorMessage") + def error_message(self) -> _builtins.str: + return pulumi.get(self, "error_message") + + @_builtins.property + @pulumi.getter(name="errorReport") + def error_report(self) -> _builtins.str: + return pulumi.get(self, "error_report") + + @_builtins.property + @pulumi.getter(name="exitStatus") + def exit_status(self) -> _builtins.float: + return pulumi.get(self, "exit_status") + + @_builtins.property + @pulumi.getter(name="homeDir") + def home_dir(self) -> _builtins.str: + return pulumi.get(self, "home_dir") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="launchId") + def launch_id(self) -> _builtins.str: + return pulumi.get(self, "launch_id") + + @_builtins.property + @pulumi.getter(name="logFile") + def log_file(self) -> _builtins.str: + return pulumi.get(self, "log_file") + + @_builtins.property + @pulumi.getter + def manifest(self) -> 'outputs.GetWorkflowsWorkflowManifestResult': + return pulumi.get(self, "manifest") + + @_builtins.property + @pulumi.getter + def nextflow(self) -> 'outputs.GetWorkflowsWorkflowNextflowResult': + return pulumi.get(self, "nextflow") + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> _builtins.str: + return pulumi.get(self, "operation_id") + + @_builtins.property + @pulumi.getter(name="outFile") + def out_file(self) -> _builtins.str: + return pulumi.get(self, "out_file") + + @_builtins.property + @pulumi.getter(name="ownerId") + def owner_id(self) -> _builtins.float: + return pulumi.get(self, "owner_id") + + @_builtins.property + @pulumi.getter + def params(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "params") + + @_builtins.property + @pulumi.getter + def profile(self) -> _builtins.str: + return pulumi.get(self, "profile") + + @_builtins.property + @pulumi.getter(name="projectDir") + def project_dir(self) -> _builtins.str: + return pulumi.get(self, "project_dir") + + @_builtins.property + @pulumi.getter(name="projectName") + def project_name(self) -> _builtins.str: + return pulumi.get(self, "project_name") + + @_builtins.property + @pulumi.getter + def repository(self) -> _builtins.str: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter(name="requiresAttention") + def requires_attention(self) -> _builtins.bool: + return pulumi.get(self, "requires_attention") + + @_builtins.property + @pulumi.getter + def resume(self) -> _builtins.bool: + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter + def revision(self) -> _builtins.str: + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> _builtins.str: + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="scriptFile") + def script_file(self) -> _builtins.str: + return pulumi.get(self, "script_file") + + @_builtins.property + @pulumi.getter(name="scriptId") + def script_id(self) -> _builtins.str: + return pulumi.get(self, "script_id") + + @_builtins.property + @pulumi.getter(name="scriptName") + def script_name(self) -> _builtins.str: + return pulumi.get(self, "script_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> _builtins.str: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter + def start(self) -> _builtins.str: + return pulumi.get(self, "start") + + @_builtins.property + @pulumi.getter + def stats(self) -> 'outputs.GetWorkflowsWorkflowStatsResult': + return pulumi.get(self, "stats") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def submit(self) -> _builtins.str: + return pulumi.get(self, "submit") + + @_builtins.property + @pulumi.getter + def success(self) -> _builtins.bool: + return pulumi.get(self, "success") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetWorkflowsWorkflowManifestResult(dict): + def __init__(__self__, *, + author: _builtins.str, + default_branch: _builtins.str, + description: _builtins.str, + gitmodules: _builtins.str, + home_page: _builtins.str, + icon: _builtins.str, + main_script: _builtins.str, + name: _builtins.str, + nextflow_version: _builtins.str, + version: _builtins.str): + pulumi.set(__self__, "author", author) + pulumi.set(__self__, "default_branch", default_branch) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "gitmodules", gitmodules) + pulumi.set(__self__, "home_page", home_page) + pulumi.set(__self__, "icon", icon) + pulumi.set(__self__, "main_script", main_script) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "nextflow_version", nextflow_version) + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def author(self) -> _builtins.str: + return pulumi.get(self, "author") + + @_builtins.property + @pulumi.getter(name="defaultBranch") + def default_branch(self) -> _builtins.str: + return pulumi.get(self, "default_branch") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def gitmodules(self) -> _builtins.str: + return pulumi.get(self, "gitmodules") + + @_builtins.property + @pulumi.getter(name="homePage") + def home_page(self) -> _builtins.str: + return pulumi.get(self, "home_page") + + @_builtins.property + @pulumi.getter + def icon(self) -> _builtins.str: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> _builtins.str: + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="nextflowVersion") + def nextflow_version(self) -> _builtins.str: + return pulumi.get(self, "nextflow_version") + + @_builtins.property + @pulumi.getter + def version(self) -> _builtins.str: + return pulumi.get(self, "version") + + +@pulumi.output_type +class GetWorkflowsWorkflowNextflowResult(dict): + def __init__(__self__, *, + build: _builtins.str, + timestamp: _builtins.str, + version: _builtins.str): + pulumi.set(__self__, "build", build) + pulumi.set(__self__, "timestamp", timestamp) + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def build(self) -> _builtins.str: + return pulumi.get(self, "build") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> _builtins.str: + return pulumi.get(self, "timestamp") + + @_builtins.property + @pulumi.getter + def version(self) -> _builtins.str: + return pulumi.get(self, "version") + + +@pulumi.output_type +class GetWorkflowsWorkflowStatsResult(dict): + def __init__(__self__, *, + cached_count: _builtins.float, + cached_count_fmt: _builtins.str, + cached_duration: _builtins.float, + cached_pct: _builtins.float, + compute_time_fmt: _builtins.str, + failed_count: _builtins.float, + failed_count_fmt: _builtins.str, + failed_duration: _builtins.float, + failed_pct: _builtins.float, + ignored_count: _builtins.float, + ignored_count_fmt: _builtins.str, + ignored_pct: _builtins.float, + succeed_count: _builtins.float, + succeed_count_fmt: _builtins.str, + succeed_duration: _builtins.float, + succeed_pct: _builtins.float): + pulumi.set(__self__, "cached_count", cached_count) + pulumi.set(__self__, "cached_count_fmt", cached_count_fmt) + pulumi.set(__self__, "cached_duration", cached_duration) + pulumi.set(__self__, "cached_pct", cached_pct) + pulumi.set(__self__, "compute_time_fmt", compute_time_fmt) + pulumi.set(__self__, "failed_count", failed_count) + pulumi.set(__self__, "failed_count_fmt", failed_count_fmt) + pulumi.set(__self__, "failed_duration", failed_duration) + pulumi.set(__self__, "failed_pct", failed_pct) + pulumi.set(__self__, "ignored_count", ignored_count) + pulumi.set(__self__, "ignored_count_fmt", ignored_count_fmt) + pulumi.set(__self__, "ignored_pct", ignored_pct) + pulumi.set(__self__, "succeed_count", succeed_count) + pulumi.set(__self__, "succeed_count_fmt", succeed_count_fmt) + pulumi.set(__self__, "succeed_duration", succeed_duration) + pulumi.set(__self__, "succeed_pct", succeed_pct) + + @_builtins.property + @pulumi.getter(name="cachedCount") + def cached_count(self) -> _builtins.float: + return pulumi.get(self, "cached_count") + + @_builtins.property + @pulumi.getter(name="cachedCountFmt") + def cached_count_fmt(self) -> _builtins.str: + return pulumi.get(self, "cached_count_fmt") + + @_builtins.property + @pulumi.getter(name="cachedDuration") + def cached_duration(self) -> _builtins.float: + return pulumi.get(self, "cached_duration") + + @_builtins.property + @pulumi.getter(name="cachedPct") + def cached_pct(self) -> _builtins.float: + return pulumi.get(self, "cached_pct") + + @_builtins.property + @pulumi.getter(name="computeTimeFmt") + def compute_time_fmt(self) -> _builtins.str: + return pulumi.get(self, "compute_time_fmt") + + @_builtins.property + @pulumi.getter(name="failedCount") + def failed_count(self) -> _builtins.float: + return pulumi.get(self, "failed_count") + + @_builtins.property + @pulumi.getter(name="failedCountFmt") + def failed_count_fmt(self) -> _builtins.str: + return pulumi.get(self, "failed_count_fmt") + + @_builtins.property + @pulumi.getter(name="failedDuration") + def failed_duration(self) -> _builtins.float: + return pulumi.get(self, "failed_duration") + + @_builtins.property + @pulumi.getter(name="failedPct") + def failed_pct(self) -> _builtins.float: + return pulumi.get(self, "failed_pct") + + @_builtins.property + @pulumi.getter(name="ignoredCount") + def ignored_count(self) -> _builtins.float: + return pulumi.get(self, "ignored_count") + + @_builtins.property + @pulumi.getter(name="ignoredCountFmt") + def ignored_count_fmt(self) -> _builtins.str: + return pulumi.get(self, "ignored_count_fmt") + + @_builtins.property + @pulumi.getter(name="ignoredPct") + def ignored_pct(self) -> _builtins.float: + return pulumi.get(self, "ignored_pct") + + @_builtins.property + @pulumi.getter(name="succeedCount") + def succeed_count(self) -> _builtins.float: + return pulumi.get(self, "succeed_count") + + @_builtins.property + @pulumi.getter(name="succeedCountFmt") + def succeed_count_fmt(self) -> _builtins.str: + return pulumi.get(self, "succeed_count_fmt") + + @_builtins.property + @pulumi.getter(name="succeedDuration") + def succeed_duration(self) -> _builtins.float: + return pulumi.get(self, "succeed_duration") + + @_builtins.property + @pulumi.getter(name="succeedPct") + def succeed_pct(self) -> _builtins.float: + return pulumi.get(self, "succeed_pct") + + +@pulumi.output_type +class GetWorkspacesWorkspaceResult(dict): + def __init__(__self__, *, + description: _builtins.str, + full_name: _builtins.str, + id: _builtins.float, + name: _builtins.str, + visibility: _builtins.str): + """ + :param _builtins.str description: Detailed description of the workspace's purpose + :param _builtins.str full_name: Complete display name for the workspace + :param _builtins.float id: Unique numeric identifier for the workspace + :param _builtins.str name: Short name or handle for the workspace + """ + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "full_name", full_name) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "visibility", visibility) + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + """ + Detailed description of the workspace's purpose + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> _builtins.str: + """ + Complete display name for the workspace + """ + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the workspace + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Short name or handle for the workspace + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def visibility(self) -> _builtins.str: + return pulumi.get(self, "visibility") + + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pipeline.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pipeline.py new file mode 100644 index 00000000..45b9d6dc --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pipeline.py @@ -0,0 +1,711 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['PipelineArgs', 'Pipeline'] + +@pulumi.input_type +class PipelineArgs: + def __init__(__self__, *, + launch: pulumi.Input['PipelineLaunchArgs'], + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Pipeline resource. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + pulumi.set(__self__, "launch", launch) + if description is not None: + pulumi.set(__self__, "description", description) + if icon is not None: + pulumi.set(__self__, "icon", icon) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if name is not None: + pulumi.set(__self__, "name", name) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def launch(self) -> pulumi.Input['PipelineLaunchArgs']: + return pulumi.get(self, "launch") + + @launch.setter + def launch(self, value: pulumi.Input['PipelineLaunchArgs']): + pulumi.set(self, "launch", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "icon") + + @icon.setter + def icon(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "icon", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _PipelineState: + def __init__(__self__, *, + compute_env: Optional[pulumi.Input['PipelineComputeEnvArgs']] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineLabelArgs']]]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch: Optional[pulumi.Input['PipelineLaunchArgs']] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_status: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + org_name: Optional[pulumi.Input[_builtins.str]] = None, + pipeline_id: Optional[pulumi.Input[_builtins.float]] = None, + repository: Optional[pulumi.Input[_builtins.str]] = None, + user_first_name: Optional[pulumi.Input[_builtins.str]] = None, + user_id: Optional[pulumi.Input[_builtins.float]] = None, + user_last_name: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_name: Optional[pulumi.Input[_builtins.str]] = None): + """ + Input properties used for looking up and filtering Pipeline resources. + :param pulumi.Input[_builtins.str] optimization_status: must be one of ["OPTIMIZED", "OPTIMIZABLE", "UNAVAILABLE"] + :param pulumi.Input[_builtins.float] pipeline_id: Unique numeric identifier for the pipeline + :param pulumi.Input[_builtins.str] repository: Git repository URL containing the pipeline source code + :param pulumi.Input[_builtins.str] user_first_name: First name of the user who created the pipeline + :param pulumi.Input[_builtins.float] user_id: Numeric identifier of the user who created the pipeline + :param pulumi.Input[_builtins.str] user_name: Username of the pipeline creator + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if icon is not None: + pulumi.set(__self__, "icon", icon) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch is not None: + pulumi.set(__self__, "launch", launch) + if name is not None: + pulumi.set(__self__, "name", name) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_status is not None: + pulumi.set(__self__, "optimization_status", optimization_status) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if org_name is not None: + pulumi.set(__self__, "org_name", org_name) + if pipeline_id is not None: + pulumi.set(__self__, "pipeline_id", pipeline_id) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if user_first_name is not None: + pulumi.set(__self__, "user_first_name", user_first_name) + if user_id is not None: + pulumi.set(__self__, "user_id", user_id) + if user_last_name is not None: + pulumi.set(__self__, "user_last_name", user_last_name) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if visibility is not None: + pulumi.set(__self__, "visibility", visibility) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + if workspace_name is not None: + pulumi.set(__self__, "workspace_name", workspace_name) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional[pulumi.Input['PipelineComputeEnvArgs']]: + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: Optional[pulumi.Input['PipelineComputeEnvArgs']]): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "icon") + + @icon.setter + def icon(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "icon", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PipelineLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter + def launch(self) -> Optional[pulumi.Input['PipelineLaunchArgs']]: + return pulumi.get(self, "launch") + + @launch.setter + def launch(self, value: Optional[pulumi.Input['PipelineLaunchArgs']]): + pulumi.set(self, "launch", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationStatus") + def optimization_status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["OPTIMIZED", "OPTIMIZABLE", "UNAVAILABLE"] + """ + return pulumi.get(self, "optimization_status") + + @optimization_status.setter + def optimization_status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_status", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "org_name") + + @org_name.setter + def org_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "org_name", value) + + @_builtins.property + @pulumi.getter(name="pipelineId") + def pipeline_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the pipeline + """ + return pulumi.get(self, "pipeline_id") + + @pipeline_id.setter + def pipeline_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "pipeline_id", value) + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Git repository URL containing the pipeline source code + """ + return pulumi.get(self, "repository") + + @repository.setter + def repository(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "repository", value) + + @_builtins.property + @pulumi.getter(name="userFirstName") + def user_first_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + First name of the user who created the pipeline + """ + return pulumi.get(self, "user_first_name") + + @user_first_name.setter + def user_first_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_first_name", value) + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Numeric identifier of the user who created the pipeline + """ + return pulumi.get(self, "user_id") + + @user_id.setter + def user_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "user_id", value) + + @_builtins.property + @pulumi.getter(name="userLastName") + def user_last_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_last_name") + + @user_last_name.setter + def user_last_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_last_name", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Username of the pipeline creator + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter + def visibility(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "visibility") + + @visibility.setter + def visibility(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "visibility", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "workspace_name") + + @workspace_name.setter + def workspace_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "workspace_name", value) + + +@pulumi.type_token("seqera:index/pipeline:Pipeline") +class Pipeline(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch: Optional[pulumi.Input[Union['PipelineLaunchArgs', 'PipelineLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Pipeline resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PipelineArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Pipeline resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param PipelineArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(PipelineArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch: Optional[pulumi.Input[Union['PipelineLaunchArgs', 'PipelineLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = PipelineArgs.__new__(PipelineArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["icon"] = icon + __props__.__dict__["label_ids"] = label_ids + if launch is None and not opts.urn: + raise TypeError("Missing required property 'launch'") + __props__.__dict__["launch"] = launch + __props__.__dict__["name"] = name + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["compute_env"] = None + __props__.__dict__["deleted"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["optimization_id"] = None + __props__.__dict__["optimization_status"] = None + __props__.__dict__["optimization_targets"] = None + __props__.__dict__["org_id"] = None + __props__.__dict__["org_name"] = None + __props__.__dict__["pipeline_id"] = None + __props__.__dict__["repository"] = None + __props__.__dict__["user_first_name"] = None + __props__.__dict__["user_id"] = None + __props__.__dict__["user_last_name"] = None + __props__.__dict__["user_name"] = None + __props__.__dict__["visibility"] = None + __props__.__dict__["workspace_name"] = None + super(Pipeline, __self__).__init__( + 'seqera:index/pipeline:Pipeline', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + compute_env: Optional[pulumi.Input[Union['PipelineComputeEnvArgs', 'PipelineComputeEnvArgsDict']]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineLabelArgs', 'PipelineLabelArgsDict']]]]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch: Optional[pulumi.Input[Union['PipelineLaunchArgs', 'PipelineLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_status: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + org_name: Optional[pulumi.Input[_builtins.str]] = None, + pipeline_id: Optional[pulumi.Input[_builtins.float]] = None, + repository: Optional[pulumi.Input[_builtins.str]] = None, + user_first_name: Optional[pulumi.Input[_builtins.str]] = None, + user_id: Optional[pulumi.Input[_builtins.float]] = None, + user_last_name: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_name: Optional[pulumi.Input[_builtins.str]] = None) -> 'Pipeline': + """ + Get an existing Pipeline resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] optimization_status: must be one of ["OPTIMIZED", "OPTIMIZABLE", "UNAVAILABLE"] + :param pulumi.Input[_builtins.float] pipeline_id: Unique numeric identifier for the pipeline + :param pulumi.Input[_builtins.str] repository: Git repository URL containing the pipeline source code + :param pulumi.Input[_builtins.str] user_first_name: First name of the user who created the pipeline + :param pulumi.Input[_builtins.float] user_id: Numeric identifier of the user who created the pipeline + :param pulumi.Input[_builtins.str] user_name: Username of the pipeline creator + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PipelineState.__new__(_PipelineState) + + __props__.__dict__["compute_env"] = compute_env + __props__.__dict__["deleted"] = deleted + __props__.__dict__["description"] = description + __props__.__dict__["icon"] = icon + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["labels"] = labels + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["launch"] = launch + __props__.__dict__["name"] = name + __props__.__dict__["optimization_id"] = optimization_id + __props__.__dict__["optimization_status"] = optimization_status + __props__.__dict__["optimization_targets"] = optimization_targets + __props__.__dict__["org_id"] = org_id + __props__.__dict__["org_name"] = org_name + __props__.__dict__["pipeline_id"] = pipeline_id + __props__.__dict__["repository"] = repository + __props__.__dict__["user_first_name"] = user_first_name + __props__.__dict__["user_id"] = user_id + __props__.__dict__["user_last_name"] = user_last_name + __props__.__dict__["user_name"] = user_name + __props__.__dict__["visibility"] = visibility + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["workspace_name"] = workspace_name + return Pipeline(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> pulumi.Output['outputs.PipelineComputeEnv']: + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter + def deleted(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def icon(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.float]]]: + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.PipelineLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def launch(self) -> pulumi.Output['outputs.PipelineLaunch']: + return pulumi.get(self, "launch") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationStatus") + def optimization_status(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["OPTIMIZED", "OPTIMIZABLE", "UNAVAILABLE"] + """ + return pulumi.get(self, "optimization_status") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter(name="pipelineId") + def pipeline_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the pipeline + """ + return pulumi.get(self, "pipeline_id") + + @_builtins.property + @pulumi.getter + def repository(self) -> pulumi.Output[_builtins.str]: + """ + Git repository URL containing the pipeline source code + """ + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter(name="userFirstName") + def user_first_name(self) -> pulumi.Output[_builtins.str]: + """ + First name of the user who created the pipeline + """ + return pulumi.get(self, "user_first_name") + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> pulumi.Output[_builtins.float]: + """ + Numeric identifier of the user who created the pipeline + """ + return pulumi.get(self, "user_id") + + @_builtins.property + @pulumi.getter(name="userLastName") + def user_last_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "user_last_name") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> pulumi.Output[_builtins.str]: + """ + Username of the pipeline creator + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter + def visibility(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "visibility") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "workspace_name") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pipeline_secret.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pipeline_secret.py new file mode 100644 index 00000000..a853cf61 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pipeline_secret.py @@ -0,0 +1,364 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['PipelineSecretArgs', 'PipelineSecret'] + +@pulumi.input_type +class PipelineSecretArgs: + def __init__(__self__, *, + value: pulumi.Input[_builtins.str], + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a PipelineSecret resource. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + pulumi.set(__self__, "value", value) + if name is not None: + pulumi.set(__self__, "name", name) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def value(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "value", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _PipelineSecretState: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + pipeline_secret_id: Optional[pulumi.Input[_builtins.float]] = None, + secret_id: Optional[pulumi.Input[_builtins.float]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering PipelineSecret resources. + :param pulumi.Input[_builtins.str] date_created: Read-only timestamp when the secret was created + :param pulumi.Input[_builtins.str] last_used: Read-only timestamp when the secret was last accessed + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] pipeline_secret_id: Unique numeric identifier for the secret (nullable) + :param pulumi.Input[_builtins.float] secret_id: Secret numeric identifier + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + if pipeline_secret_id is not None: + pulumi.set(__self__, "pipeline_secret_id", pipeline_secret_id) + if secret_id is not None: + pulumi.set(__self__, "secret_id", secret_id) + if value is not None: + pulumi.set(__self__, "value", value) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Read-only timestamp when the secret was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Read-only timestamp when the secret was last accessed + """ + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="pipelineSecretId") + def pipeline_secret_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the secret (nullable) + """ + return pulumi.get(self, "pipeline_secret_id") + + @pipeline_secret_id.setter + def pipeline_secret_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "pipeline_secret_id", value) + + @_builtins.property + @pulumi.getter(name="secretId") + def secret_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Secret numeric identifier + """ + return pulumi.get(self, "secret_id") + + @secret_id.setter + def secret_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "secret_id", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/pipelineSecret:PipelineSecret") +class PipelineSecret(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a PipelineSecret resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PipelineSecretArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a PipelineSecret resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param PipelineSecretArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(PipelineSecretArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = PipelineSecretArgs.__new__(PipelineSecretArgs) + + __props__.__dict__["name"] = name + if value is None and not opts.urn: + raise TypeError("Missing required property 'value'") + __props__.__dict__["value"] = value + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["date_created"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["last_used"] = None + __props__.__dict__["pipeline_secret_id"] = None + __props__.__dict__["secret_id"] = None + super(PipelineSecret, __self__).__init__( + 'seqera:index/pipelineSecret:PipelineSecret', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + pipeline_secret_id: Optional[pulumi.Input[_builtins.float]] = None, + secret_id: Optional[pulumi.Input[_builtins.float]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'PipelineSecret': + """ + Get an existing PipelineSecret resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] date_created: Read-only timestamp when the secret was created + :param pulumi.Input[_builtins.str] last_used: Read-only timestamp when the secret was last accessed + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] pipeline_secret_id: Unique numeric identifier for the secret (nullable) + :param pulumi.Input[_builtins.float] secret_id: Secret numeric identifier + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PipelineSecretState.__new__(_PipelineSecretState) + + __props__.__dict__["date_created"] = date_created + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["last_used"] = last_used + __props__.__dict__["name"] = name + __props__.__dict__["pipeline_secret_id"] = pipeline_secret_id + __props__.__dict__["secret_id"] = secret_id + __props__.__dict__["value"] = value + __props__.__dict__["workspace_id"] = workspace_id + return PipelineSecret(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + """ + Read-only timestamp when the secret was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> pulumi.Output[_builtins.str]: + """ + Read-only timestamp when the secret was last accessed + """ + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="pipelineSecretId") + def pipeline_secret_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the secret (nullable) + """ + return pulumi.get(self, "pipeline_secret_id") + + @_builtins.property + @pulumi.getter(name="secretId") + def secret_id(self) -> pulumi.Output[_builtins.float]: + """ + Secret numeric identifier + """ + return pulumi.get(self, "secret_id") + + @_builtins.property + @pulumi.getter + def value(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "value") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/provider.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/provider.py new file mode 100644 index 00000000..7527e804 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/provider.py @@ -0,0 +1,156 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ProviderArgs', 'Provider'] + +@pulumi.input_type +class ProviderArgs: + def __init__(__self__, *, + bearer_auth: pulumi.Input[_builtins.str], + server_url: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Provider resource. + :param pulumi.Input[_builtins.str] server_url: Server URL (defaults to https://api.cloud.seqera.io) + """ + pulumi.set(__self__, "bearer_auth", bearer_auth) + if server_url is not None: + pulumi.set(__self__, "server_url", server_url) + + @_builtins.property + @pulumi.getter(name="bearerAuth") + def bearer_auth(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "bearer_auth") + + @bearer_auth.setter + def bearer_auth(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "bearer_auth", value) + + @_builtins.property + @pulumi.getter(name="serverUrl") + def server_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Server URL (defaults to https://api.cloud.seqera.io) + """ + return pulumi.get(self, "server_url") + + @server_url.setter + def server_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server_url", value) + + +@pulumi.type_token("pulumi:providers:seqera") +class Provider(pulumi.ProviderResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bearer_auth: Optional[pulumi.Input[_builtins.str]] = None, + server_url: Optional[pulumi.Input[_builtins.str]] = None, + __props__=None): + """ + The provider type for the seqera package. By default, resources use package-wide configuration + settings, however an explicit `Provider` instance may be created and passed during resource + construction to achieve fine-grained programmatic control over provider settings. See the + [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] server_url: Server URL (defaults to https://api.cloud.seqera.io) + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ProviderArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + The provider type for the seqera package. By default, resources use package-wide configuration + settings, however an explicit `Provider` instance may be created and passed during resource + construction to achieve fine-grained programmatic control over provider settings. See the + [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. + + :param str resource_name: The name of the resource. + :param ProviderArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(ProviderArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bearer_auth: Optional[pulumi.Input[_builtins.str]] = None, + server_url: Optional[pulumi.Input[_builtins.str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ProviderArgs.__new__(ProviderArgs) + + if bearer_auth is None and not opts.urn: + raise TypeError("Missing required property 'bearer_auth'") + __props__.__dict__["bearer_auth"] = None if bearer_auth is None else pulumi.Output.secret(bearer_auth) + __props__.__dict__["server_url"] = server_url + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["bearerAuth"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(Provider, __self__).__init__( + 'seqera', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @_builtins.property + @pulumi.getter(name="bearerAuth") + def bearer_auth(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "bearer_auth") + + @_builtins.property + @pulumi.getter(name="serverUrl") + def server_url(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Server URL (defaults to https://api.cloud.seqera.io) + """ + return pulumi.get(self, "server_url") + + @pulumi.output_type + class TerraformConfigResult: + def __init__(__self__, result=None): + if result and not isinstance(result, dict): + raise TypeError("Expected argument 'result' to be a dict") + pulumi.set(__self__, "result", result) + + @_builtins.property + @pulumi.getter + def result(self) -> Mapping[str, Any]: + return pulumi.get(self, "result") + + def terraform_config(__self__) -> pulumi.Output['Provider.TerraformConfigResult']: + """ + This function returns a Terraform config object with terraform-namecased keys,to be used with the Terraform Module Provider. + """ + __args__ = dict() + __args__['__self__'] = __self__ + return pulumi.runtime.call('pulumi:providers:seqera/terraformConfig', __args__, res=__self__, typ=Provider.TerraformConfigResult, package_ref=_utilities.get_package()) + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pulumi-plugin.json b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pulumi-plugin.json new file mode 100644 index 00000000..d30dbb9d --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/pulumi-plugin.json @@ -0,0 +1,10 @@ +{ + "resource": true, + "name": "terraform-provider", + "version": "0.13.0", + "parameterization": { + "name": "seqera", + "version": "0.25.2", + "value": "eyJyZW1vdGUiOnsidXJsIjoicmVnaXN0cnkudGVycmFmb3JtLmlvL3NlcWVyYWxhYnMvc2VxZXJhIiwidmVyc2lvbiI6IjAuMjUuMiJ9fQ==" + } +} diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/studios.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/studios.py new file mode 100644 index 00000000..d4ef6458 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/studios.py @@ -0,0 +1,1000 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['StudiosArgs', 'Studios'] + +@pulumi.input_type +class StudiosArgs: + def __init__(__self__, *, + compute_env_id: pulumi.Input[_builtins.str], + data_studio_tool_url: pulumi.Input[_builtins.str], + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + configuration: Optional[pulumi.Input['StudiosConfigurationArgs']] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Studios resource. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] data_studio_tool_url: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] auto_start: Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + :param pulumi.Input['StudiosConfigurationArgs'] configuration: Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.float] initial_checkpoint_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] is_private: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "data_studio_tool_url", data_studio_tool_url) + if auto_start is not None: + pulumi.set(__self__, "auto_start", auto_start) + if configuration is not None: + pulumi.set(__self__, "configuration", configuration) + if description is not None: + pulumi.set(__self__, "description", description) + if initial_checkpoint_id is not None: + pulumi.set(__self__, "initial_checkpoint_id", initial_checkpoint_id) + if is_private is not None: + pulumi.set(__self__, "is_private", is_private) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if name is not None: + pulumi.set(__self__, "name", name) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter(name="dataStudioToolUrl") + def data_studio_tool_url(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "data_studio_tool_url") + + @data_studio_tool_url.setter + def data_studio_tool_url(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "data_studio_tool_url", value) + + @_builtins.property + @pulumi.getter(name="autoStart") + def auto_start(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + """ + return pulumi.get(self, "auto_start") + + @auto_start.setter + def auto_start(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_start", value) + + @_builtins.property + @pulumi.getter + def configuration(self) -> Optional[pulumi.Input['StudiosConfigurationArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "configuration") + + @configuration.setter + def configuration(self, value: Optional[pulumi.Input['StudiosConfigurationArgs']]): + pulumi.set(self, "configuration", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="initialCheckpointId") + def initial_checkpoint_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "initial_checkpoint_id") + + @initial_checkpoint_id.setter + def initial_checkpoint_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "initial_checkpoint_id", value) + + @_builtins.property + @pulumi.getter(name="isPrivate") + def is_private(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "is_private") + + @is_private.setter + def is_private(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_private", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @spot.setter + def spot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "spot", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _StudiosState: + def __init__(__self__, *, + active_connections: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosActiveConnectionArgs']]]] = None, + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + base_image: Optional[pulumi.Input[_builtins.str]] = None, + compute_env: Optional[pulumi.Input['StudiosComputeEnvArgs']] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + configuration: Optional[pulumi.Input['StudiosConfigurationArgs']] = None, + custom_image: Optional[pulumi.Input[_builtins.bool]] = None, + data_studio_tool_url: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + effective_lifespan_hours: Optional[pulumi.Input[_builtins.float]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosLabelArgs']]]] = None, + last_started: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + mounted_data_links: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkArgs']]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + parent_checkpoint: Optional[pulumi.Input['StudiosParentCheckpointArgs']] = None, + progresses: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosProgressArgs']]]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + status_info: Optional[pulumi.Input['StudiosStatusInfoArgs']] = None, + studio_url: Optional[pulumi.Input[_builtins.str]] = None, + template: Optional[pulumi.Input['StudiosTemplateArgs']] = None, + user: Optional[pulumi.Input['StudiosUserArgs']] = None, + wave_build_url: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Studios resources. + :param pulumi.Input[_builtins.bool] auto_start: Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input['StudiosConfigurationArgs'] configuration: Requires replacement if changed. + :param pulumi.Input[_builtins.str] data_studio_tool_url: Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.float] initial_checkpoint_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] is_private: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Unique identifier for the Studio session + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.str] studio_url: URL to access the running Studio instance + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + if active_connections is not None: + pulumi.set(__self__, "active_connections", active_connections) + if auto_start is not None: + pulumi.set(__self__, "auto_start", auto_start) + if base_image is not None: + pulumi.set(__self__, "base_image", base_image) + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if configuration is not None: + pulumi.set(__self__, "configuration", configuration) + if custom_image is not None: + pulumi.set(__self__, "custom_image", custom_image) + if data_studio_tool_url is not None: + pulumi.set(__self__, "data_studio_tool_url", data_studio_tool_url) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if description is not None: + pulumi.set(__self__, "description", description) + if effective_lifespan_hours is not None: + pulumi.set(__self__, "effective_lifespan_hours", effective_lifespan_hours) + if initial_checkpoint_id is not None: + pulumi.set(__self__, "initial_checkpoint_id", initial_checkpoint_id) + if is_private is not None: + pulumi.set(__self__, "is_private", is_private) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_started is not None: + pulumi.set(__self__, "last_started", last_started) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if mounted_data_links is not None: + pulumi.set(__self__, "mounted_data_links", mounted_data_links) + if name is not None: + pulumi.set(__self__, "name", name) + if parent_checkpoint is not None: + pulumi.set(__self__, "parent_checkpoint", parent_checkpoint) + if progresses is not None: + pulumi.set(__self__, "progresses", progresses) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if status_info is not None: + pulumi.set(__self__, "status_info", status_info) + if studio_url is not None: + pulumi.set(__self__, "studio_url", studio_url) + if template is not None: + pulumi.set(__self__, "template", template) + if user is not None: + pulumi.set(__self__, "user", user) + if wave_build_url is not None: + pulumi.set(__self__, "wave_build_url", wave_build_url) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="activeConnections") + def active_connections(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosActiveConnectionArgs']]]]: + return pulumi.get(self, "active_connections") + + @active_connections.setter + def active_connections(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosActiveConnectionArgs']]]]): + pulumi.set(self, "active_connections", value) + + @_builtins.property + @pulumi.getter(name="autoStart") + def auto_start(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + """ + return pulumi.get(self, "auto_start") + + @auto_start.setter + def auto_start(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_start", value) + + @_builtins.property + @pulumi.getter(name="baseImage") + def base_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "base_image") + + @base_image.setter + def base_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "base_image", value) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional[pulumi.Input['StudiosComputeEnvArgs']]: + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: Optional[pulumi.Input['StudiosComputeEnvArgs']]): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def configuration(self) -> Optional[pulumi.Input['StudiosConfigurationArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "configuration") + + @configuration.setter + def configuration(self, value: Optional[pulumi.Input['StudiosConfigurationArgs']]): + pulumi.set(self, "configuration", value) + + @_builtins.property + @pulumi.getter(name="customImage") + def custom_image(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "custom_image") + + @custom_image.setter + def custom_image(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "custom_image", value) + + @_builtins.property + @pulumi.getter(name="dataStudioToolUrl") + def data_studio_tool_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "data_studio_tool_url") + + @data_studio_tool_url.setter + def data_studio_tool_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "data_studio_tool_url", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="effectiveLifespanHours") + def effective_lifespan_hours(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "effective_lifespan_hours") + + @effective_lifespan_hours.setter + def effective_lifespan_hours(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "effective_lifespan_hours", value) + + @_builtins.property + @pulumi.getter(name="initialCheckpointId") + def initial_checkpoint_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "initial_checkpoint_id") + + @initial_checkpoint_id.setter + def initial_checkpoint_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "initial_checkpoint_id", value) + + @_builtins.property + @pulumi.getter(name="isPrivate") + def is_private(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "is_private") + + @is_private.setter + def is_private(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_private", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="lastStarted") + def last_started(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_started") + + @last_started.setter + def last_started(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_started", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="mountedDataLinks") + def mounted_data_links(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkArgs']]]]: + return pulumi.get(self, "mounted_data_links") + + @mounted_data_links.setter + def mounted_data_links(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkArgs']]]]): + pulumi.set(self, "mounted_data_links", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="parentCheckpoint") + def parent_checkpoint(self) -> Optional[pulumi.Input['StudiosParentCheckpointArgs']]: + return pulumi.get(self, "parent_checkpoint") + + @parent_checkpoint.setter + def parent_checkpoint(self, value: Optional[pulumi.Input['StudiosParentCheckpointArgs']]): + pulumi.set(self, "parent_checkpoint", value) + + @_builtins.property + @pulumi.getter + def progresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosProgressArgs']]]]: + return pulumi.get(self, "progresses") + + @progresses.setter + def progresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosProgressArgs']]]]): + pulumi.set(self, "progresses", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the Studio session + """ + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @spot.setter + def spot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "spot", value) + + @_builtins.property + @pulumi.getter(name="statusInfo") + def status_info(self) -> Optional[pulumi.Input['StudiosStatusInfoArgs']]: + return pulumi.get(self, "status_info") + + @status_info.setter + def status_info(self, value: Optional[pulumi.Input['StudiosStatusInfoArgs']]): + pulumi.set(self, "status_info", value) + + @_builtins.property + @pulumi.getter(name="studioUrl") + def studio_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + URL to access the running Studio instance + """ + return pulumi.get(self, "studio_url") + + @studio_url.setter + def studio_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "studio_url", value) + + @_builtins.property + @pulumi.getter + def template(self) -> Optional[pulumi.Input['StudiosTemplateArgs']]: + return pulumi.get(self, "template") + + @template.setter + def template(self, value: Optional[pulumi.Input['StudiosTemplateArgs']]): + pulumi.set(self, "template", value) + + @_builtins.property + @pulumi.getter + def user(self) -> Optional[pulumi.Input['StudiosUserArgs']]: + return pulumi.get(self, "user") + + @user.setter + def user(self, value: Optional[pulumi.Input['StudiosUserArgs']]): + pulumi.set(self, "user", value) + + @_builtins.property + @pulumi.getter(name="waveBuildUrl") + def wave_build_url(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "wave_build_url") + + @wave_build_url.setter + def wave_build_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "wave_build_url", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/studios:Studios") +class Studios(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + configuration: Optional[pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']]] = None, + data_studio_tool_url: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Studios resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] auto_start: Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']] configuration: Requires replacement if changed. + :param pulumi.Input[_builtins.str] data_studio_tool_url: Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.float] initial_checkpoint_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] is_private: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: StudiosArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Studios resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param StudiosArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(StudiosArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + configuration: Optional[pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']]] = None, + data_studio_tool_url: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = StudiosArgs.__new__(StudiosArgs) + + __props__.__dict__["auto_start"] = auto_start + if compute_env_id is None and not opts.urn: + raise TypeError("Missing required property 'compute_env_id'") + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["configuration"] = configuration + if data_studio_tool_url is None and not opts.urn: + raise TypeError("Missing required property 'data_studio_tool_url'") + __props__.__dict__["data_studio_tool_url"] = data_studio_tool_url + __props__.__dict__["description"] = description + __props__.__dict__["initial_checkpoint_id"] = initial_checkpoint_id + __props__.__dict__["is_private"] = is_private + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["name"] = name + __props__.__dict__["spot"] = spot + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["active_connections"] = None + __props__.__dict__["base_image"] = None + __props__.__dict__["compute_env"] = None + __props__.__dict__["custom_image"] = None + __props__.__dict__["date_created"] = None + __props__.__dict__["effective_lifespan_hours"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["last_started"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["mounted_data_links"] = None + __props__.__dict__["parent_checkpoint"] = None + __props__.__dict__["progresses"] = None + __props__.__dict__["session_id"] = None + __props__.__dict__["status_info"] = None + __props__.__dict__["studio_url"] = None + __props__.__dict__["template"] = None + __props__.__dict__["user"] = None + __props__.__dict__["wave_build_url"] = None + super(Studios, __self__).__init__( + 'seqera:index/studios:Studios', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + active_connections: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StudiosActiveConnectionArgs', 'StudiosActiveConnectionArgsDict']]]]] = None, + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + base_image: Optional[pulumi.Input[_builtins.str]] = None, + compute_env: Optional[pulumi.Input[Union['StudiosComputeEnvArgs', 'StudiosComputeEnvArgsDict']]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + configuration: Optional[pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']]] = None, + custom_image: Optional[pulumi.Input[_builtins.bool]] = None, + data_studio_tool_url: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + effective_lifespan_hours: Optional[pulumi.Input[_builtins.float]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StudiosLabelArgs', 'StudiosLabelArgsDict']]]]] = None, + last_started: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + mounted_data_links: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StudiosMountedDataLinkArgs', 'StudiosMountedDataLinkArgsDict']]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + parent_checkpoint: Optional[pulumi.Input[Union['StudiosParentCheckpointArgs', 'StudiosParentCheckpointArgsDict']]] = None, + progresses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StudiosProgressArgs', 'StudiosProgressArgsDict']]]]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + status_info: Optional[pulumi.Input[Union['StudiosStatusInfoArgs', 'StudiosStatusInfoArgsDict']]] = None, + studio_url: Optional[pulumi.Input[_builtins.str]] = None, + template: Optional[pulumi.Input[Union['StudiosTemplateArgs', 'StudiosTemplateArgsDict']]] = None, + user: Optional[pulumi.Input[Union['StudiosUserArgs', 'StudiosUserArgsDict']]] = None, + wave_build_url: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Studios': + """ + Get an existing Studios resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] auto_start: Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']] configuration: Requires replacement if changed. + :param pulumi.Input[_builtins.str] data_studio_tool_url: Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.float] initial_checkpoint_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] is_private: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Unique identifier for the Studio session + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.str] studio_url: URL to access the running Studio instance + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _StudiosState.__new__(_StudiosState) + + __props__.__dict__["active_connections"] = active_connections + __props__.__dict__["auto_start"] = auto_start + __props__.__dict__["base_image"] = base_image + __props__.__dict__["compute_env"] = compute_env + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["configuration"] = configuration + __props__.__dict__["custom_image"] = custom_image + __props__.__dict__["data_studio_tool_url"] = data_studio_tool_url + __props__.__dict__["date_created"] = date_created + __props__.__dict__["description"] = description + __props__.__dict__["effective_lifespan_hours"] = effective_lifespan_hours + __props__.__dict__["initial_checkpoint_id"] = initial_checkpoint_id + __props__.__dict__["is_private"] = is_private + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["labels"] = labels + __props__.__dict__["last_started"] = last_started + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["mounted_data_links"] = mounted_data_links + __props__.__dict__["name"] = name + __props__.__dict__["parent_checkpoint"] = parent_checkpoint + __props__.__dict__["progresses"] = progresses + __props__.__dict__["session_id"] = session_id + __props__.__dict__["spot"] = spot + __props__.__dict__["status_info"] = status_info + __props__.__dict__["studio_url"] = studio_url + __props__.__dict__["template"] = template + __props__.__dict__["user"] = user + __props__.__dict__["wave_build_url"] = wave_build_url + __props__.__dict__["workspace_id"] = workspace_id + return Studios(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="activeConnections") + def active_connections(self) -> pulumi.Output[Sequence['outputs.StudiosActiveConnection']]: + return pulumi.get(self, "active_connections") + + @_builtins.property + @pulumi.getter(name="autoStart") + def auto_start(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + """ + return pulumi.get(self, "auto_start") + + @_builtins.property + @pulumi.getter(name="baseImage") + def base_image(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "base_image") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> pulumi.Output['outputs.StudiosComputeEnv']: + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def configuration(self) -> pulumi.Output['outputs.StudiosConfiguration']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "configuration") + + @_builtins.property + @pulumi.getter(name="customImage") + def custom_image(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "custom_image") + + @_builtins.property + @pulumi.getter(name="dataStudioToolUrl") + def data_studio_tool_url(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "data_studio_tool_url") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="effectiveLifespanHours") + def effective_lifespan_hours(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "effective_lifespan_hours") + + @_builtins.property + @pulumi.getter(name="initialCheckpointId") + def initial_checkpoint_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "initial_checkpoint_id") + + @_builtins.property + @pulumi.getter(name="isPrivate") + def is_private(self) -> pulumi.Output[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "is_private") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.float]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.StudiosLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastStarted") + def last_started(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_started") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="mountedDataLinks") + def mounted_data_links(self) -> pulumi.Output[Sequence['outputs.StudiosMountedDataLink']]: + return pulumi.get(self, "mounted_data_links") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="parentCheckpoint") + def parent_checkpoint(self) -> pulumi.Output['outputs.StudiosParentCheckpoint']: + return pulumi.get(self, "parent_checkpoint") + + @_builtins.property + @pulumi.getter + def progresses(self) -> pulumi.Output[Sequence['outputs.StudiosProgress']]: + return pulumi.get(self, "progresses") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> pulumi.Output[_builtins.str]: + """ + Unique identifier for the Studio session + """ + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter + def spot(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="statusInfo") + def status_info(self) -> pulumi.Output['outputs.StudiosStatusInfo']: + return pulumi.get(self, "status_info") + + @_builtins.property + @pulumi.getter(name="studioUrl") + def studio_url(self) -> pulumi.Output[_builtins.str]: + """ + URL to access the running Studio instance + """ + return pulumi.get(self, "studio_url") + + @_builtins.property + @pulumi.getter + def template(self) -> pulumi.Output['outputs.StudiosTemplate']: + return pulumi.get(self, "template") + + @_builtins.property + @pulumi.getter + def user(self) -> pulumi.Output['outputs.StudiosUser']: + return pulumi.get(self, "user") + + @_builtins.property + @pulumi.getter(name="waveBuildUrl") + def wave_build_url(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "wave_build_url") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/teams.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/teams.py new file mode 100644 index 00000000..e9d6c4bc --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/teams.py @@ -0,0 +1,337 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['TeamsArgs', 'Teams'] + +@pulumi.input_type +class TeamsArgs: + def __init__(__self__, *, + org_id: pulumi.Input[_builtins.float], + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Teams resource. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + """ + pulumi.set(__self__, "org_id", org_id) + if avatar_id is not None: + pulumi.set(__self__, "avatar_id", avatar_id) + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Input[_builtins.float]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter(name="avatarId") + def avatar_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "avatar_id") + + @avatar_id.setter + def avatar_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _TeamsState: + def __init__(__self__, *, + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + avatar_url: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + members_count: Optional[pulumi.Input[_builtins.float]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + team_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Teams resources. + :param pulumi.Input[_builtins.str] avatar_url: URL to the team's avatar or profile image + :param pulumi.Input[_builtins.float] members_count: Total number of members in the team + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.float] team_id: Unique numeric identifier for the team + """ + if avatar_id is not None: + pulumi.set(__self__, "avatar_id", avatar_id) + if avatar_url is not None: + pulumi.set(__self__, "avatar_url", avatar_url) + if description is not None: + pulumi.set(__self__, "description", description) + if members_count is not None: + pulumi.set(__self__, "members_count", members_count) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if team_id is not None: + pulumi.set(__self__, "team_id", team_id) + + @_builtins.property + @pulumi.getter(name="avatarId") + def avatar_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "avatar_id") + + @avatar_id.setter + def avatar_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar_id", value) + + @_builtins.property + @pulumi.getter(name="avatarUrl") + def avatar_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + URL to the team's avatar or profile image + """ + return pulumi.get(self, "avatar_url") + + @avatar_url.setter + def avatar_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar_url", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="membersCount") + def members_count(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Total number of members in the team + """ + return pulumi.get(self, "members_count") + + @members_count.setter + def members_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "members_count", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the team + """ + return pulumi.get(self, "team_id") + + @team_id.setter + def team_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "team_id", value) + + +@pulumi.type_token("seqera:index/teams:Teams") +class Teams(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Teams resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: TeamsArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Teams resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param TeamsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(TeamsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = TeamsArgs.__new__(TeamsArgs) + + __props__.__dict__["avatar_id"] = avatar_id + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + if org_id is None and not opts.urn: + raise TypeError("Missing required property 'org_id'") + __props__.__dict__["org_id"] = org_id + __props__.__dict__["avatar_url"] = None + __props__.__dict__["members_count"] = None + __props__.__dict__["team_id"] = None + super(Teams, __self__).__init__( + 'seqera:index/teams:Teams', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + avatar_url: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + members_count: Optional[pulumi.Input[_builtins.float]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + team_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Teams': + """ + Get an existing Teams resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] avatar_url: URL to the team's avatar or profile image + :param pulumi.Input[_builtins.float] members_count: Total number of members in the team + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.float] team_id: Unique numeric identifier for the team + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TeamsState.__new__(_TeamsState) + + __props__.__dict__["avatar_id"] = avatar_id + __props__.__dict__["avatar_url"] = avatar_url + __props__.__dict__["description"] = description + __props__.__dict__["members_count"] = members_count + __props__.__dict__["name"] = name + __props__.__dict__["org_id"] = org_id + __props__.__dict__["team_id"] = team_id + return Teams(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="avatarId") + def avatar_id(self) -> pulumi.Output[Optional[_builtins.str]]: + return pulumi.get(self, "avatar_id") + + @_builtins.property + @pulumi.getter(name="avatarUrl") + def avatar_url(self) -> pulumi.Output[_builtins.str]: + """ + URL to the team's avatar or profile image + """ + return pulumi.get(self, "avatar_url") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="membersCount") + def members_count(self) -> pulumi.Output[_builtins.float]: + """ + Total number of members in the team + """ + return pulumi.get(self, "members_count") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="teamId") + def team_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the team + """ + return pulumi.get(self, "team_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/tokens.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/tokens.py new file mode 100644 index 00000000..12f517d8 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/tokens.py @@ -0,0 +1,368 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['TokensArgs', 'Tokens'] + +@pulumi.input_type +class TokensArgs: + def __init__(__self__, *, + name: Optional[pulumi.Input[_builtins.str]] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Tokens resource. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] token_id: Token numeric identifier + """ + if name is not None: + pulumi.set(__self__, "name", name) + if token_id is not None: + pulumi.set(__self__, "token_id", token_id) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="tokenId") + def token_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Token numeric identifier + """ + return pulumi.get(self, "token_id") + + @token_id.setter + def token_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "token_id", value) + + +@pulumi.input_type +class _TokensState: + def __init__(__self__, *, + access_key: Optional[pulumi.Input[_builtins.str]] = None, + basic_auth: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + token: Optional[pulumi.Input['TokensTokenArgs']] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None, + tokens_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Tokens resources. + :param pulumi.Input[_builtins.str] basic_auth: Deprecated basic authentication string + :param pulumi.Input[_builtins.str] date_created: Timestamp when the token was created + :param pulumi.Input[_builtins.str] last_used: Timestamp when the token was last used for authentication + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input['TokensTokenArgs'] token: Represents an API access token for authentication. Contains token metadata, permissions, and expiration information for + secure API access to platform resources. + :param pulumi.Input[_builtins.float] token_id: Token numeric identifier + :param pulumi.Input[_builtins.float] tokens_id: Unique numeric identifier for the access token (nullable) + """ + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if basic_auth is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""basic_auth is deprecated: Deprecated""") + if basic_auth is not None: + pulumi.set(__self__, "basic_auth", basic_auth) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + if token is not None: + pulumi.set(__self__, "token", token) + if token_id is not None: + pulumi.set(__self__, "token_id", token_id) + if tokens_id is not None: + pulumi.set(__self__, "tokens_id", tokens_id) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "access_key") + + @access_key.setter + def access_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "access_key", value) + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Deprecated basic authentication string + """ + return pulumi.get(self, "basic_auth") + + @basic_auth.setter + def basic_auth(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "basic_auth", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the token was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the token was last used for authentication + """ + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[pulumi.Input['TokensTokenArgs']]: + """ + Represents an API access token for authentication. Contains token metadata, permissions, and expiration information for + secure API access to platform resources. + """ + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input['TokensTokenArgs']]): + pulumi.set(self, "token", value) + + @_builtins.property + @pulumi.getter(name="tokenId") + def token_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Token numeric identifier + """ + return pulumi.get(self, "token_id") + + @token_id.setter + def token_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "token_id", value) + + @_builtins.property + @pulumi.getter(name="tokensId") + def tokens_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the access token (nullable) + """ + return pulumi.get(self, "tokens_id") + + @tokens_id.setter + def tokens_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "tokens_id", value) + + +@pulumi.type_token("seqera:index/tokens:Tokens") +class Tokens(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Tokens resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] token_id: Token numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[TokensArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Tokens resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param TokensArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(TokensArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = TokensArgs.__new__(TokensArgs) + + __props__.__dict__["name"] = name + __props__.__dict__["token_id"] = token_id + __props__.__dict__["access_key"] = None + __props__.__dict__["basic_auth"] = None + __props__.__dict__["date_created"] = None + __props__.__dict__["last_used"] = None + __props__.__dict__["token"] = None + __props__.__dict__["tokens_id"] = None + super(Tokens, __self__).__init__( + 'seqera:index/tokens:Tokens', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + access_key: Optional[pulumi.Input[_builtins.str]] = None, + basic_auth: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + token: Optional[pulumi.Input[Union['TokensTokenArgs', 'TokensTokenArgsDict']]] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None, + tokens_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Tokens': + """ + Get an existing Tokens resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] basic_auth: Deprecated basic authentication string + :param pulumi.Input[_builtins.str] date_created: Timestamp when the token was created + :param pulumi.Input[_builtins.str] last_used: Timestamp when the token was last used for authentication + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[Union['TokensTokenArgs', 'TokensTokenArgsDict']] token: Represents an API access token for authentication. Contains token metadata, permissions, and expiration information for + secure API access to platform resources. + :param pulumi.Input[_builtins.float] token_id: Token numeric identifier + :param pulumi.Input[_builtins.float] tokens_id: Unique numeric identifier for the access token (nullable) + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TokensState.__new__(_TokensState) + + __props__.__dict__["access_key"] = access_key + __props__.__dict__["basic_auth"] = basic_auth + __props__.__dict__["date_created"] = date_created + __props__.__dict__["last_used"] = last_used + __props__.__dict__["name"] = name + __props__.__dict__["token"] = token + __props__.__dict__["token_id"] = token_id + __props__.__dict__["tokens_id"] = tokens_id + return Tokens(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> pulumi.Output[_builtins.str]: + """ + Deprecated basic authentication string + """ + return pulumi.get(self, "basic_auth") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + """ + Timestamp when the token was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> pulumi.Output[_builtins.str]: + """ + Timestamp when the token was last used for authentication + """ + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def token(self) -> pulumi.Output['outputs.TokensToken']: + """ + Represents an API access token for authentication. Contains token metadata, permissions, and expiration information for + secure API access to platform resources. + """ + return pulumi.get(self, "token") + + @_builtins.property + @pulumi.getter(name="tokenId") + def token_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Token numeric identifier + """ + return pulumi.get(self, "token_id") + + @_builtins.property + @pulumi.getter(name="tokensId") + def tokens_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the access token (nullable) + """ + return pulumi.get(self, "tokens_id") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/workflows.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/workflows.py new file mode 100644 index 00000000..9c7c52f1 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/workflows.py @@ -0,0 +1,1775 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['WorkflowsArgs', 'Workflows'] + +@pulumi.input_type +class WorkflowsArgs: + def __init__(__self__, *, + compute_env_id: pulumi.Input[_builtins.str], + pipeline: pulumi.Input[_builtins.str], + work_dir: pulumi.Input[_builtins.str], + workspace_id: pulumi.Input[_builtins.float], + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + The set of arguments for constructing a Workflows resource. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] force: Force the deletion even if the workflow is active + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.float] source_workspace_id: Source Optional workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + pulumi.set(__self__, "workspace_id", workspace_id) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if force is not None: + pulumi.set(__self__, "force", force) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if source_workspace_id is not None: + pulumi.set(__self__, "source_workspace_id", source_workspace_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def pipeline(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @pipeline.setter + def pipeline(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "pipeline", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @config_profiles.setter + def config_profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_profiles", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @entry_name.setter + def entry_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "entry_name", value) + + @_builtins.property + @pulumi.getter + def force(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Force the deletion even if the workflow is active + """ + return pulumi.get(self, "force") + + @force.setter + def force(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "force", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @launch_container.setter + def launch_container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_container", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @params_text.setter + def params_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "params_text", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @pull_latest.setter + def pull_latest(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "pull_latest", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @schema_name.setter + def schema_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "schema_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="sourceWorkspaceId") + def source_workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Source Optional workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "source_workspace_id") + + @source_workspace_id.setter + def source_workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "source_workspace_id", value) + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @stub_run.setter + def stub_run(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "stub_run", value) + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @tower_config.setter + def tower_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tower_config", value) + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @user_secrets.setter + def user_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "user_secrets", value) + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + + @workspace_secrets.setter + def workspace_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "workspace_secrets", value) + + +@pulumi.input_type +class _WorkflowsState: + def __init__(__self__, *, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + job_info: Optional[pulumi.Input['WorkflowsJobInfoArgs']] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsLabelArgs']]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + messages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + optimized: Optional[pulumi.Input[_builtins.bool]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + org_name: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + pipeline: Optional[pulumi.Input[_builtins.str]] = None, + platform: Optional[pulumi.Input['WorkflowsPlatformArgs']] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + progress: Optional[pulumi.Input['WorkflowsProgressArgs']] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + workflow: Optional[pulumi.Input['WorkflowsWorkflowArgs']] = None, + workflow_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + Input properties used for looking up and filtering Workflows resources. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] force: Force the deletion even if the workflow is active + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.float] source_workspace_id: Source Optional workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.str] workflow_id: Workflow string identifier + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if force is not None: + pulumi.set(__self__, "force", force) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if job_info is not None: + pulumi.set(__self__, "job_info", job_info) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if messages is not None: + pulumi.set(__self__, "messages", messages) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if optimized is not None: + pulumi.set(__self__, "optimized", optimized) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if org_name is not None: + pulumi.set(__self__, "org_name", org_name) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if pipeline is not None: + pulumi.set(__self__, "pipeline", pipeline) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if progress is not None: + pulumi.set(__self__, "progress", progress) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if source_workspace_id is not None: + pulumi.set(__self__, "source_workspace_id", source_workspace_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if workflow is not None: + pulumi.set(__self__, "workflow", workflow) + if workflow_id is not None: + pulumi.set(__self__, "workflow_id", workflow_id) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + if workspace_name is not None: + pulumi.set(__self__, "workspace_name", workspace_name) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @config_profiles.setter + def config_profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_profiles", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @entry_name.setter + def entry_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "entry_name", value) + + @_builtins.property + @pulumi.getter + def force(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Force the deletion even if the workflow is active + """ + return pulumi.get(self, "force") + + @force.setter + def force(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "force", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="jobInfo") + def job_info(self) -> Optional[pulumi.Input['WorkflowsJobInfoArgs']]: + return pulumi.get(self, "job_info") + + @job_info.setter + def job_info(self, value: Optional[pulumi.Input['WorkflowsJobInfoArgs']]): + pulumi.set(self, "job_info", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @launch_container.setter + def launch_container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_container", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter + def messages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "messages") + + @messages.setter + def messages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "messages", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter + def optimized(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "optimized") + + @optimized.setter + def optimized(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "optimized", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "org_name") + + @org_name.setter + def org_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "org_name", value) + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @params_text.setter + def params_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "params_text", value) + + @_builtins.property + @pulumi.getter + def pipeline(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @pipeline.setter + def pipeline(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pipeline", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[pulumi.Input['WorkflowsPlatformArgs']]: + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: Optional[pulumi.Input['WorkflowsPlatformArgs']]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def progress(self) -> Optional[pulumi.Input['WorkflowsProgressArgs']]: + return pulumi.get(self, "progress") + + @progress.setter + def progress(self, value: Optional[pulumi.Input['WorkflowsProgressArgs']]): + pulumi.set(self, "progress", value) + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @pull_latest.setter + def pull_latest(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "pull_latest", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @schema_name.setter + def schema_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "schema_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="sourceWorkspaceId") + def source_workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Source Optional workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "source_workspace_id") + + @source_workspace_id.setter + def source_workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "source_workspace_id", value) + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @stub_run.setter + def stub_run(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "stub_run", value) + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @tower_config.setter + def tower_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tower_config", value) + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @user_secrets.setter + def user_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "user_secrets", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter + def workflow(self) -> Optional[pulumi.Input['WorkflowsWorkflowArgs']]: + return pulumi.get(self, "workflow") + + @workflow.setter + def workflow(self, value: Optional[pulumi.Input['WorkflowsWorkflowArgs']]): + pulumi.set(self, "workflow", value) + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Workflow string identifier + """ + return pulumi.get(self, "workflow_id") + + @workflow_id.setter + def workflow_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "workflow_id", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "workspace_name") + + @workspace_name.setter + def workspace_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "workspace_name", value) + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + + @workspace_secrets.setter + def workspace_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "workspace_secrets", value) + + +@pulumi.type_token("seqera:index/workflows:Workflows") +class Workflows(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + pipeline: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + __props__=None): + """ + Create a Workflows resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] force: Force the deletion even if the workflow is active + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.float] source_workspace_id: Source Optional workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: WorkflowsArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Workflows resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param WorkflowsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(WorkflowsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + pipeline: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = WorkflowsArgs.__new__(WorkflowsArgs) + + if compute_env_id is None and not opts.urn: + raise TypeError("Missing required property 'compute_env_id'") + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["config_profiles"] = config_profiles + __props__.__dict__["config_text"] = config_text + __props__.__dict__["date_created"] = date_created + __props__.__dict__["entry_name"] = entry_name + __props__.__dict__["force"] = force + __props__.__dict__["head_job_cpus"] = head_job_cpus + __props__.__dict__["head_job_memory_mb"] = head_job_memory_mb + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["launch_container"] = launch_container + __props__.__dict__["main_script"] = main_script + __props__.__dict__["optimization_id"] = optimization_id + __props__.__dict__["optimization_targets"] = optimization_targets + __props__.__dict__["params_text"] = params_text + if pipeline is None and not opts.urn: + raise TypeError("Missing required property 'pipeline'") + __props__.__dict__["pipeline"] = pipeline + __props__.__dict__["post_run_script"] = post_run_script + __props__.__dict__["pre_run_script"] = pre_run_script + __props__.__dict__["pull_latest"] = pull_latest + __props__.__dict__["resume"] = resume + __props__.__dict__["revision"] = revision + __props__.__dict__["run_name"] = run_name + __props__.__dict__["schema_name"] = schema_name + __props__.__dict__["session_id"] = session_id + __props__.__dict__["source_workspace_id"] = source_workspace_id + __props__.__dict__["stub_run"] = stub_run + __props__.__dict__["tower_config"] = tower_config + __props__.__dict__["user_secrets"] = user_secrets + if work_dir is None and not opts.urn: + raise TypeError("Missing required property 'work_dir'") + __props__.__dict__["work_dir"] = work_dir + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["workspace_secrets"] = workspace_secrets + __props__.__dict__["job_info"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["messages"] = None + __props__.__dict__["optimized"] = None + __props__.__dict__["org_id"] = None + __props__.__dict__["org_name"] = None + __props__.__dict__["platform"] = None + __props__.__dict__["progress"] = None + __props__.__dict__["workflow"] = None + __props__.__dict__["workflow_id"] = None + __props__.__dict__["workspace_name"] = None + super(Workflows, __self__).__init__( + 'seqera:index/workflows:Workflows', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + job_info: Optional[pulumi.Input[Union['WorkflowsJobInfoArgs', 'WorkflowsJobInfoArgsDict']]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['WorkflowsLabelArgs', 'WorkflowsLabelArgsDict']]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + messages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + optimized: Optional[pulumi.Input[_builtins.bool]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + org_name: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + pipeline: Optional[pulumi.Input[_builtins.str]] = None, + platform: Optional[pulumi.Input[Union['WorkflowsPlatformArgs', 'WorkflowsPlatformArgsDict']]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + progress: Optional[pulumi.Input[Union['WorkflowsProgressArgs', 'WorkflowsProgressArgsDict']]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + workflow: Optional[pulumi.Input[Union['WorkflowsWorkflowArgs', 'WorkflowsWorkflowArgsDict']]] = None, + workflow_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'Workflows': + """ + Get an existing Workflows resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] force: Force the deletion even if the workflow is active + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.float] source_workspace_id: Source Optional workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.str] workflow_id: Workflow string identifier + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _WorkflowsState.__new__(_WorkflowsState) + + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["config_profiles"] = config_profiles + __props__.__dict__["config_text"] = config_text + __props__.__dict__["date_created"] = date_created + __props__.__dict__["entry_name"] = entry_name + __props__.__dict__["force"] = force + __props__.__dict__["head_job_cpus"] = head_job_cpus + __props__.__dict__["head_job_memory_mb"] = head_job_memory_mb + __props__.__dict__["job_info"] = job_info + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["labels"] = labels + __props__.__dict__["launch_container"] = launch_container + __props__.__dict__["main_script"] = main_script + __props__.__dict__["messages"] = messages + __props__.__dict__["optimization_id"] = optimization_id + __props__.__dict__["optimization_targets"] = optimization_targets + __props__.__dict__["optimized"] = optimized + __props__.__dict__["org_id"] = org_id + __props__.__dict__["org_name"] = org_name + __props__.__dict__["params_text"] = params_text + __props__.__dict__["pipeline"] = pipeline + __props__.__dict__["platform"] = platform + __props__.__dict__["post_run_script"] = post_run_script + __props__.__dict__["pre_run_script"] = pre_run_script + __props__.__dict__["progress"] = progress + __props__.__dict__["pull_latest"] = pull_latest + __props__.__dict__["resume"] = resume + __props__.__dict__["revision"] = revision + __props__.__dict__["run_name"] = run_name + __props__.__dict__["schema_name"] = schema_name + __props__.__dict__["session_id"] = session_id + __props__.__dict__["source_workspace_id"] = source_workspace_id + __props__.__dict__["stub_run"] = stub_run + __props__.__dict__["tower_config"] = tower_config + __props__.__dict__["user_secrets"] = user_secrets + __props__.__dict__["work_dir"] = work_dir + __props__.__dict__["workflow"] = workflow + __props__.__dict__["workflow_id"] = workflow_id + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["workspace_name"] = workspace_name + __props__.__dict__["workspace_secrets"] = workspace_secrets + return Workflows(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @_builtins.property + @pulumi.getter + def force(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Force the deletion even if the workflow is active + """ + return pulumi.get(self, "force") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="jobInfo") + def job_info(self) -> pulumi.Output['outputs.WorkflowsJobInfo']: + return pulumi.get(self, "job_info") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.float]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.WorkflowsLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter + def messages(self) -> pulumi.Output[Sequence[_builtins.str]]: + return pulumi.get(self, "messages") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter + def optimized(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "optimized") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @_builtins.property + @pulumi.getter + def pipeline(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @_builtins.property + @pulumi.getter + def platform(self) -> pulumi.Output['outputs.WorkflowsPlatform']: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def progress(self) -> pulumi.Output['outputs.WorkflowsProgress']: + return pulumi.get(self, "progress") + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @_builtins.property + @pulumi.getter + def resume(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter + def revision(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="sourceWorkspaceId") + def source_workspace_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Source Optional workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "source_workspace_id") + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def workflow(self) -> pulumi.Output['outputs.WorkflowsWorkflow']: + return pulumi.get(self, "workflow") + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> pulumi.Output[_builtins.str]: + """ + Workflow string identifier + """ + return pulumi.get(self, "workflow_id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "workspace_name") + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + diff --git a/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/workspace.py b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/workspace.py new file mode 100644 index 00000000..698783d1 --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/sdks/seqera/pulumi_seqera/workspace.py @@ -0,0 +1,443 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['WorkspaceArgs', 'Workspace'] + +@pulumi.input_type +class WorkspaceArgs: + def __init__(__self__, *, + full_name: pulumi.Input[_builtins.str], + org_id: pulumi.Input[_builtins.float], + visibility: pulumi.Input[_builtins.str], + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Workspace resource. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.str] visibility: must be one of ["PRIVATE", "SHARED"] + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] last_updated: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Optional workspace numeric identifier + """ + pulumi.set(__self__, "full_name", full_name) + pulumi.set(__self__, "org_id", org_id) + pulumi.set(__self__, "visibility", visibility) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if description is not None: + pulumi.set(__self__, "description", description) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if name is not None: + pulumi.set(__self__, "name", name) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "full_name") + + @full_name.setter + def full_name(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "full_name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Input[_builtins.float]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + def visibility(self) -> pulumi.Input[_builtins.str]: + """ + must be one of ["PRIVATE", "SHARED"] + """ + return pulumi.get(self, "visibility") + + @visibility.setter + def visibility(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "visibility", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Optional workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _WorkspaceState: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Workspace resources. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] last_updated: Requires replacement if changed. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.str] visibility: must be one of ["PRIVATE", "SHARED"] + :param pulumi.Input[_builtins.float] workspace_id: Optional workspace numeric identifier + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if description is not None: + pulumi.set(__self__, "description", description) + if full_name is not None: + pulumi.set(__self__, "full_name", full_name) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if visibility is not None: + pulumi.set(__self__, "visibility", visibility) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "full_name") + + @full_name.setter + def full_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "full_name", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + def visibility(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["PRIVATE", "SHARED"] + """ + return pulumi.get(self, "visibility") + + @visibility.setter + def visibility(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "visibility", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Optional workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/workspace:Workspace") +class Workspace(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Workspace resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] last_updated: Requires replacement if changed. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.str] visibility: must be one of ["PRIVATE", "SHARED"] + :param pulumi.Input[_builtins.float] workspace_id: Optional workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: WorkspaceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Workspace resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param WorkspaceArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(WorkspaceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = WorkspaceArgs.__new__(WorkspaceArgs) + + __props__.__dict__["date_created"] = date_created + __props__.__dict__["description"] = description + if full_name is None and not opts.urn: + raise TypeError("Missing required property 'full_name'") + __props__.__dict__["full_name"] = full_name + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["name"] = name + if org_id is None and not opts.urn: + raise TypeError("Missing required property 'org_id'") + __props__.__dict__["org_id"] = org_id + if visibility is None and not opts.urn: + raise TypeError("Missing required property 'visibility'") + __props__.__dict__["visibility"] = visibility + __props__.__dict__["workspace_id"] = workspace_id + super(Workspace, __self__).__init__( + 'seqera:index/workspace:Workspace', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Workspace': + """ + Get an existing Workspace resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] last_updated: Requires replacement if changed. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.str] visibility: must be one of ["PRIVATE", "SHARED"] + :param pulumi.Input[_builtins.float] workspace_id: Optional workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _WorkspaceState.__new__(_WorkspaceState) + + __props__.__dict__["date_created"] = date_created + __props__.__dict__["description"] = description + __props__.__dict__["full_name"] = full_name + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["name"] = name + __props__.__dict__["org_id"] = org_id + __props__.__dict__["visibility"] = visibility + __props__.__dict__["workspace_id"] = workspace_id + return Workspace(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def visibility(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["PRIVATE", "SHARED"] + """ + return pulumi.get(self, "visibility") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Optional workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/awsmegatests/workspace_config.py b/pulumi/seqera_platform/awsmegatests/workspace_config.py new file mode 100644 index 00000000..1983dc5f --- /dev/null +++ b/pulumi/seqera_platform/awsmegatests/workspace_config.py @@ -0,0 +1,55 @@ +"""Configuration specific to the AWS Megatests workspace""" + +from typing import Dict, Any + + +def get_workspace_config() -> Dict[str, Any]: + """ + Get workspace-specific configuration for AWS Megatests. + + Returns: + Dict containing workspace settings including compute environment configuration + """ + return { + "workspace_name": "AWSmegatests", + "organization_name": "nf-core", + "description": "Workspace for nf-core AWS megatests infrastructure", + + # Compute environment configuration + "compute_environments": { + "cpu": { + "enabled": True, + "name": "aws_ireland_fusionv2_nvme_cpu", + "instance_types": ["c6id", "m6id", "r6id"], + "max_cpus": 500, + }, + "gpu": { + "enabled": True, + "name": "aws_ireland_fusionv2_nvme_gpu", + "instance_types": ["g4dn", "g5"], + "max_cpus": 500, + }, + "arm": { + "enabled": True, + "name": "aws_ireland_fusionv2_nvme_arm", + "instance_types": ["c6gd", "m6gd", "r6gd"], + "max_cpus": 500, + }, + }, + + # AWS configuration + "aws_region": "eu-west-1", + "s3_bucket_name": "nf-core-awsmegatests", + + # GitHub integration + "github_integration": { + "enabled": True, + "organization": "nf-core", + }, + + # Workspace participants + "workspace_participants": { + "enabled": True, + "teams": ["nf-core", "nf-core-maintainers"], + }, + } diff --git a/pulumi/seqera_platform/resource_optimization/.gitignore b/pulumi/seqera_platform/resource_optimization/.gitignore new file mode 100644 index 00000000..5e8e899e --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/.gitignore @@ -0,0 +1,10 @@ +*.pyc +__pycache__/ +venv/ +.venv/ +*.egg-info/ +dist/ +build/ +.pulumi/ +Pulumi.*.yaml +!Pulumi.yaml diff --git a/pulumi/seqera_platform/resource_optimization/Pulumi.yaml b/pulumi/seqera_platform/resource_optimization/Pulumi.yaml new file mode 100644 index 00000000..b02e03cd --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/Pulumi.yaml @@ -0,0 +1,11 @@ +name: seqera-resource-optimization +runtime: + name: python + options: + virtualenv: .venv +description: Seqera Platform workspace for resource optimization testing +config: + pulumi:tags: + value: + pulumi:template: seqera-platform-workspace + workspace: resource-optimization diff --git a/pulumi/seqera_platform/resource_optimization/README.md b/pulumi/seqera_platform/resource_optimization/README.md new file mode 100644 index 00000000..3642225e --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/README.md @@ -0,0 +1,188 @@ +# Resource Optimization Workspace + +Seqera Platform workspace for resource optimization testing and analysis. + +## Overview + +This workspace provides a focused testing environment for analyzing and optimizing pipeline resource requirements. It includes: + +- **CPU-Only Compute Environment**: Single compute environment for resource profiling +- **S3 Storage**: Dedicated bucket for test results +- **Minimal Configuration**: Streamlined setup for resource analysis +- **TowerForge Credentials**: IAM user and policies for compute environment access + +Unlike the full AWS Megatests workspace, this workspace intentionally omits GPU and ARM compute environments to focus specifically on CPU resource optimization work. + +## Configuration + +The workspace configuration is defined in `workspace_config.py`: + +- **Workspace Name**: ResourceOptimization +- **Organization**: nf-core +- **AWS Region**: eu-west-1 +- **S3 Bucket**: nf-core-resource-optimization + +### Compute Environments + +1. **CPU Environment** (Only) + - Instance types: c6id, m6id, r6id + - Max CPUs: 500 + - Fusion v2 with NVMe storage + - SPOT provisioning model + +**Note**: GPU and ARM environments are explicitly disabled for this workspace. + +## Deployment + +### Prerequisites + +1. Python 3.12+ +2. uv package manager +3. Pulumi CLI +4. AWS credentials +5. Seqera Platform access token + +### Initial Setup + +```bash +# Install dependencies +uv sync + +# Login to Pulumi +pulumi login + +# Create a new stack +pulumi stack init prod + +# Configure ESC environment +# Edit Pulumi..yaml to reference ESC environment +``` + +### Deploy Infrastructure + +```bash +# Preview changes +uv run pulumi preview + +# Deploy +uv run pulumi up + +# View outputs +uv run pulumi stack output +``` + +## Outputs + +The stack exports: + +- `workspace`: Workspace details (name, organization, ID, description) +- `s3_bucket`: S3 bucket information +- `compute_env_ids`: IDs of compute environment (CPU only) +- `terraform_resources`: CPU compute environment ID +- `workspace_participants`: Team member sync status (if enabled) + +**Note**: GitHub integration outputs are omitted as GitHub integration is disabled by default. + +## Structure + +``` +resource_optimization/ +├── __main__.py # Main Pulumi program +├── workspace_config.py # Workspace-specific configuration +├── Pulumi.yaml # Pulumi project definition +├── pyproject.toml # Python dependencies +├── requirements.txt # Alternative dependency specification +└── .gitignore # Git ignore patterns +``` + +## Shared Modules + +This workspace uses shared modules from `../shared/`: +- `providers/`: AWS, Seqera providers +- `infrastructure/`: S3, IAM, compute environments +- `config/`: Configuration management +- `utils/`: Helper functions + +## Use Cases + +This workspace is designed for: + +1. **Resource Profiling**: Running pipelines with detailed resource monitoring +2. **Optimization Testing**: Testing resource requirement adjustments +3. **Cost Analysis**: Analyzing compute costs for different configurations +4. **Performance Benchmarking**: Comparing execution times across instance types + +## Customization + +### Enabling GitHub Integration + +Edit `workspace_config.py`: + +```python +"github_integration": { + "enabled": True, # Change from False + "organization": "nf-core", +} +``` + +### Adjusting Compute Limits + +Edit `workspace_config.py`: + +```python +"compute_environments": { + "cpu": { + "enabled": True, + "max_cpus": 1000, # Increase from 500 + ... + } +} +``` + +### Adding GPU or ARM Support + +If resource optimization work expands to include GPU or ARM: + +```python +"compute_environments": { + "cpu": {...}, + "gpu": { + "enabled": True, # Change from False + "name": "aws_ireland_fusionv2_nvme_gpu", + "instance_types": ["g4dn", "g5"], + "max_cpus": 500, + }, +} +``` + +## Maintenance + +### Resource Monitoring + +Monitor resource usage through: +1. Seqera Platform dashboard +2. CloudWatch metrics +3. S3 bucket analytics + +### Cost Optimization + +- Review instance type usage +- Adjust max_cpus based on actual usage +- Consider SPOT vs on-demand mix + +## Troubleshooting + +**Issue**: Import errors from shared modules +**Solution**: The `__main__.py` automatically adds `../shared` to the Python path. Ensure the shared directory exists. + +**Issue**: Compute environment not deploying +**Solution**: Verify `TOWER_ACCESS_TOKEN` and workspace ID in ESC configuration. + +**Issue**: S3 bucket creation fails +**Solution**: Check if bucket name is globally unique and region is correct. + +## Related Documentation + +- [Main Seqera Platform README](../README.md) +- [Shared Module Documentation](../shared/README.md) +- [AWS Megatests Workspace](../awsmegatests/README.md) diff --git a/pulumi/seqera_platform/resource_optimization/__init__.py b/pulumi/seqera_platform/resource_optimization/__init__.py new file mode 100644 index 00000000..9e41c308 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/__init__.py @@ -0,0 +1 @@ +"""Seqera Platform Resource Optimization workspace""" diff --git a/pulumi/seqera_platform/resource_optimization/__main__.py b/pulumi/seqera_platform/resource_optimization/__main__.py new file mode 100644 index 00000000..174742f4 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/__main__.py @@ -0,0 +1,190 @@ +"""Pulumi program for Seqera Platform - Resource Optimization workspace""" + +import sys +from pathlib import Path + +# Add shared module to Python path +shared_path = Path(__file__).parent.parent / "shared" +sys.path.insert(0, str(shared_path)) + +# Add sdks directory to Python path for pulumi_seqera +sdks_path = Path(__file__).parent / "sdks" / "seqera" +sys.path.insert(0, str(sdks_path)) + +import pulumi + +# Import shared modules +from providers import ( + create_aws_provider, + create_github_provider, + create_seqera_provider, +) +from config import get_configuration +from infrastructure import create_s3_infrastructure, create_towerforge_credentials +from infrastructure import ( + deploy_seqera_environments_terraform, + get_compute_environment_ids_terraform, +) +from integrations import create_github_resources, create_github_credential +from integrations.workspace_participants_command import ( + create_individual_member_commands, +) + +# Import workspace-specific configuration +from workspace_config import get_workspace_config + + +def main(): + """Main Pulumi program function for Resource Optimization workspace""" + + # Get workspace-specific configuration + workspace_config = get_workspace_config() + + # Get ESC configuration + config = get_configuration() + + # Create providers + aws_provider = create_aws_provider() + seqera_provider = create_seqera_provider(config) + + # Only create GitHub provider if GitHub integration is enabled + github_provider = None + github_credential = None + github_credential_id = None + if workspace_config["github_integration"]["enabled"]: + github_provider = create_github_provider(config["github_token"]) + # Create GitHub credential in Seqera Platform + github_credential, github_credential_id = create_github_credential( + seqera_provider=seqera_provider, + workspace_id=int(config["tower_workspace_id"]), + github_token=config.get("platform_github_org_token", ""), + ) + + # Set up S3 infrastructure with workspace-specific bucket name + # Create new bucket (don't import existing) for this workspace + s3_resources = create_s3_infrastructure( + aws_provider, + bucket_name=workspace_config["s3_bucket_name"], + import_existing=False + ) + resource_opt_bucket = s3_resources["bucket"] + + # Create TowerForge IAM credentials and upload to Seqera Platform + # Use workspace name to create unique IAM resource names + ( + towerforge_access_key_id, + towerforge_access_key_secret, + seqera_credentials_id, + seqera_credential_resource, + iam_policy_hash, + ) = create_towerforge_credentials( + aws_provider, + resource_opt_bucket, + seqera_provider, + float(config["tower_workspace_id"]), + workspace_name=workspace_config["workspace_name"], + ) + + # Deploy Seqera Platform compute environments (CPU only for this workspace) + # workspace_config controls which environments are deployed + terraform_resources = deploy_seqera_environments_terraform( + config, + seqera_credentials_id, + seqera_provider, + seqera_credential_resource, + iam_policy_hash, + workspace_config=workspace_config, + ) + + # Get compute environment IDs + compute_env_ids = get_compute_environment_ids_terraform(terraform_resources) + deployment_method = "terraform-provider" + + # Create GitHub resources only if enabled + github_resources = {} + if workspace_config["github_integration"]["enabled"] and github_provider: + github_resources = create_github_resources( + github_provider, + compute_env_ids, + config["tower_workspace_id"], + tower_access_token=config["tower_access_token"], + ) + + # Add workspace participants if enabled + if workspace_config["workspace_participants"]["enabled"]: + setup_cmd, member_commands = create_individual_member_commands( + workspace_id=int(config["tower_workspace_id"]), + token=config["tower_access_token"], + github_token=config["github_token"], + opts=pulumi.ResourceOptions(depends_on=[seqera_credential_resource]), + ) + + pulumi.export( + "workspace_participants", + { + "setup_command_id": setup_cmd.id, + "individual_member_commands": { + username: {"command_id": cmd.id, "github_username": username} + for username, cmd in member_commands.items() + }, + "total_tracked_members": len(member_commands), + }, + ) + + # Exports + pulumi.export( + "workspace", + { + "name": workspace_config["workspace_name"], + "organization": workspace_config["organization_name"], + "workspace_id": config["tower_workspace_id"], + "description": workspace_config["description"], + }, + ) + + pulumi.export( + "s3_bucket", + { + "name": resource_opt_bucket.bucket, + "arn": resource_opt_bucket.arn, + "region": workspace_config["aws_region"], + }, + ) + + if github_resources: + pulumi.export( + "github_resources", + { + "variables": { + k: v.id for k, v in github_resources.get("variables", {}).items() + } + if github_resources.get("variables") + else {}, + "secrets": {k: v.id for k, v in github_resources.get("secrets", {}).items()} + if github_resources.get("secrets") + else {}, + }, + ) + + pulumi.export("compute_env_ids", compute_env_ids) + pulumi.export("deployment_method", deployment_method) + + if github_credential_id: + pulumi.export( + "github_credential", + { + "credential_id": github_credential_id, + "credential_name": "nf-core-github-finegrained", + }, + ) + + # Only export enabled compute environments + terraform_exports = {} + if workspace_config["compute_environments"]["cpu"]["enabled"]: + terraform_exports["cpu_env_id"] = terraform_resources["cpu_env"].compute_env_id + + pulumi.export("terraform_resources", terraform_exports) + + +if __name__ == "__main__": + main() diff --git a/pulumi/seqera_platform/resource_optimization/pyproject.toml b/pulumi/seqera_platform/resource_optimization/pyproject.toml new file mode 100644 index 00000000..023f7cb7 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/pyproject.toml @@ -0,0 +1,13 @@ +[project] +name = "seqera-resource-optimization" +version = "0.1.0" +description = "Pulumi project for Seqera Platform - Resource Optimization workspace" +readme = "README.md" +requires-python = ">=3.12" +dependencies = [ + "pulumi>=3.173.0,<4.0.0", + "pulumi-aws>=6.81.0,<7.0.0", + "pulumi-github>=6.4.0,<7.0.0", + "pulumi-command>=1.0.1,<2.0.0", + # pulumi-seqera is not on PyPI, loaded from sdks/ directory via sys.path +] diff --git a/pulumi/seqera_platform/resource_optimization/requirements.txt b/pulumi/seqera_platform/resource_optimization/requirements.txt new file mode 100644 index 00000000..eedf217e --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/requirements.txt @@ -0,0 +1,5 @@ +pulumi>=3.173.0,<4.0.0 +pulumi-aws>=6.81.0,<7.0.0 +pulumi-github>=6.4.0,<7.0.0 +pulumi-command>=1.0.1,<2.0.0 +# pulumi-seqera is not on PyPI, loaded from sdks/ directory via sys.path diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera-0.25.2.dist-info/direct_url.json b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera-0.25.2.dist-info/direct_url.json new file mode 100644 index 00000000..c2b07c40 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera-0.25.2.dist-info/direct_url.json @@ -0,0 +1 @@ +{"url":"file:///Users/edmundmiller/src/nf-core/ops/pulumi/AWSMegatests/sdks/seqera","dir_info":{}} \ No newline at end of file diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera-0.25.2.dist-info/uv_cache.json b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera-0.25.2.dist-info/uv_cache.json new file mode 100644 index 00000000..f65d87c2 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera-0.25.2.dist-info/uv_cache.json @@ -0,0 +1 @@ +{"timestamp":{"secs_since_epoch":1754967841,"nanos_since_epoch":642471435},"commit":null,"tags":null} \ No newline at end of file diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/__init__.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/__init__.py new file mode 100644 index 00000000..b6e2641f --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/__init__.py @@ -0,0 +1,178 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +from . import _utilities +import typing +# Export this package's modules as members: +from .action import * +from .compute_env import * +from .credential import * +from .data_link import * +from .datasets import * +from .get_action import * +from .get_compute_env import * +from .get_credential import * +from .get_data_link import * +from .get_dataset import * +from .get_labels import * +from .get_orgs import * +from .get_pipeline import * +from .get_pipeline_secret import * +from .get_studios import * +from .get_teams import * +from .get_tokens import * +from .get_user import * +from .get_user_workspaces import * +from .get_workflows import * +from .get_workspace import * +from .get_workspaces import * +from .labels import * +from .orgs import * +from .pipeline import * +from .pipeline_secret import * +from .provider import * +from .studios import * +from .teams import * +from .tokens import * +from .workflows import * +from .workspace import * +from ._inputs import * +from . import outputs + +# Make subpackages available: +if typing.TYPE_CHECKING: + import pulumi_seqera.config as __config + config = __config +else: + config = _utilities.lazy_import('pulumi_seqera.config') + +_utilities.register( + resource_modules=""" +[ + { + "pkg": "seqera", + "mod": "index/action", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/action:Action": "Action" + } + }, + { + "pkg": "seqera", + "mod": "index/computeEnv", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/computeEnv:ComputeEnv": "ComputeEnv" + } + }, + { + "pkg": "seqera", + "mod": "index/credential", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/credential:Credential": "Credential" + } + }, + { + "pkg": "seqera", + "mod": "index/dataLink", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/dataLink:DataLink": "DataLink" + } + }, + { + "pkg": "seqera", + "mod": "index/datasets", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/datasets:Datasets": "Datasets" + } + }, + { + "pkg": "seqera", + "mod": "index/labels", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/labels:Labels": "Labels" + } + }, + { + "pkg": "seqera", + "mod": "index/orgs", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/orgs:Orgs": "Orgs" + } + }, + { + "pkg": "seqera", + "mod": "index/pipeline", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/pipeline:Pipeline": "Pipeline" + } + }, + { + "pkg": "seqera", + "mod": "index/pipelineSecret", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/pipelineSecret:PipelineSecret": "PipelineSecret" + } + }, + { + "pkg": "seqera", + "mod": "index/studios", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/studios:Studios": "Studios" + } + }, + { + "pkg": "seqera", + "mod": "index/teams", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/teams:Teams": "Teams" + } + }, + { + "pkg": "seqera", + "mod": "index/tokens", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/tokens:Tokens": "Tokens" + } + }, + { + "pkg": "seqera", + "mod": "index/workflows", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/workflows:Workflows": "Workflows" + } + }, + { + "pkg": "seqera", + "mod": "index/workspace", + "fqn": "pulumi_seqera", + "classes": { + "seqera:index/workspace:Workspace": "Workspace" + } + } +] +""", + resource_packages=""" +[ + { + "pkg": "seqera", + "token": "pulumi:providers:seqera", + "fqn": "pulumi_seqera", + "class": "Provider" + } +] +""" +) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/_inputs.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/_inputs.py new file mode 100644 index 00000000..73e0319e --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/_inputs.py @@ -0,0 +1,21335 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'ActionConfigArgs', + 'ActionConfigArgsDict', + 'ActionConfigGithubArgs', + 'ActionConfigGithubArgsDict', + 'ActionConfigTowerArgs', + 'ActionConfigTowerArgsDict', + 'ActionEventArgs', + 'ActionEventArgsDict', + 'ActionEventGithubArgs', + 'ActionEventGithubArgsDict', + 'ActionEventTowerArgs', + 'ActionEventTowerArgsDict', + 'ActionLabelArgs', + 'ActionLabelArgsDict', + 'ActionLaunchArgs', + 'ActionLaunchArgsDict', + 'ActionLaunchComputeEnvArgs', + 'ActionLaunchComputeEnvArgsDict', + 'ActionLaunchComputeEnvConfigArgs', + 'ActionLaunchComputeEnvConfigArgsDict', + 'ActionLaunchComputeEnvConfigAltairPlatformArgs', + 'ActionLaunchComputeEnvConfigAltairPlatformArgsDict', + 'ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigAwsBatchArgs', + 'ActionLaunchComputeEnvConfigAwsBatchArgsDict', + 'ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs', + 'ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigAwsBatchForgeArgs', + 'ActionLaunchComputeEnvConfigAwsBatchForgeArgsDict', + 'ActionLaunchComputeEnvConfigAwsCloudArgs', + 'ActionLaunchComputeEnvConfigAwsCloudArgsDict', + 'ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs', + 'ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigAzureBatchArgs', + 'ActionLaunchComputeEnvConfigAzureBatchArgsDict', + 'ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs', + 'ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigAzureBatchForgeArgs', + 'ActionLaunchComputeEnvConfigAzureBatchForgeArgsDict', + 'ActionLaunchComputeEnvConfigEksPlatformArgs', + 'ActionLaunchComputeEnvConfigEksPlatformArgsDict', + 'ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigGkePlatformArgs', + 'ActionLaunchComputeEnvConfigGkePlatformArgsDict', + 'ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigGoogleBatchArgs', + 'ActionLaunchComputeEnvConfigGoogleBatchArgsDict', + 'ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs', + 'ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesArgs', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesArgsDict', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigK8sPlatformArgs', + 'ActionLaunchComputeEnvConfigK8sPlatformArgsDict', + 'ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigLsfPlatformArgs', + 'ActionLaunchComputeEnvConfigLsfPlatformArgsDict', + 'ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigMoabPlatformArgs', + 'ActionLaunchComputeEnvConfigMoabPlatformArgsDict', + 'ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformArgsDict', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgsDict', + 'ActionLaunchComputeEnvConfigSlurmPlatformArgs', + 'ActionLaunchComputeEnvConfigSlurmPlatformArgsDict', + 'ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgsDict', + 'ActionLaunchComputeEnvConfigUgePlatformArgs', + 'ActionLaunchComputeEnvConfigUgePlatformArgsDict', + 'ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs', + 'ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvArgs', + 'ComputeEnvComputeEnvArgsDict', + 'ComputeEnvComputeEnvConfigArgs', + 'ComputeEnvComputeEnvConfigArgsDict', + 'ComputeEnvComputeEnvConfigAltairPlatformArgs', + 'ComputeEnvComputeEnvConfigAltairPlatformArgsDict', + 'ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigAwsBatchArgs', + 'ComputeEnvComputeEnvConfigAwsBatchArgsDict', + 'ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs', + 'ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigAwsBatchForgeArgs', + 'ComputeEnvComputeEnvConfigAwsBatchForgeArgsDict', + 'ComputeEnvComputeEnvConfigAwsCloudArgs', + 'ComputeEnvComputeEnvConfigAwsCloudArgsDict', + 'ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs', + 'ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigAzureBatchArgs', + 'ComputeEnvComputeEnvConfigAzureBatchArgsDict', + 'ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs', + 'ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigAzureBatchForgeArgs', + 'ComputeEnvComputeEnvConfigAzureBatchForgeArgsDict', + 'ComputeEnvComputeEnvConfigEksPlatformArgs', + 'ComputeEnvComputeEnvConfigEksPlatformArgsDict', + 'ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigGkePlatformArgs', + 'ComputeEnvComputeEnvConfigGkePlatformArgsDict', + 'ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigGoogleBatchArgs', + 'ComputeEnvComputeEnvConfigGoogleBatchArgsDict', + 'ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs', + 'ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesArgs', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesArgsDict', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigK8sPlatformArgs', + 'ComputeEnvComputeEnvConfigK8sPlatformArgsDict', + 'ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigLsfPlatformArgs', + 'ComputeEnvComputeEnvConfigLsfPlatformArgsDict', + 'ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigMoabPlatformArgs', + 'ComputeEnvComputeEnvConfigMoabPlatformArgsDict', + 'ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformArgsDict', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgsDict', + 'ComputeEnvComputeEnvConfigSlurmPlatformArgs', + 'ComputeEnvComputeEnvConfigSlurmPlatformArgsDict', + 'ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvConfigUgePlatformArgs', + 'ComputeEnvComputeEnvConfigUgePlatformArgsDict', + 'ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs', + 'ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgsDict', + 'ComputeEnvComputeEnvLabelArgs', + 'ComputeEnvComputeEnvLabelArgsDict', + 'CredentialKeysArgs', + 'CredentialKeysArgsDict', + 'CredentialKeysAwsArgs', + 'CredentialKeysAwsArgsDict', + 'CredentialKeysAzureArgs', + 'CredentialKeysAzureArgsDict', + 'CredentialKeysAzureEntraArgs', + 'CredentialKeysAzureEntraArgsDict', + 'CredentialKeysAzurereposArgs', + 'CredentialKeysAzurereposArgsDict', + 'CredentialKeysBitbucketArgs', + 'CredentialKeysBitbucketArgsDict', + 'CredentialKeysCodecommitArgs', + 'CredentialKeysCodecommitArgsDict', + 'CredentialKeysContainerRegArgs', + 'CredentialKeysContainerRegArgsDict', + 'CredentialKeysGiteaArgs', + 'CredentialKeysGiteaArgsDict', + 'CredentialKeysGithubArgs', + 'CredentialKeysGithubArgsDict', + 'CredentialKeysGitlabArgs', + 'CredentialKeysGitlabArgsDict', + 'CredentialKeysGoogleArgs', + 'CredentialKeysGoogleArgsDict', + 'CredentialKeysK8sArgs', + 'CredentialKeysK8sArgsDict', + 'CredentialKeysSeqeracomputeArgs', + 'CredentialKeysSeqeracomputeArgsDict', + 'CredentialKeysSshArgs', + 'CredentialKeysSshArgsDict', + 'CredentialKeysTwAgentArgs', + 'CredentialKeysTwAgentArgsDict', + 'DataLinkCredentialArgs', + 'DataLinkCredentialArgsDict', + 'LabelsLabelArgs', + 'LabelsLabelArgsDict', + 'PipelineComputeEnvArgs', + 'PipelineComputeEnvArgsDict', + 'PipelineLabelArgs', + 'PipelineLabelArgsDict', + 'PipelineLaunchArgs', + 'PipelineLaunchArgsDict', + 'StudiosActiveConnectionArgs', + 'StudiosActiveConnectionArgsDict', + 'StudiosComputeEnvArgs', + 'StudiosComputeEnvArgsDict', + 'StudiosConfigurationArgs', + 'StudiosConfigurationArgsDict', + 'StudiosLabelArgs', + 'StudiosLabelArgsDict', + 'StudiosMountedDataLinkArgs', + 'StudiosMountedDataLinkArgsDict', + 'StudiosMountedDataLinkCredentialArgs', + 'StudiosMountedDataLinkCredentialArgsDict', + 'StudiosParentCheckpointArgs', + 'StudiosParentCheckpointArgsDict', + 'StudiosProgressArgs', + 'StudiosProgressArgsDict', + 'StudiosStatusInfoArgs', + 'StudiosStatusInfoArgsDict', + 'StudiosTemplateArgs', + 'StudiosTemplateArgsDict', + 'StudiosUserArgs', + 'StudiosUserArgsDict', + 'TokensTokenArgs', + 'TokensTokenArgsDict', + 'WorkflowsJobInfoArgs', + 'WorkflowsJobInfoArgsDict', + 'WorkflowsLabelArgs', + 'WorkflowsLabelArgsDict', + 'WorkflowsPlatformArgs', + 'WorkflowsPlatformArgsDict', + 'WorkflowsProgressArgs', + 'WorkflowsProgressArgsDict', + 'WorkflowsProgressProcessesProgressArgs', + 'WorkflowsProgressProcessesProgressArgsDict', + 'WorkflowsProgressWorkflowProgressArgs', + 'WorkflowsProgressWorkflowProgressArgsDict', + 'WorkflowsWorkflowArgs', + 'WorkflowsWorkflowArgsDict', + 'WorkflowsWorkflowManifestArgs', + 'WorkflowsWorkflowManifestArgsDict', + 'WorkflowsWorkflowNextflowArgs', + 'WorkflowsWorkflowNextflowArgsDict', + 'WorkflowsWorkflowStatsArgs', + 'WorkflowsWorkflowStatsArgsDict', +] + +MYPY = False + +if not MYPY: + class ActionConfigArgsDict(TypedDict): + github: NotRequired[pulumi.Input['ActionConfigGithubArgsDict']] + tower: NotRequired[pulumi.Input['ActionConfigTowerArgsDict']] +elif False: + ActionConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionConfigArgs: + def __init__(__self__, *, + github: Optional[pulumi.Input['ActionConfigGithubArgs']] = None, + tower: Optional[pulumi.Input['ActionConfigTowerArgs']] = None): + if github is not None: + pulumi.set(__self__, "github", github) + if tower is not None: + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional[pulumi.Input['ActionConfigGithubArgs']]: + return pulumi.get(self, "github") + + @github.setter + def github(self, value: Optional[pulumi.Input['ActionConfigGithubArgs']]): + pulumi.set(self, "github", value) + + @_builtins.property + @pulumi.getter + def tower(self) -> Optional[pulumi.Input['ActionConfigTowerArgs']]: + return pulumi.get(self, "tower") + + @tower.setter + def tower(self, value: Optional[pulumi.Input['ActionConfigTowerArgs']]): + pulumi.set(self, "tower", value) + + +if not MYPY: + class ActionConfigGithubArgsDict(TypedDict): + discriminator: NotRequired[pulumi.Input[_builtins.str]] + events: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] +elif False: + ActionConfigGithubArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionConfigGithubArgs: + def __init__(__self__, *, + discriminator: Optional[pulumi.Input[_builtins.str]] = None, + events: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if events is not None: + pulumi.set(__self__, "events", events) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "discriminator") + + @discriminator.setter + def discriminator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "discriminator", value) + + @_builtins.property + @pulumi.getter + def events(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "events") + + @events.setter + def events(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "events", value) + + +if not MYPY: + class ActionConfigTowerArgsDict(TypedDict): + discriminator: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionConfigTowerArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionConfigTowerArgs: + def __init__(__self__, *, + discriminator: Optional[pulumi.Input[_builtins.str]] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "discriminator") + + @discriminator.setter + def discriminator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "discriminator", value) + + +if not MYPY: + class ActionEventArgsDict(TypedDict): + github: NotRequired[pulumi.Input['ActionEventGithubArgsDict']] + tower: NotRequired[pulumi.Input['ActionEventTowerArgsDict']] +elif False: + ActionEventArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionEventArgs: + def __init__(__self__, *, + github: Optional[pulumi.Input['ActionEventGithubArgs']] = None, + tower: Optional[pulumi.Input['ActionEventTowerArgs']] = None): + if github is not None: + pulumi.set(__self__, "github", github) + if tower is not None: + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional[pulumi.Input['ActionEventGithubArgs']]: + return pulumi.get(self, "github") + + @github.setter + def github(self, value: Optional[pulumi.Input['ActionEventGithubArgs']]): + pulumi.set(self, "github", value) + + @_builtins.property + @pulumi.getter + def tower(self) -> Optional[pulumi.Input['ActionEventTowerArgs']]: + return pulumi.get(self, "tower") + + @tower.setter + def tower(self, value: Optional[pulumi.Input['ActionEventTowerArgs']]): + pulumi.set(self, "tower", value) + + +if not MYPY: + class ActionEventGithubArgsDict(TypedDict): + commit_id: NotRequired[pulumi.Input[_builtins.str]] + commit_message: NotRequired[pulumi.Input[_builtins.str]] + discriminator: NotRequired[pulumi.Input[_builtins.str]] + pusher_email: NotRequired[pulumi.Input[_builtins.str]] + pusher_name: NotRequired[pulumi.Input[_builtins.str]] + ref: NotRequired[pulumi.Input[_builtins.str]] + timestamp: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionEventGithubArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionEventGithubArgs: + def __init__(__self__, *, + commit_id: Optional[pulumi.Input[_builtins.str]] = None, + commit_message: Optional[pulumi.Input[_builtins.str]] = None, + discriminator: Optional[pulumi.Input[_builtins.str]] = None, + pusher_email: Optional[pulumi.Input[_builtins.str]] = None, + pusher_name: Optional[pulumi.Input[_builtins.str]] = None, + ref: Optional[pulumi.Input[_builtins.str]] = None, + timestamp: Optional[pulumi.Input[_builtins.str]] = None): + if commit_id is not None: + pulumi.set(__self__, "commit_id", commit_id) + if commit_message is not None: + pulumi.set(__self__, "commit_message", commit_message) + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if pusher_email is not None: + pulumi.set(__self__, "pusher_email", pusher_email) + if pusher_name is not None: + pulumi.set(__self__, "pusher_name", pusher_name) + if ref is not None: + pulumi.set(__self__, "ref", ref) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "commit_id") + + @commit_id.setter + def commit_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "commit_id", value) + + @_builtins.property + @pulumi.getter(name="commitMessage") + def commit_message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "commit_message") + + @commit_message.setter + def commit_message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "commit_message", value) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "discriminator") + + @discriminator.setter + def discriminator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "discriminator", value) + + @_builtins.property + @pulumi.getter(name="pusherEmail") + def pusher_email(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "pusher_email") + + @pusher_email.setter + def pusher_email(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pusher_email", value) + + @_builtins.property + @pulumi.getter(name="pusherName") + def pusher_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "pusher_name") + + @pusher_name.setter + def pusher_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pusher_name", value) + + @_builtins.property + @pulumi.getter + def ref(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ref") + + @ref.setter + def ref(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ref", value) + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "timestamp") + + @timestamp.setter + def timestamp(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "timestamp", value) + + +if not MYPY: + class ActionEventTowerArgsDict(TypedDict): + discriminator: NotRequired[pulumi.Input[_builtins.str]] + timestamp: NotRequired[pulumi.Input[_builtins.str]] + workflow_id: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionEventTowerArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionEventTowerArgs: + def __init__(__self__, *, + discriminator: Optional[pulumi.Input[_builtins.str]] = None, + timestamp: Optional[pulumi.Input[_builtins.str]] = None, + workflow_id: Optional[pulumi.Input[_builtins.str]] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + if workflow_id is not None: + pulumi.set(__self__, "workflow_id", workflow_id) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "discriminator") + + @discriminator.setter + def discriminator(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "discriminator", value) + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "timestamp") + + @timestamp.setter + def timestamp(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "timestamp", value) + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "workflow_id") + + @workflow_id.setter + def workflow_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "workflow_id", value) + + +if not MYPY: + class ActionLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + ActionLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchArgsDict(TypedDict): + compute_env_id: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + pipeline: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + work_dir: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + compute_env: NotRequired[pulumi.Input['ActionLaunchComputeEnvArgsDict']] + config_profiles: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + config_text: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + entry_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + id: NotRequired[pulumi.Input[_builtins.str]] + label_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] + """ + Requires replacement if changed. + """ + last_updated: NotRequired[pulumi.Input[_builtins.str]] + launch_container: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + main_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + optimization_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + optimization_targets: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + params_text: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + pull_latest: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + resume: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + resume_launch_id: NotRequired[pulumi.Input[_builtins.str]] + revision: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + run_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + schema_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + session_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + stub_run: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + tower_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + user_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + workspace_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ +elif False: + ActionLaunchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchArgs: + def __init__(__self__, *, + compute_env_id: pulumi.Input[_builtins.str], + pipeline: pulumi.Input[_builtins.str], + work_dir: pulumi.Input[_builtins.str], + compute_env: Optional[pulumi.Input['ActionLaunchComputeEnvArgs']] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + id: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + resume_launch_id: Optional[pulumi.Input[_builtins.str]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if id is not None: + pulumi.set(__self__, "id", id) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if resume_launch_id is not None: + pulumi.set(__self__, "resume_launch_id", resume_launch_id) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def pipeline(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @pipeline.setter + def pipeline(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "pipeline", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvArgs']]: + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvArgs']]): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @config_profiles.setter + def config_profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_profiles", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @entry_name.setter + def entry_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "entry_name", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @launch_container.setter + def launch_container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_container", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @params_text.setter + def params_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "params_text", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @pull_latest.setter + def pull_latest(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "pull_latest", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter(name="resumeLaunchId") + def resume_launch_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "resume_launch_id") + + @resume_launch_id.setter + def resume_launch_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "resume_launch_id", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @schema_name.setter + def schema_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "schema_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @stub_run.setter + def stub_run(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "stub_run", value) + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @tower_config.setter + def tower_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tower_config", value) + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @user_secrets.setter + def user_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "user_secrets", value) + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + + @workspace_secrets.setter + def workspace_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "workspace_secrets", value) + + +if not MYPY: + class ActionLaunchComputeEnvArgsDict(TypedDict): + compute_env_id: NotRequired[pulumi.Input[_builtins.str]] + config: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigArgsDict']] + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + credentials_id: NotRequired[pulumi.Input[_builtins.str]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + deleted: NotRequired[pulumi.Input[_builtins.bool]] + description: NotRequired[pulumi.Input[_builtins.str]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + last_used: NotRequired[pulumi.Input[_builtins.str]] + message: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + org_id: NotRequired[pulumi.Input[_builtins.float]] + platform: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + """ + primary: NotRequired[pulumi.Input[_builtins.bool]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + workspace_id: NotRequired[pulumi.Input[_builtins.float]] +elif False: + ActionLaunchComputeEnvArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvArgs: + def __init__(__self__, *, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config: Optional[pulumi.Input['ActionLaunchComputeEnvConfigArgs']] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + platform: Optional[pulumi.Input[_builtins.str]] = None, + primary: Optional[pulumi.Input[_builtins.bool]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + :param pulumi.Input['ActionLaunchComputeEnvConfigArgs'] config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + :param pulumi.Input[_builtins.str] platform: must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + :param pulumi.Input[_builtins.str] status: must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if config is not None: + pulumi.set(__self__, "config", config) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if primary is not None: + pulumi.set(__self__, "primary", primary) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def config(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigArgs']]: + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + return pulumi.get(self, "config") + + @config.setter + def config(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigArgs']]): + pulumi.set(self, "config", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + """ + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter + def primary(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "primary") + + @primary.setter + def primary(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "primary", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigArgsDict(TypedDict): + altair_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformArgsDict']] + aws_batch: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchArgsDict']] + aws_cloud: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudArgsDict']] + azure_batch: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchArgsDict']] + eks_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformArgsDict']] + gke_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformArgsDict']] + google_batch: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchArgsDict']] + google_lifesciences: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesArgsDict']] + k8s_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformArgsDict']] + lsf_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformArgsDict']] + moab_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformArgsDict']] + seqeracompute_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformArgsDict']] + slurm_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformArgsDict']] + uge_platform: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformArgsDict']] +elif False: + ActionLaunchComputeEnvConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigArgs: + def __init__(__self__, *, + altair_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformArgs']] = None, + aws_batch: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchArgs']] = None, + aws_cloud: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudArgs']] = None, + azure_batch: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchArgs']] = None, + eks_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformArgs']] = None, + gke_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformArgs']] = None, + google_batch: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchArgs']] = None, + google_lifesciences: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesArgs']] = None, + k8s_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformArgs']] = None, + lsf_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformArgs']] = None, + moab_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformArgs']] = None, + seqeracompute_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs']] = None, + slurm_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformArgs']] = None, + uge_platform: Optional[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformArgs']] = None): + if altair_platform is not None: + pulumi.set(__self__, "altair_platform", altair_platform) + if aws_batch is not None: + pulumi.set(__self__, "aws_batch", aws_batch) + if aws_cloud is not None: + pulumi.set(__self__, "aws_cloud", aws_cloud) + if azure_batch is not None: + pulumi.set(__self__, "azure_batch", azure_batch) + if eks_platform is not None: + pulumi.set(__self__, "eks_platform", eks_platform) + if gke_platform is not None: + pulumi.set(__self__, "gke_platform", gke_platform) + if google_batch is not None: + pulumi.set(__self__, "google_batch", google_batch) + if google_lifesciences is not None: + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + if k8s_platform is not None: + pulumi.set(__self__, "k8s_platform", k8s_platform) + if lsf_platform is not None: + pulumi.set(__self__, "lsf_platform", lsf_platform) + if moab_platform is not None: + pulumi.set(__self__, "moab_platform", moab_platform) + if seqeracompute_platform is not None: + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + if slurm_platform is not None: + pulumi.set(__self__, "slurm_platform", slurm_platform) + if uge_platform is not None: + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformArgs']]: + return pulumi.get(self, "altair_platform") + + @altair_platform.setter + def altair_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformArgs']]): + pulumi.set(self, "altair_platform", value) + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchArgs']]: + return pulumi.get(self, "aws_batch") + + @aws_batch.setter + def aws_batch(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchArgs']]): + pulumi.set(self, "aws_batch", value) + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudArgs']]: + return pulumi.get(self, "aws_cloud") + + @aws_cloud.setter + def aws_cloud(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudArgs']]): + pulumi.set(self, "aws_cloud", value) + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchArgs']]: + return pulumi.get(self, "azure_batch") + + @azure_batch.setter + def azure_batch(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchArgs']]): + pulumi.set(self, "azure_batch", value) + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformArgs']]: + return pulumi.get(self, "eks_platform") + + @eks_platform.setter + def eks_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformArgs']]): + pulumi.set(self, "eks_platform", value) + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformArgs']]: + return pulumi.get(self, "gke_platform") + + @gke_platform.setter + def gke_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformArgs']]): + pulumi.set(self, "gke_platform", value) + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchArgs']]: + return pulumi.get(self, "google_batch") + + @google_batch.setter + def google_batch(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchArgs']]): + pulumi.set(self, "google_batch", value) + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesArgs']]: + return pulumi.get(self, "google_lifesciences") + + @google_lifesciences.setter + def google_lifesciences(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesArgs']]): + pulumi.set(self, "google_lifesciences", value) + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformArgs']]: + return pulumi.get(self, "k8s_platform") + + @k8s_platform.setter + def k8s_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformArgs']]): + pulumi.set(self, "k8s_platform", value) + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformArgs']]: + return pulumi.get(self, "lsf_platform") + + @lsf_platform.setter + def lsf_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformArgs']]): + pulumi.set(self, "lsf_platform", value) + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformArgs']]: + return pulumi.get(self, "moab_platform") + + @moab_platform.setter + def moab_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformArgs']]): + pulumi.set(self, "moab_platform", value) + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs']]: + return pulumi.get(self, "seqeracompute_platform") + + @seqeracompute_platform.setter + def seqeracompute_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs']]): + pulumi.set(self, "seqeracompute_platform", value) + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformArgs']]: + return pulumi.get(self, "slurm_platform") + + @slurm_platform.setter + def slurm_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformArgs']]): + pulumi.set(self, "slurm_platform", value) + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformArgs']]: + return pulumi.get(self, "uge_platform") + + @uge_platform.setter + def uge_platform(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformArgs']]): + pulumi.set(self, "uge_platform", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAltairPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigAltairPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAltairPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsBatchArgsDict(TypedDict): + cli_path: NotRequired[pulumi.Input[_builtins.str]] + compute_job_role: NotRequired[pulumi.Input[_builtins.str]] + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + dragen_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + execution_role: NotRequired[pulumi.Input[_builtins.str]] + forge: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchForgeArgsDict']] + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + fusion_snapshots: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_job_role: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + log_group: NotRequired[pulumi.Input[_builtins.str]] + lustre_id: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + nvnme_storage_enabled: NotRequired[pulumi.Input[_builtins.bool]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + storage_type: NotRequired[pulumi.Input[_builtins.str]] + volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigAwsBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsBatchArgs: + def __init__(__self__, *, + cli_path: Optional[pulumi.Input[_builtins.str]] = None, + compute_job_role: Optional[pulumi.Input[_builtins.str]] = None, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + dragen_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs']]]] = None, + execution_role: Optional[pulumi.Input[_builtins.str]] = None, + forge: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fusion_snapshots: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_job_role: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + lustre_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nvnme_storage_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + storage_type: Optional[pulumi.Input[_builtins.str]] = None, + volumes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""lustre_id is deprecated: Deprecated""") + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""storage_type is deprecated: Deprecated""") + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "cli_path") + + @cli_path.setter + def cli_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cli_path", value) + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_job_role") + + @compute_job_role.setter + def compute_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_job_role", value) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_queue") + + @dragen_queue.setter + def dragen_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "execution_role") + + @execution_role.setter + def execution_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "execution_role", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchForgeArgs']]: + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAwsBatchForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion_snapshots") + + @fusion_snapshots.setter + def fusion_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_snapshots", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_role") + + @head_job_role.setter + def head_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_role", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "lustre_id") + + @lustre_id.setter + def lustre_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "lustre_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "nvnme_storage_enabled") + + @nvnme_storage_enabled.setter + def nvnme_storage_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "nvnme_storage_enabled", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_type") + + @storage_type.setter + def storage_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_type", value) + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "volumes") + + @volumes.setter + def volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "volumes", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsBatchForgeArgsDict(TypedDict): + alloc_strategy: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + bid_percentage: NotRequired[pulumi.Input[_builtins.float]] + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + dragen_ami_id: NotRequired[pulumi.Input[_builtins.str]] + dragen_enabled: NotRequired[pulumi.Input[_builtins.bool]] + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + ebs_auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + ebs_block_size: NotRequired[pulumi.Input[_builtins.float]] + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + ecs_config: NotRequired[pulumi.Input[_builtins.str]] + efs_create: NotRequired[pulumi.Input[_builtins.bool]] + efs_id: NotRequired[pulumi.Input[_builtins.str]] + efs_mount: NotRequired[pulumi.Input[_builtins.str]] + fargate_head_enabled: NotRequired[pulumi.Input[_builtins.bool]] + fsx_mount: NotRequired[pulumi.Input[_builtins.str]] + fsx_name: NotRequired[pulumi.Input[_builtins.str]] + fsx_size: NotRequired[pulumi.Input[_builtins.float]] + fusion_enabled: NotRequired[pulumi.Input[_builtins.bool]] + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + image_id: NotRequired[pulumi.Input[_builtins.str]] + instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + max_cpus: NotRequired[pulumi.Input[_builtins.float]] + min_cpus: NotRequired[pulumi.Input[_builtins.float]] + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["SPOT", "EC2"] + """ + vpc_id: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAwsBatchForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsBatchForgeArgs: + def __init__(__self__, *, + alloc_strategy: Optional[pulumi.Input[_builtins.str]] = None, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + bid_percentage: Optional[pulumi.Input[_builtins.float]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_ami_id: Optional[pulumi.Input[_builtins.str]] = None, + dragen_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + ebs_auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_block_size: Optional[pulumi.Input[_builtins.float]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + ecs_config: Optional[pulumi.Input[_builtins.str]] = None, + efs_create: Optional[pulumi.Input[_builtins.bool]] = None, + efs_id: Optional[pulumi.Input[_builtins.str]] = None, + efs_mount: Optional[pulumi.Input[_builtins.str]] = None, + fargate_head_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fsx_mount: Optional[pulumi.Input[_builtins.str]] = None, + fsx_name: Optional[pulumi.Input[_builtins.str]] = None, + fsx_size: Optional[pulumi.Input[_builtins.float]] = None, + fusion_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + max_cpus: Optional[pulumi.Input[_builtins.float]] = None, + min_cpus: Optional[pulumi.Input[_builtins.float]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + vpc_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + :param pulumi.Input[_builtins.str] type: must be one of ["SPOT", "EC2"] + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + return pulumi.get(self, "alloc_strategy") + + @alloc_strategy.setter + def alloc_strategy(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alloc_strategy", value) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "bid_percentage") + + @bid_percentage.setter + def bid_percentage(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "bid_percentage", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_ami_id") + + @dragen_ami_id.setter + def dragen_ami_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_ami_id", value) + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dragen_enabled") + + @dragen_enabled.setter + def dragen_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dragen_enabled", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "ebs_auto_scale") + + @ebs_auto_scale.setter + def ebs_auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ebs_auto_scale", value) + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_block_size") + + @ebs_block_size.setter + def ebs_block_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_block_size", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ecs_config") + + @ecs_config.setter + def ecs_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ecs_config", value) + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "efs_create") + + @efs_create.setter + def efs_create(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "efs_create", value) + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "efs_id") + + @efs_id.setter + def efs_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_id", value) + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "efs_mount") + + @efs_mount.setter + def efs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_mount", value) + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fargate_head_enabled") + + @fargate_head_enabled.setter + def fargate_head_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fargate_head_enabled", value) + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "fsx_mount") + + @fsx_mount.setter + def fsx_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_mount", value) + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "fsx_name") + + @fsx_name.setter + def fsx_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_name", value) + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "fsx_size") + + @fsx_size.setter + def fsx_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "fsx_size", value) + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion_enabled") + + @fusion_enabled.setter + def fusion_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "instance_types") + + @instance_types.setter + def instance_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "instance_types", value) + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_cpus") + + @max_cpus.setter + def max_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_cpus", value) + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "min_cpus") + + @min_cpus.setter + def min_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "min_cpus", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "subnets") + + @subnets.setter + def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "subnets", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["SPOT", "EC2"] + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "vpc_id") + + @vpc_id.setter + def vpc_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vpc_id", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsCloudArgsDict(TypedDict): + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + image_id: NotRequired[pulumi.Input[_builtins.str]] + instance_profile_arn: NotRequired[pulumi.Input[_builtins.str]] + instance_type: NotRequired[pulumi.Input[_builtins.str]] + log_group: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + subnet_id: NotRequired[pulumi.Input[_builtins.str]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigAwsCloudArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsCloudArgs: + def __init__(__self__, *, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_profile_arn: Optional[pulumi.Input[_builtins.str]] = None, + instance_type: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnet_id: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_profile_arn is not None: + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + if instance_type is not None: + pulumi.set(__self__, "instance_type", instance_type) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnet_id is not None: + pulumi.set(__self__, "subnet_id", subnet_id) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "instance_profile_arn") + + @instance_profile_arn.setter + def instance_profile_arn(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_profile_arn", value) + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "instance_type") + + @instance_type.setter + def instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_type", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "subnet_id") + + @subnet_id.setter + def subnet_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "subnet_id", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAzureBatchArgsDict(TypedDict): + auto_pool_mode: NotRequired[pulumi.Input[_builtins.bool]] + delete_jobs_on_completion: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"] + """ + delete_pools_on_completion: NotRequired[pulumi.Input[_builtins.bool]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + forge: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchForgeArgsDict']] + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + head_pool: NotRequired[pulumi.Input[_builtins.str]] + managed_identity_client_id: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + token_duration: NotRequired[pulumi.Input[_builtins.str]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigAzureBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAzureBatchArgs: + def __init__(__self__, *, + auto_pool_mode: Optional[pulumi.Input[_builtins.bool]] = None, + delete_jobs_on_completion: Optional[pulumi.Input[_builtins.str]] = None, + delete_pools_on_completion: Optional[pulumi.Input[_builtins.bool]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs']]]] = None, + forge: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_pool: Optional[pulumi.Input[_builtins.str]] = None, + managed_identity_client_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + token_duration: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] delete_jobs_on_completion: must be one of ["on_success", "always", "never"] + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if auto_pool_mode is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""auto_pool_mode is deprecated: Deprecated""") + if auto_pool_mode is not None: + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + if delete_jobs_on_completion is not None: + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + if delete_pools_on_completion is not None: + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_pool is not None: + pulumi.set(__self__, "head_pool", head_pool) + if managed_identity_client_id is not None: + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if token_duration is not None: + pulumi.set(__self__, "token_duration", token_duration) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "auto_pool_mode") + + @auto_pool_mode.setter + def auto_pool_mode(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_pool_mode", value) + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "delete_jobs_on_completion") + + @delete_jobs_on_completion.setter + def delete_jobs_on_completion(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "delete_jobs_on_completion", value) + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "delete_pools_on_completion") + + @delete_pools_on_completion.setter + def delete_pools_on_completion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "delete_pools_on_completion", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchForgeArgs']]: + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigAzureBatchForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_pool") + + @head_pool.setter + def head_pool(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pool", value) + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "managed_identity_client_id") + + @managed_identity_client_id.setter + def managed_identity_client_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "managed_identity_client_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "token_duration") + + @token_duration.setter + def token_duration(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "token_duration", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigAzureBatchForgeArgsDict(TypedDict): + auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + container_reg_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + vm_count: NotRequired[pulumi.Input[_builtins.float]] + vm_type: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigAzureBatchForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigAzureBatchForgeArgs: + def __init__(__self__, *, + auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + container_reg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + vm_count: Optional[pulumi.Input[_builtins.float]] = None, + vm_type: Optional[pulumi.Input[_builtins.str]] = None): + if auto_scale is not None: + pulumi.set(__self__, "auto_scale", auto_scale) + if container_reg_ids is not None: + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if vm_count is not None: + pulumi.set(__self__, "vm_count", vm_count) + if vm_type is not None: + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "auto_scale") + + @auto_scale.setter + def auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_scale", value) + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "container_reg_ids") + + @container_reg_ids.setter + def container_reg_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "container_reg_ids", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "vm_count") + + @vm_count.setter + def vm_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "vm_count", value) + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "vm_type") + + @vm_type.setter + def vm_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vm_type", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigEksPlatformArgsDict(TypedDict): + cluster_name: NotRequired[pulumi.Input[_builtins.str]] + """ + The AWS EKS cluster name + """ + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + namespace: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"] + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + AWS region + """ + server: NotRequired[pulumi.Input[_builtins.str]] + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigEksPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigEksPlatformArgs: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[_builtins.str]] = None, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cluster_name: The AWS EKS cluster name + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"] + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] region: AWS region + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The AWS EKS cluster name + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + AWS region + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGkePlatformArgsDict(TypedDict): + cluster_name: NotRequired[pulumi.Input[_builtins.str]] + """ + The GKE cluster name + """ + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + namespace: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"] + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + The GKE cluster region - or - zone + """ + server: NotRequired[pulumi.Input[_builtins.str]] + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigGkePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGkePlatformArgs: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[_builtins.str]] = None, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cluster_name: The GKE cluster name + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"] + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] region: The GKE cluster region - or - zone + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The GKE cluster name + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The GKE cluster region - or - zone + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGoogleBatchArgsDict(TypedDict): + boot_disk_size_gb: NotRequired[pulumi.Input[_builtins.float]] + compute_jobs_instance_template: NotRequired[pulumi.Input[_builtins.str]] + copy_image: NotRequired[pulumi.Input[_builtins.str]] + cpu_platform: NotRequired[pulumi.Input[_builtins.str]] + debug_mode: NotRequired[pulumi.Input[_builtins.float]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_instance_template: NotRequired[pulumi.Input[_builtins.str]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + location: NotRequired[pulumi.Input[_builtins.str]] + machine_type: NotRequired[pulumi.Input[_builtins.str]] + network: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + nfs_mount: NotRequired[pulumi.Input[_builtins.str]] + nfs_target: NotRequired[pulumi.Input[_builtins.str]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + project_id: NotRequired[pulumi.Input[_builtins.str]] + service_account: NotRequired[pulumi.Input[_builtins.str]] + spot: NotRequired[pulumi.Input[_builtins.bool]] + ssh_daemon: NotRequired[pulumi.Input[_builtins.bool]] + ssh_image: NotRequired[pulumi.Input[_builtins.str]] + subnetwork: NotRequired[pulumi.Input[_builtins.str]] + use_private_address: NotRequired[pulumi.Input[_builtins.bool]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigGoogleBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGoogleBatchArgs: + def __init__(__self__, *, + boot_disk_size_gb: Optional[pulumi.Input[_builtins.float]] = None, + compute_jobs_instance_template: Optional[pulumi.Input[_builtins.str]] = None, + copy_image: Optional[pulumi.Input[_builtins.str]] = None, + cpu_platform: Optional[pulumi.Input[_builtins.str]] = None, + debug_mode: Optional[pulumi.Input[_builtins.float]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_instance_template: Optional[pulumi.Input[_builtins.str]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + machine_type: Optional[pulumi.Input[_builtins.str]] = None, + network: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nfs_mount: Optional[pulumi.Input[_builtins.str]] = None, + nfs_target: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + project_id: Optional[pulumi.Input[_builtins.str]] = None, + service_account: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_daemon: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_image: Optional[pulumi.Input[_builtins.str]] = None, + subnetwork: Optional[pulumi.Input[_builtins.str]] = None, + use_private_address: Optional[pulumi.Input[_builtins.bool]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if compute_jobs_instance_template is not None: + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if cpu_platform is not None: + pulumi.set(__self__, "cpu_platform", cpu_platform) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_instance_template is not None: + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if network is not None: + pulumi.set(__self__, "network", network) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if subnetwork is not None: + pulumi.set(__self__, "subnetwork", subnetwork) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "boot_disk_size_gb") + + @boot_disk_size_gb.setter + def boot_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "boot_disk_size_gb", value) + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_jobs_instance_template") + + @compute_jobs_instance_template.setter + def compute_jobs_instance_template(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_jobs_instance_template", value) + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "copy_image") + + @copy_image.setter + def copy_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "copy_image", value) + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "cpu_platform") + + @cpu_platform.setter + def cpu_platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cpu_platform", value) + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "debug_mode") + + @debug_mode.setter + def debug_mode(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "debug_mode", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_instance_template") + + @head_job_instance_template.setter + def head_job_instance_template(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_instance_template", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "machine_type") + + @machine_type.setter + def machine_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "machine_type", value) + + @_builtins.property + @pulumi.getter + def network(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "network") + + @network.setter + def network(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "network", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nfs_mount") + + @nfs_mount.setter + def nfs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_mount", value) + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nfs_target") + + @nfs_target.setter + def nfs_target(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_target", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_id", value) + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "service_account") + + @service_account.setter + def service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_account", value) + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "spot") + + @spot.setter + def spot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "spot", value) + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "ssh_daemon") + + @ssh_daemon.setter + def ssh_daemon(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ssh_daemon", value) + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssh_image") + + @ssh_image.setter + def ssh_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssh_image", value) + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "subnetwork") + + @subnetwork.setter + def subnetwork(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "subnetwork", value) + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "use_private_address") + + @use_private_address.setter + def use_private_address(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_private_address", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGoogleLifesciencesArgsDict(TypedDict): + boot_disk_size_gb: NotRequired[pulumi.Input[_builtins.float]] + copy_image: NotRequired[pulumi.Input[_builtins.str]] + debug_mode: NotRequired[pulumi.Input[_builtins.float]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + location: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + nfs_mount: NotRequired[pulumi.Input[_builtins.str]] + nfs_target: NotRequired[pulumi.Input[_builtins.str]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + preemptible: NotRequired[pulumi.Input[_builtins.bool]] + project_id: NotRequired[pulumi.Input[_builtins.str]] + region: NotRequired[pulumi.Input[_builtins.str]] + ssh_daemon: NotRequired[pulumi.Input[_builtins.bool]] + ssh_image: NotRequired[pulumi.Input[_builtins.str]] + use_private_address: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ + zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] +elif False: + ActionLaunchComputeEnvConfigGoogleLifesciencesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGoogleLifesciencesArgs: + def __init__(__self__, *, + boot_disk_size_gb: Optional[pulumi.Input[_builtins.float]] = None, + copy_image: Optional[pulumi.Input[_builtins.str]] = None, + debug_mode: Optional[pulumi.Input[_builtins.float]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nfs_mount: Optional[pulumi.Input[_builtins.str]] = None, + nfs_target: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + preemptible: Optional[pulumi.Input[_builtins.bool]] = None, + project_id: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + ssh_daemon: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_image: Optional[pulumi.Input[_builtins.str]] = None, + use_private_address: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if preemptible is not None: + pulumi.set(__self__, "preemptible", preemptible) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "boot_disk_size_gb") + + @boot_disk_size_gb.setter + def boot_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "boot_disk_size_gb", value) + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "copy_image") + + @copy_image.setter + def copy_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "copy_image", value) + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "debug_mode") + + @debug_mode.setter + def debug_mode(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "debug_mode", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nfs_mount") + + @nfs_mount.setter + def nfs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_mount", value) + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nfs_target") + + @nfs_target.setter + def nfs_target(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_target", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def preemptible(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "preemptible") + + @preemptible.setter + def preemptible(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "preemptible", value) + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_id", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "ssh_daemon") + + @ssh_daemon.setter + def ssh_daemon(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ssh_daemon", value) + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssh_image") + + @ssh_image.setter + def ssh_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssh_image", value) + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "use_private_address") + + @use_private_address.setter + def use_private_address(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_private_address", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter + def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "zones") + + @zones.setter + def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "zones", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigK8sPlatformArgsDict(TypedDict): + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + namespace: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"] + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + server: NotRequired[pulumi.Input[_builtins.str]] + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigK8sPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigK8sPlatformArgs: + def __init__(__self__, *, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs']]]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"] + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigLsfPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + per_job_mem_limit: NotRequired[pulumi.Input[_builtins.bool]] + per_task_reserve: NotRequired[pulumi.Input[_builtins.bool]] + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + unit_for_limits: NotRequired[pulumi.Input[_builtins.str]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigLsfPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigLsfPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + per_job_mem_limit: Optional[pulumi.Input[_builtins.bool]] = None, + per_task_reserve: Optional[pulumi.Input[_builtins.bool]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + unit_for_limits: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if per_job_mem_limit is not None: + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + if per_task_reserve is not None: + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if unit_for_limits is not None: + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "per_job_mem_limit") + + @per_job_mem_limit.setter + def per_job_mem_limit(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "per_job_mem_limit", value) + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "per_task_reserve") + + @per_task_reserve.setter + def per_task_reserve(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "per_task_reserve", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "unit_for_limits") + + @unit_for_limits.setter + def unit_for_limits(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "unit_for_limits", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigMoabPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigMoabPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigMoabPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSeqeracomputePlatformArgsDict(TypedDict): + cli_path: NotRequired[pulumi.Input[_builtins.str]] + compute_job_role: NotRequired[pulumi.Input[_builtins.str]] + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + dragen_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + execution_role: NotRequired[pulumi.Input[_builtins.str]] + forge: NotRequired[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgsDict']] + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + fusion_snapshots: NotRequired[pulumi.Input[_builtins.bool]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + head_job_role: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + log_group: NotRequired[pulumi.Input[_builtins.str]] + lustre_id: NotRequired[pulumi.Input[_builtins.str]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + nvnme_storage_enabled: NotRequired[pulumi.Input[_builtins.bool]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + region: NotRequired[pulumi.Input[_builtins.str]] + storage_type: NotRequired[pulumi.Input[_builtins.str]] + volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigSeqeracomputePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformArgs: + def __init__(__self__, *, + cli_path: Optional[pulumi.Input[_builtins.str]] = None, + compute_job_role: Optional[pulumi.Input[_builtins.str]] = None, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + dragen_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]] = None, + execution_role: Optional[pulumi.Input[_builtins.str]] = None, + forge: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fusion_snapshots: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_job_role: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + lustre_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nvnme_storage_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + storage_type: Optional[pulumi.Input[_builtins.str]] = None, + volumes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""lustre_id is deprecated: Deprecated""") + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""storage_type is deprecated: Deprecated""") + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "cli_path") + + @cli_path.setter + def cli_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cli_path", value) + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_job_role") + + @compute_job_role.setter + def compute_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_job_role", value) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_queue") + + @dragen_queue.setter + def dragen_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "execution_role") + + @execution_role.setter + def execution_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "execution_role", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs']]: + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion_snapshots") + + @fusion_snapshots.setter + def fusion_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_snapshots", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_role") + + @head_job_role.setter + def head_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_role", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "lustre_id") + + @lustre_id.setter + def lustre_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "lustre_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "nvnme_storage_enabled") + + @nvnme_storage_enabled.setter + def nvnme_storage_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "nvnme_storage_enabled", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_type") + + @storage_type.setter + def storage_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_type", value) + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "volumes") + + @volumes.setter + def volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "volumes", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgsDict(TypedDict): + alloc_strategy: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + bid_percentage: NotRequired[pulumi.Input[_builtins.float]] + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + dragen_ami_id: NotRequired[pulumi.Input[_builtins.str]] + dragen_enabled: NotRequired[pulumi.Input[_builtins.bool]] + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + ebs_auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + ebs_block_size: NotRequired[pulumi.Input[_builtins.float]] + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + ecs_config: NotRequired[pulumi.Input[_builtins.str]] + efs_create: NotRequired[pulumi.Input[_builtins.bool]] + efs_id: NotRequired[pulumi.Input[_builtins.str]] + efs_mount: NotRequired[pulumi.Input[_builtins.str]] + fargate_head_enabled: NotRequired[pulumi.Input[_builtins.bool]] + fsx_mount: NotRequired[pulumi.Input[_builtins.str]] + fsx_name: NotRequired[pulumi.Input[_builtins.str]] + fsx_size: NotRequired[pulumi.Input[_builtins.float]] + fusion_enabled: NotRequired[pulumi.Input[_builtins.bool]] + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + image_id: NotRequired[pulumi.Input[_builtins.str]] + instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + max_cpus: NotRequired[pulumi.Input[_builtins.float]] + min_cpus: NotRequired[pulumi.Input[_builtins.float]] + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["SPOT", "EC2"] + """ + vpc_id: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformForgeArgs: + def __init__(__self__, *, + alloc_strategy: Optional[pulumi.Input[_builtins.str]] = None, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + bid_percentage: Optional[pulumi.Input[_builtins.float]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_ami_id: Optional[pulumi.Input[_builtins.str]] = None, + dragen_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + ebs_auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_block_size: Optional[pulumi.Input[_builtins.float]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + ecs_config: Optional[pulumi.Input[_builtins.str]] = None, + efs_create: Optional[pulumi.Input[_builtins.bool]] = None, + efs_id: Optional[pulumi.Input[_builtins.str]] = None, + efs_mount: Optional[pulumi.Input[_builtins.str]] = None, + fargate_head_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fsx_mount: Optional[pulumi.Input[_builtins.str]] = None, + fsx_name: Optional[pulumi.Input[_builtins.str]] = None, + fsx_size: Optional[pulumi.Input[_builtins.float]] = None, + fusion_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + max_cpus: Optional[pulumi.Input[_builtins.float]] = None, + min_cpus: Optional[pulumi.Input[_builtins.float]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + vpc_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + :param pulumi.Input[_builtins.str] type: must be one of ["SPOT", "EC2"] + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + return pulumi.get(self, "alloc_strategy") + + @alloc_strategy.setter + def alloc_strategy(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alloc_strategy", value) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "bid_percentage") + + @bid_percentage.setter + def bid_percentage(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "bid_percentage", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_ami_id") + + @dragen_ami_id.setter + def dragen_ami_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_ami_id", value) + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "dragen_enabled") + + @dragen_enabled.setter + def dragen_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dragen_enabled", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "ebs_auto_scale") + + @ebs_auto_scale.setter + def ebs_auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ebs_auto_scale", value) + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_block_size") + + @ebs_block_size.setter + def ebs_block_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_block_size", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ecs_config") + + @ecs_config.setter + def ecs_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ecs_config", value) + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "efs_create") + + @efs_create.setter + def efs_create(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "efs_create", value) + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "efs_id") + + @efs_id.setter + def efs_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_id", value) + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "efs_mount") + + @efs_mount.setter + def efs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_mount", value) + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fargate_head_enabled") + + @fargate_head_enabled.setter + def fargate_head_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fargate_head_enabled", value) + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "fsx_mount") + + @fsx_mount.setter + def fsx_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_mount", value) + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "fsx_name") + + @fsx_name.setter + def fsx_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_name", value) + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "fsx_size") + + @fsx_size.setter + def fsx_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "fsx_size", value) + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "fusion_enabled") + + @fusion_enabled.setter + def fusion_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "instance_types") + + @instance_types.setter + def instance_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "instance_types", value) + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_cpus") + + @max_cpus.setter + def max_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_cpus", value) + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "min_cpus") + + @min_cpus.setter + def min_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "min_cpus", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "subnets") + + @subnets.setter + def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "subnets", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["SPOT", "EC2"] + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "vpc_id") + + @vpc_id.setter + def vpc_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vpc_id", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSlurmPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigSlurmPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSlurmPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigUgePlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + head_queue: NotRequired[pulumi.Input[_builtins.str]] + host_name: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters + """ + port: NotRequired[pulumi.Input[_builtins.float]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution + """ +elif False: + ActionLaunchComputeEnvConfigUgePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigUgePlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + head: NotRequired[pulumi.Input[_builtins.bool]] + name: NotRequired[pulumi.Input[_builtins.str]] + value: NotRequired[pulumi.Input[_builtins.str]] +elif False: + ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvArgsDict(TypedDict): + config: pulumi.Input['ComputeEnvComputeEnvConfigArgsDict'] + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + """ + credentials_id: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + name: pulumi.Input[_builtins.str] + """ + Requires replacement if changed. + """ + platform: pulumi.Input[_builtins.str] + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + """ + compute_env_id: NotRequired[pulumi.Input[_builtins.str]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + deleted: NotRequired[pulumi.Input[_builtins.bool]] + description: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvLabelArgsDict']]]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + last_used: NotRequired[pulumi.Input[_builtins.str]] + managed_identity_id: NotRequired[pulumi.Input[_builtins.str]] + message: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + org_id: NotRequired[pulumi.Input[_builtins.float]] + primary: NotRequired[pulumi.Input[_builtins.bool]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + workspace_id: NotRequired[pulumi.Input[_builtins.float]] +elif False: + ComputeEnvComputeEnvArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvArgs: + def __init__(__self__, *, + config: pulumi.Input['ComputeEnvComputeEnvConfigArgs'], + credentials_id: pulumi.Input[_builtins.str], + name: pulumi.Input[_builtins.str], + platform: pulumi.Input[_builtins.str], + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvLabelArgs']]]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + managed_identity_id: Optional[pulumi.Input[_builtins.str]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + primary: Optional[pulumi.Input[_builtins.bool]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + :param pulumi.Input['ComputeEnvComputeEnvConfigArgs'] config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + :param pulumi.Input[_builtins.str] credentials_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] platform: must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] message: Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "platform", platform) + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if managed_identity_id is not None: + pulumi.set(__self__, "managed_identity_id", managed_identity_id) + if message is not None: + pulumi.set(__self__, "message", message) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if primary is not None: + pulumi.set(__self__, "primary", primary) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def config(self) -> pulumi.Input['ComputeEnvComputeEnvConfigArgs']: + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + """ + return pulumi.get(self, "config") + + @config.setter + def config(self, value: pulumi.Input['ComputeEnvComputeEnvConfigArgs']): + pulumi.set(self, "config", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> pulumi.Input[_builtins.str]: + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + """ + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter(name="managedIdentityId") + def managed_identity_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "managed_identity_id") + + @managed_identity_id.setter + def managed_identity_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "managed_identity_id", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + def primary(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "primary") + + @primary.setter + def primary(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "primary", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigArgsDict(TypedDict): + altair_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgsDict']] + """ + Requires replacement if changed. + """ + aws_batch: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgsDict']] + """ + Requires replacement if changed. + """ + aws_cloud: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgsDict']] + """ + Requires replacement if changed. + """ + azure_batch: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgsDict']] + """ + Requires replacement if changed. + """ + eks_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgsDict']] + """ + Requires replacement if changed. + """ + gke_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgsDict']] + """ + Requires replacement if changed. + """ + google_batch: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgsDict']] + """ + Requires replacement if changed. + """ + google_lifesciences: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgsDict']] + """ + Requires replacement if changed. + """ + k8s_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgsDict']] + """ + Requires replacement if changed. + """ + lsf_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgsDict']] + """ + Requires replacement if changed. + """ + moab_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgsDict']] + """ + Requires replacement if changed. + """ + seqeracompute_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgsDict']] + """ + Requires replacement if changed. + """ + slurm_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgsDict']] + """ + Requires replacement if changed. + """ + uge_platform: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgsDict']] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigArgs: + def __init__(__self__, *, + altair_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgs']] = None, + aws_batch: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgs']] = None, + aws_cloud: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgs']] = None, + azure_batch: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgs']] = None, + eks_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgs']] = None, + gke_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgs']] = None, + google_batch: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgs']] = None, + google_lifesciences: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgs']] = None, + k8s_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgs']] = None, + lsf_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgs']] = None, + moab_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgs']] = None, + seqeracompute_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs']] = None, + slurm_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgs']] = None, + uge_platform: Optional[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgs']] = None): + """ + :param pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgs'] altair_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgs'] aws_batch: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgs'] aws_cloud: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgs'] azure_batch: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgs'] eks_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgs'] gke_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgs'] google_batch: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgs'] google_lifesciences: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgs'] k8s_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgs'] lsf_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgs'] moab_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs'] seqeracompute_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgs'] slurm_platform: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgs'] uge_platform: Requires replacement if changed. + """ + if altair_platform is not None: + pulumi.set(__self__, "altair_platform", altair_platform) + if aws_batch is not None: + pulumi.set(__self__, "aws_batch", aws_batch) + if aws_cloud is not None: + pulumi.set(__self__, "aws_cloud", aws_cloud) + if azure_batch is not None: + pulumi.set(__self__, "azure_batch", azure_batch) + if eks_platform is not None: + pulumi.set(__self__, "eks_platform", eks_platform) + if gke_platform is not None: + pulumi.set(__self__, "gke_platform", gke_platform) + if google_batch is not None: + pulumi.set(__self__, "google_batch", google_batch) + if google_lifesciences is not None: + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + if k8s_platform is not None: + pulumi.set(__self__, "k8s_platform", k8s_platform) + if lsf_platform is not None: + pulumi.set(__self__, "lsf_platform", lsf_platform) + if moab_platform is not None: + pulumi.set(__self__, "moab_platform", moab_platform) + if seqeracompute_platform is not None: + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + if slurm_platform is not None: + pulumi.set(__self__, "slurm_platform", slurm_platform) + if uge_platform is not None: + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "altair_platform") + + @altair_platform.setter + def altair_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformArgs']]): + pulumi.set(self, "altair_platform", value) + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "aws_batch") + + @aws_batch.setter + def aws_batch(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchArgs']]): + pulumi.set(self, "aws_batch", value) + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "aws_cloud") + + @aws_cloud.setter + def aws_cloud(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudArgs']]): + pulumi.set(self, "aws_cloud", value) + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "azure_batch") + + @azure_batch.setter + def azure_batch(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchArgs']]): + pulumi.set(self, "azure_batch", value) + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "eks_platform") + + @eks_platform.setter + def eks_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformArgs']]): + pulumi.set(self, "eks_platform", value) + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gke_platform") + + @gke_platform.setter + def gke_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformArgs']]): + pulumi.set(self, "gke_platform", value) + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "google_batch") + + @google_batch.setter + def google_batch(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchArgs']]): + pulumi.set(self, "google_batch", value) + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "google_lifesciences") + + @google_lifesciences.setter + def google_lifesciences(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesArgs']]): + pulumi.set(self, "google_lifesciences", value) + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "k8s_platform") + + @k8s_platform.setter + def k8s_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformArgs']]): + pulumi.set(self, "k8s_platform", value) + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lsf_platform") + + @lsf_platform.setter + def lsf_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformArgs']]): + pulumi.set(self, "lsf_platform", value) + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "moab_platform") + + @moab_platform.setter + def moab_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformArgs']]): + pulumi.set(self, "moab_platform", value) + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "seqeracompute_platform") + + @seqeracompute_platform.setter + def seqeracompute_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs']]): + pulumi.set(self, "seqeracompute_platform", value) + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "slurm_platform") + + @slurm_platform.setter + def slurm_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformArgs']]): + pulumi.set(self, "slurm_platform", value) + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "uge_platform") + + @uge_platform.setter + def uge_platform(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformArgs']]): + pulumi.set(self, "uge_platform", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAltairPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAltairPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAltairPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsBatchArgsDict(TypedDict): + cli_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + compute_job_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + execution_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + forge: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgsDict']] + """ + Not Null; Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + fusion_snapshots: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + log_group: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + lustre_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + nvnme_storage_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsBatchArgs: + def __init__(__self__, *, + cli_path: Optional[pulumi.Input[_builtins.str]] = None, + compute_job_role: Optional[pulumi.Input[_builtins.str]] = None, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + dragen_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs']]]] = None, + execution_role: Optional[pulumi.Input[_builtins.str]] = None, + forge: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fusion_snapshots: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_job_role: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + lustre_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nvnme_storage_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + storage_type: Optional[pulumi.Input[_builtins.str]] = None, + volumes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cli_path: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_job_role: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] execution_role: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgs'] forge: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion_snapshots: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_role: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] log_group: Requires replacement if changed. + :param pulumi.Input[_builtins.str] lustre_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] nvnme_storage_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_type: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] volumes: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""lustre_id is deprecated: Deprecated""") + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""storage_type is deprecated: Deprecated""") + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cli_path") + + @cli_path.setter + def cli_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cli_path", value) + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_job_role") + + @compute_job_role.setter + def compute_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_job_role", value) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_queue") + + @dragen_queue.setter + def dragen_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "execution_role") + + @execution_role.setter + def execution_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "execution_role", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgs']]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAwsBatchForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_snapshots") + + @fusion_snapshots.setter + def fusion_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_snapshots", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_role") + + @head_job_role.setter + def head_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_role", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lustre_id") + + @lustre_id.setter + def lustre_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "lustre_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nvnme_storage_enabled") + + @nvnme_storage_enabled.setter + def nvnme_storage_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "nvnme_storage_enabled", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_type") + + @storage_type.setter + def storage_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_type", value) + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "volumes") + + @volumes.setter + def volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "volumes", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsBatchForgeArgsDict(TypedDict): + alloc_strategy: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + bid_percentage: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + dragen_ami_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ebs_auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ebs_block_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ecs_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + efs_create: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + efs_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + efs_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fargate_head_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + fsx_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fsx_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fsx_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + fusion_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + image_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + max_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + min_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + type: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + vpc_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsBatchForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsBatchForgeArgs: + def __init__(__self__, *, + alloc_strategy: Optional[pulumi.Input[_builtins.str]] = None, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + bid_percentage: Optional[pulumi.Input[_builtins.float]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_ami_id: Optional[pulumi.Input[_builtins.str]] = None, + dragen_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + ebs_auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_block_size: Optional[pulumi.Input[_builtins.float]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + ecs_config: Optional[pulumi.Input[_builtins.str]] = None, + efs_create: Optional[pulumi.Input[_builtins.bool]] = None, + efs_id: Optional[pulumi.Input[_builtins.str]] = None, + efs_mount: Optional[pulumi.Input[_builtins.str]] = None, + fargate_head_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fsx_mount: Optional[pulumi.Input[_builtins.str]] = None, + fsx_name: Optional[pulumi.Input[_builtins.str]] = None, + fsx_size: Optional[pulumi.Input[_builtins.float]] = None, + fusion_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + max_cpus: Optional[pulumi.Input[_builtins.float]] = None, + min_cpus: Optional[pulumi.Input[_builtins.float]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + vpc_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_buckets: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] arm64_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] bid_percentage: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dispose_on_deletion: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_ami_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dragen_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] ebs_auto_scale: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_block_size: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_boot_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ec2_key_pair: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ecs_config: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] efs_create: Requires replacement if changed. + :param pulumi.Input[_builtins.str] efs_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] efs_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fargate_head_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] fsx_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.str] fsx_name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] fsx_size: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] gpu_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] image_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_cpus: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.float] min_cpus: Not Null; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] type: Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] vpc_id: Requires replacement if changed. + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + return pulumi.get(self, "alloc_strategy") + + @alloc_strategy.setter + def alloc_strategy(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alloc_strategy", value) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "bid_percentage") + + @bid_percentage.setter + def bid_percentage(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "bid_percentage", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_ami_id") + + @dragen_ami_id.setter + def dragen_ami_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_ami_id", value) + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_enabled") + + @dragen_enabled.setter + def dragen_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dragen_enabled", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_auto_scale") + + @ebs_auto_scale.setter + def ebs_auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ebs_auto_scale", value) + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_block_size") + + @ebs_block_size.setter + def ebs_block_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_block_size", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ecs_config") + + @ecs_config.setter + def ecs_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ecs_config", value) + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_create") + + @efs_create.setter + def efs_create(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "efs_create", value) + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_id") + + @efs_id.setter + def efs_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_id", value) + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_mount") + + @efs_mount.setter + def efs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_mount", value) + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fargate_head_enabled") + + @fargate_head_enabled.setter + def fargate_head_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fargate_head_enabled", value) + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_mount") + + @fsx_mount.setter + def fsx_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_mount", value) + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_name") + + @fsx_name.setter + def fsx_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_name", value) + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_size") + + @fsx_size.setter + def fsx_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "fsx_size", value) + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_enabled") + + @fusion_enabled.setter + def fusion_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_types") + + @instance_types.setter + def instance_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "instance_types", value) + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "max_cpus") + + @max_cpus.setter + def max_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_cpus", value) + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "min_cpus") + + @min_cpus.setter + def min_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "min_cpus", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnets") + + @subnets.setter + def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "subnets", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vpc_id") + + @vpc_id.setter + def vpc_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vpc_id", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsCloudArgsDict(TypedDict): + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + image_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + instance_profile_arn: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + log_group: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + subnet_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsCloudArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsCloudArgs: + def __init__(__self__, *, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_profile_arn: Optional[pulumi.Input[_builtins.str]] = None, + instance_type: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnet_id: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_buckets: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] arm64_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_boot_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ec2_key_pair: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] gpu_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] image_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] instance_profile_arn: Requires replacement if changed. + :param pulumi.Input[_builtins.str] instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.str] log_group: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Not Null; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: Requires replacement if changed. + :param pulumi.Input[_builtins.str] subnet_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_profile_arn is not None: + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + if instance_type is not None: + pulumi.set(__self__, "instance_type", instance_type) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnet_id is not None: + pulumi.set(__self__, "subnet_id", subnet_id) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_profile_arn") + + @instance_profile_arn.setter + def instance_profile_arn(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_profile_arn", value) + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_type") + + @instance_type.setter + def instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "instance_type", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnet_id") + + @subnet_id.setter + def subnet_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "subnet_id", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAzureBatchArgsDict(TypedDict): + auto_pool_mode: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + delete_jobs_on_completion: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + delete_pools_on_completion: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + forge: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgsDict']] + """ + Not Null; Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_pool: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + managed_identity_client_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + token_duration: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAzureBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAzureBatchArgs: + def __init__(__self__, *, + auto_pool_mode: Optional[pulumi.Input[_builtins.bool]] = None, + delete_jobs_on_completion: Optional[pulumi.Input[_builtins.str]] = None, + delete_pools_on_completion: Optional[pulumi.Input[_builtins.bool]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs']]]] = None, + forge: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_pool: Optional[pulumi.Input[_builtins.str]] = None, + managed_identity_client_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + token_duration: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] auto_pool_mode: Requires replacement if changed. + :param pulumi.Input[_builtins.str] delete_jobs_on_completion: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] delete_pools_on_completion: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgs'] forge: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_pool: Requires replacement if changed. + :param pulumi.Input[_builtins.str] managed_identity_client_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] token_duration: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if auto_pool_mode is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""auto_pool_mode is deprecated: Deprecated""") + if auto_pool_mode is not None: + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + if delete_jobs_on_completion is not None: + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + if delete_pools_on_completion is not None: + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_pool is not None: + pulumi.set(__self__, "head_pool", head_pool) + if managed_identity_client_id is not None: + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if token_duration is not None: + pulumi.set(__self__, "token_duration", token_duration) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "auto_pool_mode") + + @auto_pool_mode.setter + def auto_pool_mode(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_pool_mode", value) + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "delete_jobs_on_completion") + + @delete_jobs_on_completion.setter + def delete_jobs_on_completion(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "delete_jobs_on_completion", value) + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "delete_pools_on_completion") + + @delete_pools_on_completion.setter + def delete_pools_on_completion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "delete_pools_on_completion", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgs']]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigAzureBatchForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pool") + + @head_pool.setter + def head_pool(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pool", value) + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "managed_identity_client_id") + + @managed_identity_client_id.setter + def managed_identity_client_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "managed_identity_client_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "token_duration") + + @token_duration.setter + def token_duration(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "token_duration", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigAzureBatchForgeArgsDict(TypedDict): + auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + container_reg_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + vm_count: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + vm_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigAzureBatchForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigAzureBatchForgeArgs: + def __init__(__self__, *, + auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + container_reg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + vm_count: Optional[pulumi.Input[_builtins.float]] = None, + vm_type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] auto_scale: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] container_reg_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dispose_on_deletion: Requires replacement if changed. + :param pulumi.Input[_builtins.float] vm_count: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] vm_type: Requires replacement if changed. + """ + if auto_scale is not None: + pulumi.set(__self__, "auto_scale", auto_scale) + if container_reg_ids is not None: + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if vm_count is not None: + pulumi.set(__self__, "vm_count", vm_count) + if vm_type is not None: + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "auto_scale") + + @auto_scale.setter + def auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_scale", value) + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "container_reg_ids") + + @container_reg_ids.setter + def container_reg_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "container_reg_ids", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "vm_count") + + @vm_count.setter + def vm_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "vm_count", value) + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vm_type") + + @vm_type.setter + def vm_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vm_type", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigEksPlatformArgsDict(TypedDict): + cluster_name: NotRequired[pulumi.Input[_builtins.str]] + """ + The AWS EKS cluster name. Not Null; Requires replacement if changed. + """ + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + namespace: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + AWS region. Not Null; Requires replacement if changed. + """ + server: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigEksPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigEksPlatformArgs: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[_builtins.str]] = None, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cluster_name: The AWS EKS cluster name. Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_service_account: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_service_account: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] namespace: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: AWS region. Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] server: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] service_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssl_cert: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_claim_name: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_mount_path: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The AWS EKS cluster name. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + AWS region. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGkePlatformArgsDict(TypedDict): + cluster_name: NotRequired[pulumi.Input[_builtins.str]] + """ + The GKE cluster name. Not Null; Requires replacement if changed. + """ + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + namespace: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + """ + server: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGkePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGkePlatformArgs: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[_builtins.str]] = None, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cluster_name: The GKE cluster name. Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_service_account: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_service_account: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] namespace: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] server: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] service_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssl_cert: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_claim_name: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_mount_path: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The GKE cluster name. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGoogleBatchArgsDict(TypedDict): + boot_disk_size_gb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + compute_jobs_instance_template: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + copy_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + cpu_platform: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + debug_mode: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_instance_template: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + location: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + machine_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + network: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + nfs_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nfs_target: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + project_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + spot: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ssh_daemon: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ssh_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + subnetwork: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + use_private_address: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGoogleBatchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGoogleBatchArgs: + def __init__(__self__, *, + boot_disk_size_gb: Optional[pulumi.Input[_builtins.float]] = None, + compute_jobs_instance_template: Optional[pulumi.Input[_builtins.str]] = None, + copy_image: Optional[pulumi.Input[_builtins.str]] = None, + cpu_platform: Optional[pulumi.Input[_builtins.str]] = None, + debug_mode: Optional[pulumi.Input[_builtins.float]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs']]]] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_instance_template: Optional[pulumi.Input[_builtins.str]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + machine_type: Optional[pulumi.Input[_builtins.str]] = None, + network: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nfs_mount: Optional[pulumi.Input[_builtins.str]] = None, + nfs_target: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + project_id: Optional[pulumi.Input[_builtins.str]] = None, + service_account: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_daemon: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_image: Optional[pulumi.Input[_builtins.str]] = None, + subnetwork: Optional[pulumi.Input[_builtins.str]] = None, + use_private_address: Optional[pulumi.Input[_builtins.bool]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.float] boot_disk_size_gb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_jobs_instance_template: Requires replacement if changed. + :param pulumi.Input[_builtins.str] copy_image: Requires replacement if changed. + :param pulumi.Input[_builtins.str] cpu_platform: Requires replacement if changed. + :param pulumi.Input[_builtins.float] debug_mode: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_instance_template: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: Requires replacement if changed. + :param pulumi.Input[_builtins.str] location: Requires replacement if changed. + :param pulumi.Input[_builtins.str] machine_type: Requires replacement if changed. + :param pulumi.Input[_builtins.str] network: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] nfs_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nfs_target: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] project_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] service_account: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] ssh_daemon: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssh_image: Requires replacement if changed. + :param pulumi.Input[_builtins.str] subnetwork: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] use_private_address: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if compute_jobs_instance_template is not None: + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if cpu_platform is not None: + pulumi.set(__self__, "cpu_platform", cpu_platform) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_instance_template is not None: + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if network is not None: + pulumi.set(__self__, "network", network) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if subnetwork is not None: + pulumi.set(__self__, "subnetwork", subnetwork) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "boot_disk_size_gb") + + @boot_disk_size_gb.setter + def boot_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "boot_disk_size_gb", value) + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_jobs_instance_template") + + @compute_jobs_instance_template.setter + def compute_jobs_instance_template(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_jobs_instance_template", value) + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "copy_image") + + @copy_image.setter + def copy_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "copy_image", value) + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cpu_platform") + + @cpu_platform.setter + def cpu_platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cpu_platform", value) + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "debug_mode") + + @debug_mode.setter + def debug_mode(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "debug_mode", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_instance_template") + + @head_job_instance_template.setter + def head_job_instance_template(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_instance_template", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "machine_type") + + @machine_type.setter + def machine_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "machine_type", value) + + @_builtins.property + @pulumi.getter + def network(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "network") + + @network.setter + def network(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "network", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_mount") + + @nfs_mount.setter + def nfs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_mount", value) + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_target") + + @nfs_target.setter + def nfs_target(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_target", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_id", value) + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_account") + + @service_account.setter + def service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_account", value) + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @spot.setter + def spot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "spot", value) + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_daemon") + + @ssh_daemon.setter + def ssh_daemon(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ssh_daemon", value) + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_image") + + @ssh_image.setter + def ssh_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssh_image", value) + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnetwork") + + @subnetwork.setter + def subnetwork(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "subnetwork", value) + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "use_private_address") + + @use_private_address.setter + def use_private_address(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_private_address", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGoogleLifesciencesArgsDict(TypedDict): + boot_disk_size_gb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + copy_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + debug_mode: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + location: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + nfs_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nfs_target: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + preemptible: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + project_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ssh_daemon: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ssh_image: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + use_private_address: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGoogleLifesciencesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGoogleLifesciencesArgs: + def __init__(__self__, *, + boot_disk_size_gb: Optional[pulumi.Input[_builtins.float]] = None, + copy_image: Optional[pulumi.Input[_builtins.str]] = None, + debug_mode: Optional[pulumi.Input[_builtins.float]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nfs_mount: Optional[pulumi.Input[_builtins.str]] = None, + nfs_target: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + preemptible: Optional[pulumi.Input[_builtins.bool]] = None, + project_id: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + ssh_daemon: Optional[pulumi.Input[_builtins.bool]] = None, + ssh_image: Optional[pulumi.Input[_builtins.str]] = None, + use_private_address: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.float] boot_disk_size_gb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] copy_image: Requires replacement if changed. + :param pulumi.Input[_builtins.float] debug_mode: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: Requires replacement if changed. + :param pulumi.Input[_builtins.str] location: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] nfs_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nfs_target: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] preemptible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] project_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] ssh_daemon: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssh_image: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] use_private_address: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] zones: Requires replacement if changed. + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if preemptible is not None: + pulumi.set(__self__, "preemptible", preemptible) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "boot_disk_size_gb") + + @boot_disk_size_gb.setter + def boot_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "boot_disk_size_gb", value) + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "copy_image") + + @copy_image.setter + def copy_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "copy_image", value) + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "debug_mode") + + @debug_mode.setter + def debug_mode(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "debug_mode", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_mount") + + @nfs_mount.setter + def nfs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_mount", value) + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_target") + + @nfs_target.setter + def nfs_target(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nfs_target", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def preemptible(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "preemptible") + + @preemptible.setter + def preemptible(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "preemptible", value) + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_id", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_daemon") + + @ssh_daemon.setter + def ssh_daemon(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ssh_daemon", value) + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_image") + + @ssh_image.setter + def ssh_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssh_image", value) + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "use_private_address") + + @use_private_address.setter + def use_private_address(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "use_private_address", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter + def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "zones") + + @zones.setter + def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "zones", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigK8sPlatformArgsDict(TypedDict): + compute_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_service_account: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + namespace: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + pod_cleanup: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + server: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + service_pod_spec: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ssl_cert: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_claim_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_mount_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigK8sPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigK8sPlatformArgs: + def __init__(__self__, *, + compute_service_account: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs']]]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + head_service_account: Optional[pulumi.Input[_builtins.str]] = None, + namespace: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + pod_cleanup: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + server: Optional[pulumi.Input[_builtins.str]] = None, + service_pod_spec: Optional[pulumi.Input[_builtins.str]] = None, + ssl_cert: Optional[pulumi.Input[_builtins.str]] = None, + storage_claim_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_mount_path: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_service_account: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_service_account: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] namespace: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] server: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] service_pod_spec: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ssl_cert: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_claim_name: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_mount_path: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @compute_service_account.setter + def compute_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_service_account", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @head_pod_spec.setter + def head_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @head_service_account.setter + def head_service_account(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_service_account", value) + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "namespace", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @pod_cleanup.setter + def pod_cleanup(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pod_cleanup", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @server.setter + def server(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server", value) + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @service_pod_spec.setter + def service_pod_spec(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "service_pod_spec", value) + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @ssl_cert.setter + def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ssl_cert", value) + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @storage_claim_name.setter + def storage_claim_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_claim_name", value) + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @storage_mount_path.setter + def storage_mount_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_mount_path", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigLsfPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + per_job_mem_limit: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + per_task_reserve: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + unit_for_limits: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigLsfPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigLsfPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + per_job_mem_limit: Optional[pulumi.Input[_builtins.bool]] = None, + per_task_reserve: Optional[pulumi.Input[_builtins.bool]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + unit_for_limits: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] per_job_mem_limit: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] per_task_reserve: Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] unit_for_limits: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if per_job_mem_limit is not None: + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + if per_task_reserve is not None: + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if unit_for_limits is not None: + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "per_job_mem_limit") + + @per_job_mem_limit.setter + def per_job_mem_limit(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "per_job_mem_limit", value) + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "per_task_reserve") + + @per_task_reserve.setter + def per_task_reserve(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "per_task_reserve", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "unit_for_limits") + + @unit_for_limits.setter + def unit_for_limits(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "unit_for_limits", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigMoabPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigMoabPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigMoabPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSeqeracomputePlatformArgsDict(TypedDict): + cli_path: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + compute_job_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + execution_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + forge: NotRequired[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgsDict']] + """ + Not Null; Requires replacement if changed. + """ + fusion2_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + fusion_snapshots: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + head_job_role: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + log_group: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + lustre_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + nvnme_storage_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; Requires replacement if changed. + """ + storage_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + wave_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSeqeracomputePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs: + def __init__(__self__, *, + cli_path: Optional[pulumi.Input[_builtins.str]] = None, + compute_job_role: Optional[pulumi.Input[_builtins.str]] = None, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + dragen_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]] = None, + execution_role: Optional[pulumi.Input[_builtins.str]] = None, + forge: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs']] = None, + fusion2_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fusion_snapshots: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + head_job_role: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + log_group: Optional[pulumi.Input[_builtins.str]] = None, + lustre_id: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + nvnme_storage_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + storage_type: Optional[pulumi.Input[_builtins.str]] = None, + volumes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + wave_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] cli_path: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_job_role: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] execution_role: Requires replacement if changed. + :param pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs'] forge: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion2_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion_snapshots: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_role: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] log_group: Requires replacement if changed. + :param pulumi.Input[_builtins.str] lustre_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] nvnme_storage_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.str] storage_type: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] volumes: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] wave_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""lustre_id is deprecated: Deprecated""") + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""storage_type is deprecated: Deprecated""") + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cli_path") + + @cli_path.setter + def cli_path(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cli_path", value) + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_job_role") + + @compute_job_role.setter + def compute_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_job_role", value) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_queue") + + @dragen_queue.setter + def dragen_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "execution_role") + + @execution_role.setter + def execution_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "execution_role", value) + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs']]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @forge.setter + def forge(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs']]): + pulumi.set(self, "forge", value) + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @fusion2_enabled.setter + def fusion2_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion2_enabled", value) + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_snapshots") + + @fusion_snapshots.setter + def fusion_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_snapshots", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_role") + + @head_job_role.setter + def head_job_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_role", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @log_group.setter + def log_group(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_group", value) + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lustre_id") + + @lustre_id.setter + def lustre_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "lustre_id", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nvnme_storage_enabled") + + @nvnme_storage_enabled.setter + def nvnme_storage_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "nvnme_storage_enabled", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_type") + + @storage_type.setter + def storage_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_type", value) + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "volumes") + + @volumes.setter + def volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "volumes", value) + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @wave_enabled.setter + def wave_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "wave_enabled", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgsDict(TypedDict): + alloc_strategy: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + allow_buckets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + arm64_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + bid_percentage: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + dispose_on_deletion: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + dragen_ami_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + dragen_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + dragen_instance_type: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ebs_auto_scale: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + ebs_block_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ebs_boot_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + ec2_key_pair: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + ecs_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + efs_create: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + efs_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + efs_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fargate_head_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + fsx_mount: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fsx_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + fsx_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + fusion_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + gpu_enabled: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + image_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + max_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + min_cpus: NotRequired[pulumi.Input[_builtins.float]] + """ + Not Null; Requires replacement if changed. + """ + security_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ + type: NotRequired[pulumi.Input[_builtins.str]] + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + vpc_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs: + def __init__(__self__, *, + alloc_strategy: Optional[pulumi.Input[_builtins.str]] = None, + allow_buckets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + arm64_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + bid_percentage: Optional[pulumi.Input[_builtins.float]] = None, + dispose_on_deletion: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_ami_id: Optional[pulumi.Input[_builtins.str]] = None, + dragen_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + dragen_instance_type: Optional[pulumi.Input[_builtins.str]] = None, + ebs_auto_scale: Optional[pulumi.Input[_builtins.bool]] = None, + ebs_block_size: Optional[pulumi.Input[_builtins.float]] = None, + ebs_boot_size: Optional[pulumi.Input[_builtins.float]] = None, + ec2_key_pair: Optional[pulumi.Input[_builtins.str]] = None, + ecs_config: Optional[pulumi.Input[_builtins.str]] = None, + efs_create: Optional[pulumi.Input[_builtins.bool]] = None, + efs_id: Optional[pulumi.Input[_builtins.str]] = None, + efs_mount: Optional[pulumi.Input[_builtins.str]] = None, + fargate_head_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + fsx_mount: Optional[pulumi.Input[_builtins.str]] = None, + fsx_name: Optional[pulumi.Input[_builtins.str]] = None, + fsx_size: Optional[pulumi.Input[_builtins.float]] = None, + fusion_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + gpu_enabled: Optional[pulumi.Input[_builtins.bool]] = None, + image_id: Optional[pulumi.Input[_builtins.str]] = None, + instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + max_cpus: Optional[pulumi.Input[_builtins.float]] = None, + min_cpus: Optional[pulumi.Input[_builtins.float]] = None, + security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + subnets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + vpc_id: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_buckets: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] arm64_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.float] bid_percentage: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dispose_on_deletion: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_ami_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] dragen_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] dragen_instance_type: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] ebs_auto_scale: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_block_size: Requires replacement if changed. + :param pulumi.Input[_builtins.float] ebs_boot_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ec2_key_pair: Requires replacement if changed. + :param pulumi.Input[_builtins.str] ecs_config: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] efs_create: Requires replacement if changed. + :param pulumi.Input[_builtins.str] efs_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] efs_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fargate_head_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] fsx_mount: Requires replacement if changed. + :param pulumi.Input[_builtins.str] fsx_name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] fsx_size: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] fusion_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] gpu_enabled: Requires replacement if changed. + :param pulumi.Input[_builtins.str] image_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_cpus: Not Null; Requires replacement if changed. + :param pulumi.Input[_builtins.float] min_cpus: Not Null; Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] type: Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] vpc_id: Requires replacement if changed. + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + return pulumi.get(self, "alloc_strategy") + + @alloc_strategy.setter + def alloc_strategy(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "alloc_strategy", value) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @allow_buckets.setter + def allow_buckets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "allow_buckets", value) + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @arm64_enabled.setter + def arm64_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "arm64_enabled", value) + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "bid_percentage") + + @bid_percentage.setter + def bid_percentage(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "bid_percentage", value) + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @dispose_on_deletion.setter + def dispose_on_deletion(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dispose_on_deletion", value) + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_ami_id") + + @dragen_ami_id.setter + def dragen_ami_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_ami_id", value) + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_enabled") + + @dragen_enabled.setter + def dragen_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "dragen_enabled", value) + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @dragen_instance_type.setter + def dragen_instance_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "dragen_instance_type", value) + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_auto_scale") + + @ebs_auto_scale.setter + def ebs_auto_scale(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "ebs_auto_scale", value) + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_block_size") + + @ebs_block_size.setter + def ebs_block_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_block_size", value) + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @ebs_boot_size.setter + def ebs_boot_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ebs_boot_size", value) + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @ec2_key_pair.setter + def ec2_key_pair(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ec2_key_pair", value) + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ecs_config") + + @ecs_config.setter + def ecs_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ecs_config", value) + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_create") + + @efs_create.setter + def efs_create(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "efs_create", value) + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_id") + + @efs_id.setter + def efs_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_id", value) + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_mount") + + @efs_mount.setter + def efs_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "efs_mount", value) + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fargate_head_enabled") + + @fargate_head_enabled.setter + def fargate_head_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fargate_head_enabled", value) + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_mount") + + @fsx_mount.setter + def fsx_mount(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_mount", value) + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_name") + + @fsx_name.setter + def fsx_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "fsx_name", value) + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_size") + + @fsx_size.setter + def fsx_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "fsx_size", value) + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_enabled") + + @fusion_enabled.setter + def fusion_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "fusion_enabled", value) + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @gpu_enabled.setter + def gpu_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "gpu_enabled", value) + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "image_id", value) + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_types") + + @instance_types.setter + def instance_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "instance_types", value) + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "max_cpus") + + @max_cpus.setter + def max_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_cpus", value) + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "min_cpus") + + @min_cpus.setter + def min_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "min_cpus", value) + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @security_groups.setter + def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "security_groups", value) + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnets") + + @subnets.setter + def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "subnets", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vpc_id") + + @vpc_id.setter + def vpc_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "vpc_id", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSlurmPlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSlurmPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSlurmPlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigUgePlatformArgsDict(TypedDict): + compute_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + environments: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgsDict']]]] + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + head_job_options: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + head_queue: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + host_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + max_queue_size: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + nextflow_config: NotRequired[pulumi.Input[_builtins.str]] + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + port: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + propagate_head_job_options: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + user_name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + work_dir: NotRequired[pulumi.Input[_builtins.str]] + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigUgePlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigUgePlatformArgs: + def __init__(__self__, *, + compute_queue: Optional[pulumi.Input[_builtins.str]] = None, + environments: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs']]]] = None, + head_job_options: Optional[pulumi.Input[_builtins.str]] = None, + head_queue: Optional[pulumi.Input[_builtins.str]] = None, + host_name: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + max_queue_size: Optional[pulumi.Input[_builtins.float]] = None, + nextflow_config: Optional[pulumi.Input[_builtins.str]] = None, + port: Optional[pulumi.Input[_builtins.float]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + propagate_head_job_options: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] compute_queue: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs']]] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] head_queue: Requires replacement if changed. + :param pulumi.Input[_builtins.str] host_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] max_queue_size: Requires replacement if changed. + :param pulumi.Input[_builtins.str] nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param pulumi.Input[_builtins.float] port: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param pulumi.Input[_builtins.str] pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] propagate_head_job_options: Requires replacement if changed. + :param pulumi.Input[_builtins.str] user_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @compute_queue.setter + def compute_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_queue", value) + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs']]]]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @environments.setter + def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs']]]]): + pulumi.set(self, "environments", value) + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @head_job_options.setter + def head_job_options(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_job_options", value) + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @head_queue.setter + def head_queue(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "head_queue", value) + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @host_name.setter + def host_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "host_name", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @max_queue_size.setter + def max_queue_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "max_queue_size", value) + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @nextflow_config.setter + def nextflow_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_config", value) + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "port", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @propagate_head_job_options.setter + def propagate_head_job_options(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "propagate_head_job_options", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgsDict(TypedDict): + compute: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + head: NotRequired[pulumi.Input[_builtins.bool]] + """ + Requires replacement if changed. + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ +elif False: + ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs: + def __init__(__self__, *, + compute: Optional[pulumi.Input[_builtins.bool]] = None, + head: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.bool] compute: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] head: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @compute.setter + def compute(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "compute", value) + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @head.setter + def head(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "head", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class ComputeEnvComputeEnvLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + ComputeEnvComputeEnvLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ComputeEnvComputeEnvLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class CredentialKeysArgsDict(TypedDict): + aws: NotRequired[pulumi.Input['CredentialKeysAwsArgsDict']] + azure: NotRequired[pulumi.Input['CredentialKeysAzureArgsDict']] + azure_entra: NotRequired[pulumi.Input['CredentialKeysAzureEntraArgsDict']] + azurerepos: NotRequired[pulumi.Input['CredentialKeysAzurereposArgsDict']] + bitbucket: NotRequired[pulumi.Input['CredentialKeysBitbucketArgsDict']] + codecommit: NotRequired[pulumi.Input['CredentialKeysCodecommitArgsDict']] + container_reg: NotRequired[pulumi.Input['CredentialKeysContainerRegArgsDict']] + gitea: NotRequired[pulumi.Input['CredentialKeysGiteaArgsDict']] + github: NotRequired[pulumi.Input['CredentialKeysGithubArgsDict']] + gitlab: NotRequired[pulumi.Input['CredentialKeysGitlabArgsDict']] + google: NotRequired[pulumi.Input['CredentialKeysGoogleArgsDict']] + k8s: NotRequired[pulumi.Input['CredentialKeysK8sArgsDict']] + seqeracompute: NotRequired[pulumi.Input['CredentialKeysSeqeracomputeArgsDict']] + ssh: NotRequired[pulumi.Input['CredentialKeysSshArgsDict']] + tw_agent: NotRequired[pulumi.Input['CredentialKeysTwAgentArgsDict']] +elif False: + CredentialKeysArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysArgs: + def __init__(__self__, *, + aws: Optional[pulumi.Input['CredentialKeysAwsArgs']] = None, + azure: Optional[pulumi.Input['CredentialKeysAzureArgs']] = None, + azure_entra: Optional[pulumi.Input['CredentialKeysAzureEntraArgs']] = None, + azurerepos: Optional[pulumi.Input['CredentialKeysAzurereposArgs']] = None, + bitbucket: Optional[pulumi.Input['CredentialKeysBitbucketArgs']] = None, + codecommit: Optional[pulumi.Input['CredentialKeysCodecommitArgs']] = None, + container_reg: Optional[pulumi.Input['CredentialKeysContainerRegArgs']] = None, + gitea: Optional[pulumi.Input['CredentialKeysGiteaArgs']] = None, + github: Optional[pulumi.Input['CredentialKeysGithubArgs']] = None, + gitlab: Optional[pulumi.Input['CredentialKeysGitlabArgs']] = None, + google: Optional[pulumi.Input['CredentialKeysGoogleArgs']] = None, + k8s: Optional[pulumi.Input['CredentialKeysK8sArgs']] = None, + seqeracompute: Optional[pulumi.Input['CredentialKeysSeqeracomputeArgs']] = None, + ssh: Optional[pulumi.Input['CredentialKeysSshArgs']] = None, + tw_agent: Optional[pulumi.Input['CredentialKeysTwAgentArgs']] = None): + if aws is not None: + pulumi.set(__self__, "aws", aws) + if azure is not None: + pulumi.set(__self__, "azure", azure) + if azure_entra is not None: + pulumi.set(__self__, "azure_entra", azure_entra) + if azurerepos is not None: + pulumi.set(__self__, "azurerepos", azurerepos) + if bitbucket is not None: + pulumi.set(__self__, "bitbucket", bitbucket) + if codecommit is not None: + pulumi.set(__self__, "codecommit", codecommit) + if container_reg is not None: + pulumi.set(__self__, "container_reg", container_reg) + if gitea is not None: + pulumi.set(__self__, "gitea", gitea) + if github is not None: + pulumi.set(__self__, "github", github) + if gitlab is not None: + pulumi.set(__self__, "gitlab", gitlab) + if google is not None: + pulumi.set(__self__, "google", google) + if k8s is not None: + pulumi.set(__self__, "k8s", k8s) + if seqeracompute is not None: + pulumi.set(__self__, "seqeracompute", seqeracompute) + if ssh is not None: + pulumi.set(__self__, "ssh", ssh) + if tw_agent is not None: + pulumi.set(__self__, "tw_agent", tw_agent) + + @_builtins.property + @pulumi.getter + def aws(self) -> Optional[pulumi.Input['CredentialKeysAwsArgs']]: + return pulumi.get(self, "aws") + + @aws.setter + def aws(self, value: Optional[pulumi.Input['CredentialKeysAwsArgs']]): + pulumi.set(self, "aws", value) + + @_builtins.property + @pulumi.getter + def azure(self) -> Optional[pulumi.Input['CredentialKeysAzureArgs']]: + return pulumi.get(self, "azure") + + @azure.setter + def azure(self, value: Optional[pulumi.Input['CredentialKeysAzureArgs']]): + pulumi.set(self, "azure", value) + + @_builtins.property + @pulumi.getter(name="azureEntra") + def azure_entra(self) -> Optional[pulumi.Input['CredentialKeysAzureEntraArgs']]: + return pulumi.get(self, "azure_entra") + + @azure_entra.setter + def azure_entra(self, value: Optional[pulumi.Input['CredentialKeysAzureEntraArgs']]): + pulumi.set(self, "azure_entra", value) + + @_builtins.property + @pulumi.getter + def azurerepos(self) -> Optional[pulumi.Input['CredentialKeysAzurereposArgs']]: + return pulumi.get(self, "azurerepos") + + @azurerepos.setter + def azurerepos(self, value: Optional[pulumi.Input['CredentialKeysAzurereposArgs']]): + pulumi.set(self, "azurerepos", value) + + @_builtins.property + @pulumi.getter + def bitbucket(self) -> Optional[pulumi.Input['CredentialKeysBitbucketArgs']]: + return pulumi.get(self, "bitbucket") + + @bitbucket.setter + def bitbucket(self, value: Optional[pulumi.Input['CredentialKeysBitbucketArgs']]): + pulumi.set(self, "bitbucket", value) + + @_builtins.property + @pulumi.getter + def codecommit(self) -> Optional[pulumi.Input['CredentialKeysCodecommitArgs']]: + return pulumi.get(self, "codecommit") + + @codecommit.setter + def codecommit(self, value: Optional[pulumi.Input['CredentialKeysCodecommitArgs']]): + pulumi.set(self, "codecommit", value) + + @_builtins.property + @pulumi.getter(name="containerReg") + def container_reg(self) -> Optional[pulumi.Input['CredentialKeysContainerRegArgs']]: + return pulumi.get(self, "container_reg") + + @container_reg.setter + def container_reg(self, value: Optional[pulumi.Input['CredentialKeysContainerRegArgs']]): + pulumi.set(self, "container_reg", value) + + @_builtins.property + @pulumi.getter + def gitea(self) -> Optional[pulumi.Input['CredentialKeysGiteaArgs']]: + return pulumi.get(self, "gitea") + + @gitea.setter + def gitea(self, value: Optional[pulumi.Input['CredentialKeysGiteaArgs']]): + pulumi.set(self, "gitea", value) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional[pulumi.Input['CredentialKeysGithubArgs']]: + return pulumi.get(self, "github") + + @github.setter + def github(self, value: Optional[pulumi.Input['CredentialKeysGithubArgs']]): + pulumi.set(self, "github", value) + + @_builtins.property + @pulumi.getter + def gitlab(self) -> Optional[pulumi.Input['CredentialKeysGitlabArgs']]: + return pulumi.get(self, "gitlab") + + @gitlab.setter + def gitlab(self, value: Optional[pulumi.Input['CredentialKeysGitlabArgs']]): + pulumi.set(self, "gitlab", value) + + @_builtins.property + @pulumi.getter + def google(self) -> Optional[pulumi.Input['CredentialKeysGoogleArgs']]: + return pulumi.get(self, "google") + + @google.setter + def google(self, value: Optional[pulumi.Input['CredentialKeysGoogleArgs']]): + pulumi.set(self, "google", value) + + @_builtins.property + @pulumi.getter + def k8s(self) -> Optional[pulumi.Input['CredentialKeysK8sArgs']]: + return pulumi.get(self, "k8s") + + @k8s.setter + def k8s(self, value: Optional[pulumi.Input['CredentialKeysK8sArgs']]): + pulumi.set(self, "k8s", value) + + @_builtins.property + @pulumi.getter + def seqeracompute(self) -> Optional[pulumi.Input['CredentialKeysSeqeracomputeArgs']]: + return pulumi.get(self, "seqeracompute") + + @seqeracompute.setter + def seqeracompute(self, value: Optional[pulumi.Input['CredentialKeysSeqeracomputeArgs']]): + pulumi.set(self, "seqeracompute", value) + + @_builtins.property + @pulumi.getter + def ssh(self) -> Optional[pulumi.Input['CredentialKeysSshArgs']]: + return pulumi.get(self, "ssh") + + @ssh.setter + def ssh(self, value: Optional[pulumi.Input['CredentialKeysSshArgs']]): + pulumi.set(self, "ssh", value) + + @_builtins.property + @pulumi.getter(name="twAgent") + def tw_agent(self) -> Optional[pulumi.Input['CredentialKeysTwAgentArgs']]: + return pulumi.get(self, "tw_agent") + + @tw_agent.setter + def tw_agent(self, value: Optional[pulumi.Input['CredentialKeysTwAgentArgs']]): + pulumi.set(self, "tw_agent", value) + + +if not MYPY: + class CredentialKeysAwsArgsDict(TypedDict): + access_key: NotRequired[pulumi.Input[_builtins.str]] + assume_role_arn: NotRequired[pulumi.Input[_builtins.str]] + secret_key: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysAwsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysAwsArgs: + def __init__(__self__, *, + access_key: Optional[pulumi.Input[_builtins.str]] = None, + assume_role_arn: Optional[pulumi.Input[_builtins.str]] = None, + secret_key: Optional[pulumi.Input[_builtins.str]] = None): + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if assume_role_arn is not None: + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "access_key") + + @access_key.setter + def access_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "access_key", value) + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "assume_role_arn") + + @assume_role_arn.setter + def assume_role_arn(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "assume_role_arn", value) + + @_builtins.property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "secret_key") + + @secret_key.setter + def secret_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "secret_key", value) + + +if not MYPY: + class CredentialKeysAzureArgsDict(TypedDict): + batch_key: NotRequired[pulumi.Input[_builtins.str]] + batch_name: NotRequired[pulumi.Input[_builtins.str]] + storage_key: NotRequired[pulumi.Input[_builtins.str]] + storage_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysAzureArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysAzureArgs: + def __init__(__self__, *, + batch_key: Optional[pulumi.Input[_builtins.str]] = None, + batch_name: Optional[pulumi.Input[_builtins.str]] = None, + storage_key: Optional[pulumi.Input[_builtins.str]] = None, + storage_name: Optional[pulumi.Input[_builtins.str]] = None): + if batch_key is not None: + pulumi.set(__self__, "batch_key", batch_key) + if batch_name is not None: + pulumi.set(__self__, "batch_name", batch_name) + if storage_key is not None: + pulumi.set(__self__, "storage_key", storage_key) + if storage_name is not None: + pulumi.set(__self__, "storage_name", storage_name) + + @_builtins.property + @pulumi.getter(name="batchKey") + def batch_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "batch_key") + + @batch_key.setter + def batch_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "batch_key", value) + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "batch_name") + + @batch_name.setter + def batch_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "batch_name", value) + + @_builtins.property + @pulumi.getter(name="storageKey") + def storage_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_key") + + @storage_key.setter + def storage_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_key", value) + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_name") + + @storage_name.setter + def storage_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_name", value) + + +if not MYPY: + class CredentialKeysAzureEntraArgsDict(TypedDict): + batch_key: NotRequired[pulumi.Input[_builtins.str]] + batch_name: NotRequired[pulumi.Input[_builtins.str]] + client_id: NotRequired[pulumi.Input[_builtins.str]] + client_secret: NotRequired[pulumi.Input[_builtins.str]] + storage_key: NotRequired[pulumi.Input[_builtins.str]] + storage_name: NotRequired[pulumi.Input[_builtins.str]] + tenant_id: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysAzureEntraArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysAzureEntraArgs: + def __init__(__self__, *, + batch_key: Optional[pulumi.Input[_builtins.str]] = None, + batch_name: Optional[pulumi.Input[_builtins.str]] = None, + client_id: Optional[pulumi.Input[_builtins.str]] = None, + client_secret: Optional[pulumi.Input[_builtins.str]] = None, + storage_key: Optional[pulumi.Input[_builtins.str]] = None, + storage_name: Optional[pulumi.Input[_builtins.str]] = None, + tenant_id: Optional[pulumi.Input[_builtins.str]] = None): + if batch_key is not None: + pulumi.set(__self__, "batch_key", batch_key) + if batch_name is not None: + pulumi.set(__self__, "batch_name", batch_name) + if client_id is not None: + pulumi.set(__self__, "client_id", client_id) + if client_secret is not None: + pulumi.set(__self__, "client_secret", client_secret) + if storage_key is not None: + pulumi.set(__self__, "storage_key", storage_key) + if storage_name is not None: + pulumi.set(__self__, "storage_name", storage_name) + if tenant_id is not None: + pulumi.set(__self__, "tenant_id", tenant_id) + + @_builtins.property + @pulumi.getter(name="batchKey") + def batch_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "batch_key") + + @batch_key.setter + def batch_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "batch_key", value) + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "batch_name") + + @batch_name.setter + def batch_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "batch_name", value) + + @_builtins.property + @pulumi.getter(name="clientId") + def client_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "client_id") + + @client_id.setter + def client_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "client_id", value) + + @_builtins.property + @pulumi.getter(name="clientSecret") + def client_secret(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "client_secret") + + @client_secret.setter + def client_secret(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "client_secret", value) + + @_builtins.property + @pulumi.getter(name="storageKey") + def storage_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_key") + + @storage_key.setter + def storage_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_key", value) + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "storage_name") + + @storage_name.setter + def storage_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "storage_name", value) + + @_builtins.property + @pulumi.getter(name="tenantId") + def tenant_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "tenant_id") + + @tenant_id.setter + def tenant_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tenant_id", value) + + +if not MYPY: + class CredentialKeysAzurereposArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysAzurereposArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysAzurereposArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysBitbucketArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysBitbucketArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysBitbucketArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysCodecommitArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysCodecommitArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysCodecommitArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysContainerRegArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + registry: NotRequired[pulumi.Input[_builtins.str]] + user_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysContainerRegArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysContainerRegArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + registry: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if registry is not None: + pulumi.set(__self__, "registry", registry) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def registry(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "registry") + + @registry.setter + def registry(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "registry", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + +if not MYPY: + class CredentialKeysGiteaArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysGiteaArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysGiteaArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysGithubArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysGithubArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysGithubArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysGitlabArgsDict(TypedDict): + password: NotRequired[pulumi.Input[_builtins.str]] + token: NotRequired[pulumi.Input[_builtins.str]] + username: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysGitlabArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysGitlabArgs: + def __init__(__self__, *, + password: Optional[pulumi.Input[_builtins.str]] = None, + token: Optional[pulumi.Input[_builtins.str]] = None, + username: Optional[pulumi.Input[_builtins.str]] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if token is not None: + pulumi.set(__self__, "token", token) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "password", value) + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "token", value) + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "username", value) + + +if not MYPY: + class CredentialKeysGoogleArgsDict(TypedDict): + data: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysGoogleArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysGoogleArgs: + def __init__(__self__, *, + data: Optional[pulumi.Input[_builtins.str]] = None): + if data is not None: + pulumi.set(__self__, "data", data) + + @_builtins.property + @pulumi.getter + def data(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "data") + + @data.setter + def data(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "data", value) + + +if not MYPY: + class CredentialKeysK8sArgsDict(TypedDict): + certificate: NotRequired[pulumi.Input[_builtins.str]] + private_key: NotRequired[pulumi.Input[_builtins.str]] + token: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysK8sArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysK8sArgs: + def __init__(__self__, *, + certificate: Optional[pulumi.Input[_builtins.str]] = None, + private_key: Optional[pulumi.Input[_builtins.str]] = None, + token: Optional[pulumi.Input[_builtins.str]] = None): + if certificate is not None: + pulumi.set(__self__, "certificate", certificate) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + if token is not None: + pulumi.set(__self__, "token", token) + + @_builtins.property + @pulumi.getter + def certificate(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "certificate") + + @certificate.setter + def certificate(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "certificate", value) + + @_builtins.property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "private_key") + + @private_key.setter + def private_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "private_key", value) + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "token", value) + + +if not MYPY: + class CredentialKeysSeqeracomputeArgsDict(TypedDict): + access_key: NotRequired[pulumi.Input[_builtins.str]] + assume_role_arn: NotRequired[pulumi.Input[_builtins.str]] + secret_key: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysSeqeracomputeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysSeqeracomputeArgs: + def __init__(__self__, *, + access_key: Optional[pulumi.Input[_builtins.str]] = None, + assume_role_arn: Optional[pulumi.Input[_builtins.str]] = None, + secret_key: Optional[pulumi.Input[_builtins.str]] = None): + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if assume_role_arn is not None: + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "access_key") + + @access_key.setter + def access_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "access_key", value) + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "assume_role_arn") + + @assume_role_arn.setter + def assume_role_arn(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "assume_role_arn", value) + + @_builtins.property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "secret_key") + + @secret_key.setter + def secret_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "secret_key", value) + + +if not MYPY: + class CredentialKeysSshArgsDict(TypedDict): + passphrase: NotRequired[pulumi.Input[_builtins.str]] + private_key: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysSshArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysSshArgs: + def __init__(__self__, *, + passphrase: Optional[pulumi.Input[_builtins.str]] = None, + private_key: Optional[pulumi.Input[_builtins.str]] = None): + if passphrase is not None: + pulumi.set(__self__, "passphrase", passphrase) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + + @_builtins.property + @pulumi.getter + def passphrase(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "passphrase") + + @passphrase.setter + def passphrase(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "passphrase", value) + + @_builtins.property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "private_key") + + @private_key.setter + def private_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "private_key", value) + + +if not MYPY: + class CredentialKeysTwAgentArgsDict(TypedDict): + connection_id: NotRequired[pulumi.Input[_builtins.str]] + shared: NotRequired[pulumi.Input[_builtins.bool]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] +elif False: + CredentialKeysTwAgentArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CredentialKeysTwAgentArgs: + def __init__(__self__, *, + connection_id: Optional[pulumi.Input[_builtins.str]] = None, + shared: Optional[pulumi.Input[_builtins.bool]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + if connection_id is not None: + pulumi.set(__self__, "connection_id", connection_id) + if shared is not None: + pulumi.set(__self__, "shared", shared) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="connectionId") + def connection_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "connection_id") + + @connection_id.setter + def connection_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "connection_id", value) + + @_builtins.property + @pulumi.getter + def shared(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "shared") + + @shared.setter + def shared(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "shared", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class DataLinkCredentialArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + provider_type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ +elif False: + DataLinkCredentialArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class DataLinkCredentialArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + +if not MYPY: + class LabelsLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + LabelsLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LabelsLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class PipelineComputeEnvArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + platform: NotRequired[pulumi.Input[_builtins.str]] + region: NotRequired[pulumi.Input[_builtins.str]] +elif False: + PipelineComputeEnvArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class PipelineComputeEnvArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + platform: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None): + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if region is not None: + pulumi.set(__self__, "region", region) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + +if not MYPY: + class PipelineLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + PipelineLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class PipelineLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class PipelineLaunchArgsDict(TypedDict): + compute_env_id: pulumi.Input[_builtins.str] + pipeline: pulumi.Input[_builtins.str] + work_dir: pulumi.Input[_builtins.str] + config_profiles: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + config_text: NotRequired[pulumi.Input[_builtins.str]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + entry_name: NotRequired[pulumi.Input[_builtins.str]] + head_job_cpus: NotRequired[pulumi.Input[_builtins.float]] + head_job_memory_mb: NotRequired[pulumi.Input[_builtins.float]] + label_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] + launch_container: NotRequired[pulumi.Input[_builtins.str]] + main_script: NotRequired[pulumi.Input[_builtins.str]] + optimization_id: NotRequired[pulumi.Input[_builtins.str]] + optimization_targets: NotRequired[pulumi.Input[_builtins.str]] + params_text: NotRequired[pulumi.Input[_builtins.str]] + post_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pre_run_script: NotRequired[pulumi.Input[_builtins.str]] + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pull_latest: NotRequired[pulumi.Input[_builtins.bool]] + resume: NotRequired[pulumi.Input[_builtins.bool]] + revision: NotRequired[pulumi.Input[_builtins.str]] + run_name: NotRequired[pulumi.Input[_builtins.str]] + schema_name: NotRequired[pulumi.Input[_builtins.str]] + session_id: NotRequired[pulumi.Input[_builtins.str]] + stub_run: NotRequired[pulumi.Input[_builtins.bool]] + tower_config: NotRequired[pulumi.Input[_builtins.str]] + user_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + workspace_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] +elif False: + PipelineLaunchArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class PipelineLaunchArgs: + def __init__(__self__, *, + compute_env_id: pulumi.Input[_builtins.str], + pipeline: pulumi.Input[_builtins.str], + work_dir: pulumi.Input[_builtins.str], + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def pipeline(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "pipeline") + + @pipeline.setter + def pipeline(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "pipeline", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "config_profiles") + + @config_profiles.setter + def config_profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_profiles", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "entry_name") + + @entry_name.setter + def entry_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "entry_name", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_container") + + @launch_container.setter + def launch_container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_container", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "params_text") + + @params_text.setter + def params_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "params_text", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "pull_latest") + + @pull_latest.setter + def pull_latest(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "pull_latest", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "schema_name") + + @schema_name.setter + def schema_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "schema_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "stub_run") + + @stub_run.setter + def stub_run(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "stub_run", value) + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "tower_config") + + @tower_config.setter + def tower_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tower_config", value) + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "user_secrets") + + @user_secrets.setter + def user_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "user_secrets", value) + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "workspace_secrets") + + @workspace_secrets.setter + def workspace_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "workspace_secrets", value) + + +if not MYPY: + class StudiosActiveConnectionArgsDict(TypedDict): + avatar: NotRequired[pulumi.Input[_builtins.str]] + email: NotRequired[pulumi.Input[_builtins.str]] + id: NotRequired[pulumi.Input[_builtins.float]] + last_active: NotRequired[pulumi.Input[_builtins.str]] + user_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosActiveConnectionArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosActiveConnectionArgs: + def __init__(__self__, *, + avatar: Optional[pulumi.Input[_builtins.str]] = None, + email: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + last_active: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None): + if avatar is not None: + pulumi.set(__self__, "avatar", avatar) + if email is not None: + pulumi.set(__self__, "email", email) + if id is not None: + pulumi.set(__self__, "id", id) + if last_active is not None: + pulumi.set(__self__, "last_active", last_active) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "avatar") + + @avatar.setter + def avatar(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar", value) + + @_builtins.property + @pulumi.getter + def email(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "email") + + @email.setter + def email(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "email", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="lastActive") + def last_active(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_active") + + @last_active.setter + def last_active(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_active", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + +if not MYPY: + class StudiosComputeEnvArgsDict(TypedDict): + credentials_id: NotRequired[pulumi.Input[_builtins.str]] + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + platform: NotRequired[pulumi.Input[_builtins.str]] + region: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosComputeEnvArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosComputeEnvArgs: + def __init__(__self__, *, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + platform: Optional[pulumi.Input[_builtins.str]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if region is not None: + pulumi.set(__self__, "region", region) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class StudiosConfigurationArgsDict(TypedDict): + conda_environment: NotRequired[pulumi.Input[_builtins.str]] + """ + Requires replacement if changed. + """ + cpu: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + gpu: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + lifespan_hours: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + memory: NotRequired[pulumi.Input[_builtins.float]] + """ + Requires replacement if changed. + """ + mount_datas: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + """ + Requires replacement if changed. + """ +elif False: + StudiosConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosConfigurationArgs: + def __init__(__self__, *, + conda_environment: Optional[pulumi.Input[_builtins.str]] = None, + cpu: Optional[pulumi.Input[_builtins.float]] = None, + gpu: Optional[pulumi.Input[_builtins.float]] = None, + lifespan_hours: Optional[pulumi.Input[_builtins.float]] = None, + memory: Optional[pulumi.Input[_builtins.float]] = None, + mount_datas: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] conda_environment: Requires replacement if changed. + :param pulumi.Input[_builtins.float] cpu: Requires replacement if changed. + :param pulumi.Input[_builtins.float] gpu: Requires replacement if changed. + :param pulumi.Input[_builtins.float] lifespan_hours: Requires replacement if changed. + :param pulumi.Input[_builtins.float] memory: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] mount_datas: Requires replacement if changed. + """ + if conda_environment is not None: + pulumi.set(__self__, "conda_environment", conda_environment) + if cpu is not None: + pulumi.set(__self__, "cpu", cpu) + if gpu is not None: + pulumi.set(__self__, "gpu", gpu) + if lifespan_hours is not None: + pulumi.set(__self__, "lifespan_hours", lifespan_hours) + if memory is not None: + pulumi.set(__self__, "memory", memory) + if mount_datas is not None: + pulumi.set(__self__, "mount_datas", mount_datas) + + @_builtins.property + @pulumi.getter(name="condaEnvironment") + def conda_environment(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "conda_environment") + + @conda_environment.setter + def conda_environment(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "conda_environment", value) + + @_builtins.property + @pulumi.getter + def cpu(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cpu") + + @cpu.setter + def cpu(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu", value) + + @_builtins.property + @pulumi.getter + def gpu(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu") + + @gpu.setter + def gpu(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "gpu", value) + + @_builtins.property + @pulumi.getter(name="lifespanHours") + def lifespan_hours(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lifespan_hours") + + @lifespan_hours.setter + def lifespan_hours(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "lifespan_hours", value) + + @_builtins.property + @pulumi.getter + def memory(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "memory") + + @memory.setter + def memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory", value) + + @_builtins.property + @pulumi.getter(name="mountDatas") + def mount_datas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "mount_datas") + + @mount_datas.setter + def mount_datas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "mount_datas", value) + + +if not MYPY: + class StudiosLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + StudiosLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class StudiosMountedDataLinkArgsDict(TypedDict): + credentials: NotRequired[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgsDict']]]] + """ + Array of credentials required to access the data link + """ + data_link_id: NotRequired[pulumi.Input[_builtins.str]] + """ + Unique identifier for the data link + """ + description: NotRequired[pulumi.Input[_builtins.str]] + """ + Description of the data link's purpose and contents + """ + hidden: NotRequired[pulumi.Input[_builtins.bool]] + message: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Display name for the data link connection + """ + provider_type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + public_accessible: NotRequired[pulumi.Input[_builtins.bool]] + region: NotRequired[pulumi.Input[_builtins.str]] + """ + Geographic region where the data link is hosted + """ + resource_ref: NotRequired[pulumi.Input[_builtins.str]] + """ + Reference identifier for the external resource + """ + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["VALID", "INVALID"] + """ + type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be "bucket" + """ +elif False: + StudiosMountedDataLinkArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosMountedDataLinkArgs: + def __init__(__self__, *, + credentials: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgs']]]] = None, + data_link_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + hidden: Optional[pulumi.Input[_builtins.bool]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgs']]] credentials: Array of credentials required to access the data link + :param pulumi.Input[_builtins.str] data_link_id: Unique identifier for the data link + :param pulumi.Input[_builtins.str] description: Description of the data link's purpose and contents + :param pulumi.Input[_builtins.str] name: Display name for the data link connection + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + :param pulumi.Input[_builtins.str] region: Geographic region where the data link is hosted + :param pulumi.Input[_builtins.str] resource_ref: Reference identifier for the external resource + :param pulumi.Input[_builtins.str] status: must be one of ["VALID", "INVALID"] + :param pulumi.Input[_builtins.str] type: must be "bucket" + """ + if credentials is not None: + pulumi.set(__self__, "credentials", credentials) + if data_link_id is not None: + pulumi.set(__self__, "data_link_id", data_link_id) + if description is not None: + pulumi.set(__self__, "description", description) + if hidden is not None: + pulumi.set(__self__, "hidden", hidden) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + if public_accessible is not None: + pulumi.set(__self__, "public_accessible", public_accessible) + if region is not None: + pulumi.set(__self__, "region", region) + if resource_ref is not None: + pulumi.set(__self__, "resource_ref", resource_ref) + if status is not None: + pulumi.set(__self__, "status", status) + if type is not None: + pulumi.set(__self__, "type", type) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgs']]]]: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @credentials.setter + def credentials(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkCredentialArgs']]]]): + pulumi.set(self, "credentials", value) + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @data_link_id.setter + def data_link_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "data_link_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Description of the data link's purpose and contents + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def hidden(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "hidden") + + @hidden.setter + def hidden(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "hidden", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Display name for the data link connection + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "public_accessible") + + @public_accessible.setter + def public_accessible(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "public_accessible", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Reference identifier for the external resource + """ + return pulumi.get(self, "resource_ref") + + @resource_ref.setter + def resource_ref(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "resource_ref", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["VALID", "INVALID"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be "bucket" + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + +if not MYPY: + class StudiosMountedDataLinkCredentialArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + provider_type: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ +elif False: + StudiosMountedDataLinkCredentialArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosMountedDataLinkCredentialArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + +if not MYPY: + class StudiosParentCheckpointArgsDict(TypedDict): + checkpoint_id: NotRequired[pulumi.Input[_builtins.float]] + checkpoint_name: NotRequired[pulumi.Input[_builtins.str]] + session_id: NotRequired[pulumi.Input[_builtins.str]] + studio_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosParentCheckpointArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosParentCheckpointArgs: + def __init__(__self__, *, + checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + checkpoint_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + studio_name: Optional[pulumi.Input[_builtins.str]] = None): + if checkpoint_id is not None: + pulumi.set(__self__, "checkpoint_id", checkpoint_id) + if checkpoint_name is not None: + pulumi.set(__self__, "checkpoint_name", checkpoint_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if studio_name is not None: + pulumi.set(__self__, "studio_name", studio_name) + + @_builtins.property + @pulumi.getter(name="checkpointId") + def checkpoint_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "checkpoint_id") + + @checkpoint_id.setter + def checkpoint_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "checkpoint_id", value) + + @_builtins.property + @pulumi.getter(name="checkpointName") + def checkpoint_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "checkpoint_name") + + @checkpoint_name.setter + def checkpoint_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "checkpoint_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="studioName") + def studio_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "studio_name") + + @studio_name.setter + def studio_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "studio_name", value) + + +if not MYPY: + class StudiosProgressArgsDict(TypedDict): + message: NotRequired[pulumi.Input[_builtins.str]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + warnings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] +elif False: + StudiosProgressArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosProgressArgs: + def __init__(__self__, *, + message: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + warnings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + :param pulumi.Input[_builtins.str] status: must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + if message is not None: + pulumi.set(__self__, "message", message) + if status is not None: + pulumi.set(__self__, "status", status) + if warnings is not None: + pulumi.set(__self__, "warnings", warnings) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def warnings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "warnings") + + @warnings.setter + def warnings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "warnings", value) + + +if not MYPY: + class StudiosStatusInfoArgsDict(TypedDict): + last_update: NotRequired[pulumi.Input[_builtins.str]] + message: NotRequired[pulumi.Input[_builtins.str]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ +elif False: + StudiosStatusInfoArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosStatusInfoArgs: + def __init__(__self__, *, + last_update: Optional[pulumi.Input[_builtins.str]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] status: must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ + if last_update is not None: + pulumi.set(__self__, "last_update", last_update) + if message is not None: + pulumi.set(__self__, "message", message) + if status is not None: + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="lastUpdate") + def last_update(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_update") + + @last_update.setter + def last_update(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_update", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + +if not MYPY: + class StudiosTemplateArgsDict(TypedDict): + icon: NotRequired[pulumi.Input[_builtins.str]] + repository: NotRequired[pulumi.Input[_builtins.str]] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + tool: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosTemplateArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosTemplateArgs: + def __init__(__self__, *, + icon: Optional[pulumi.Input[_builtins.str]] = None, + repository: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + tool: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] status: must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + if icon is not None: + pulumi.set(__self__, "icon", icon) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if status is not None: + pulumi.set(__self__, "status", status) + if tool is not None: + pulumi.set(__self__, "tool", tool) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "icon") + + @icon.setter + def icon(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "icon", value) + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "repository") + + @repository.setter + def repository(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "repository", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def tool(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "tool") + + @tool.setter + def tool(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tool", value) + + +if not MYPY: + class StudiosUserArgsDict(TypedDict): + avatar: NotRequired[pulumi.Input[_builtins.str]] + email: NotRequired[pulumi.Input[_builtins.str]] + id: NotRequired[pulumi.Input[_builtins.float]] + user_name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + StudiosUserArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class StudiosUserArgs: + def __init__(__self__, *, + avatar: Optional[pulumi.Input[_builtins.str]] = None, + email: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None): + if avatar is not None: + pulumi.set(__self__, "avatar", avatar) + if email is not None: + pulumi.set(__self__, "email", email) + if id is not None: + pulumi.set(__self__, "id", id) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "avatar") + + @avatar.setter + def avatar(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar", value) + + @_builtins.property + @pulumi.getter + def email(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "email") + + @email.setter + def email(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "email", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + +if not MYPY: + class TokensTokenArgsDict(TypedDict): + basic_auth: NotRequired[pulumi.Input[_builtins.str]] + """ + Deprecated basic authentication string + """ + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the token was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the access token (nullable) + """ + last_used: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the token was last used for authentication + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Display name for the token (1-50 characters) + """ +elif False: + TokensTokenArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class TokensTokenArgs: + def __init__(__self__, *, + basic_auth: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] basic_auth: Deprecated basic authentication string + :param pulumi.Input[_builtins.str] date_created: Timestamp when the token was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the access token (nullable) + :param pulumi.Input[_builtins.str] last_used: Timestamp when the token was last used for authentication + :param pulumi.Input[_builtins.str] name: Display name for the token (1-50 characters) + """ + if basic_auth is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""basic_auth is deprecated: Deprecated""") + if basic_auth is not None: + pulumi.set(__self__, "basic_auth", basic_auth) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Deprecated basic authentication string + """ + return pulumi.get(self, "basic_auth") + + @basic_auth.setter + def basic_auth(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "basic_auth", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the token was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the access token (nullable) + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the token was last used for authentication + """ + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Display name for the token (1-50 characters) + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +if not MYPY: + class WorkflowsJobInfoArgsDict(TypedDict): + exit_code: NotRequired[pulumi.Input[_builtins.float]] + id: NotRequired[pulumi.Input[_builtins.float]] + message: NotRequired[pulumi.Input[_builtins.str]] + operation_id: NotRequired[pulumi.Input[_builtins.str]] + status: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsJobInfoArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsJobInfoArgs: + def __init__(__self__, *, + exit_code: Optional[pulumi.Input[_builtins.float]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + operation_id: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None): + if exit_code is not None: + pulumi.set(__self__, "exit_code", exit_code) + if id is not None: + pulumi.set(__self__, "id", id) + if message is not None: + pulumi.set(__self__, "message", message) + if operation_id is not None: + pulumi.set(__self__, "operation_id", operation_id) + if status is not None: + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="exitCode") + def exit_code(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "exit_code") + + @exit_code.setter + def exit_code(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "exit_code", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "operation_id") + + @operation_id.setter + def operation_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "operation_id", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + +if not MYPY: + class WorkflowsLabelArgsDict(TypedDict): + date_created: NotRequired[pulumi.Input[_builtins.str]] + """ + Timestamp when the label was created + """ + id: NotRequired[pulumi.Input[_builtins.float]] + """ + Unique numeric identifier for the label + """ + is_default: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a default system label + """ + name: NotRequired[pulumi.Input[_builtins.str]] + """ + Name or key of the label + """ + resource: NotRequired[pulumi.Input[_builtins.bool]] + """ + Flag indicating if this is a resource-level label + """ + value: NotRequired[pulumi.Input[_builtins.str]] + """ + Value associated with the label + """ +elif False: + WorkflowsLabelArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsLabelArgs: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.float]] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] date_created: Timestamp when the label was created + :param pulumi.Input[_builtins.float] id: Unique numeric identifier for the label + :param pulumi.Input[_builtins.bool] is_default: Flag indicating if this is a default system label + :param pulumi.Input[_builtins.str] name: Name or key of the label + :param pulumi.Input[_builtins.bool] resource: Flag indicating if this is a resource-level label + :param pulumi.Input[_builtins.str] value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class WorkflowsPlatformArgsDict(TypedDict): + id: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsPlatformArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsPlatformArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +if not MYPY: + class WorkflowsProgressArgsDict(TypedDict): + processes_progresses: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkflowsProgressProcessesProgressArgsDict']]]] + total_processes: NotRequired[pulumi.Input[_builtins.float]] + workflow_progress: NotRequired[pulumi.Input['WorkflowsProgressWorkflowProgressArgsDict']] +elif False: + WorkflowsProgressArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsProgressArgs: + def __init__(__self__, *, + processes_progresses: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsProgressProcessesProgressArgs']]]] = None, + total_processes: Optional[pulumi.Input[_builtins.float]] = None, + workflow_progress: Optional[pulumi.Input['WorkflowsProgressWorkflowProgressArgs']] = None): + if processes_progresses is not None: + pulumi.set(__self__, "processes_progresses", processes_progresses) + if total_processes is not None: + pulumi.set(__self__, "total_processes", total_processes) + if workflow_progress is not None: + pulumi.set(__self__, "workflow_progress", workflow_progress) + + @_builtins.property + @pulumi.getter(name="processesProgresses") + def processes_progresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsProgressProcessesProgressArgs']]]]: + return pulumi.get(self, "processes_progresses") + + @processes_progresses.setter + def processes_progresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsProgressProcessesProgressArgs']]]]): + pulumi.set(self, "processes_progresses", value) + + @_builtins.property + @pulumi.getter(name="totalProcesses") + def total_processes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "total_processes") + + @total_processes.setter + def total_processes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "total_processes", value) + + @_builtins.property + @pulumi.getter(name="workflowProgress") + def workflow_progress(self) -> Optional[pulumi.Input['WorkflowsProgressWorkflowProgressArgs']]: + return pulumi.get(self, "workflow_progress") + + @workflow_progress.setter + def workflow_progress(self, value: Optional[pulumi.Input['WorkflowsProgressWorkflowProgressArgs']]): + pulumi.set(self, "workflow_progress", value) + + +if not MYPY: + class WorkflowsProgressProcessesProgressArgsDict(TypedDict): + aborted: NotRequired[pulumi.Input[_builtins.float]] + cached: NotRequired[pulumi.Input[_builtins.float]] + cpu_efficiency: NotRequired[pulumi.Input[_builtins.float]] + cpu_load: NotRequired[pulumi.Input[_builtins.float]] + cpu_time: NotRequired[pulumi.Input[_builtins.float]] + cpus: NotRequired[pulumi.Input[_builtins.float]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + failed: NotRequired[pulumi.Input[_builtins.float]] + inv_ctx_switch: NotRequired[pulumi.Input[_builtins.float]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + load_cpus: NotRequired[pulumi.Input[_builtins.float]] + load_memory: NotRequired[pulumi.Input[_builtins.float]] + load_tasks: NotRequired[pulumi.Input[_builtins.float]] + memory_efficiency: NotRequired[pulumi.Input[_builtins.float]] + memory_req: NotRequired[pulumi.Input[_builtins.float]] + memory_rss: NotRequired[pulumi.Input[_builtins.float]] + peak_cpus: NotRequired[pulumi.Input[_builtins.float]] + peak_memory: NotRequired[pulumi.Input[_builtins.float]] + peak_tasks: NotRequired[pulumi.Input[_builtins.float]] + pending: NotRequired[pulumi.Input[_builtins.float]] + process: NotRequired[pulumi.Input[_builtins.str]] + read_bytes: NotRequired[pulumi.Input[_builtins.float]] + running: NotRequired[pulumi.Input[_builtins.float]] + submitted: NotRequired[pulumi.Input[_builtins.float]] + succeeded: NotRequired[pulumi.Input[_builtins.float]] + vol_ctx_switch: NotRequired[pulumi.Input[_builtins.float]] + write_bytes: NotRequired[pulumi.Input[_builtins.float]] +elif False: + WorkflowsProgressProcessesProgressArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsProgressProcessesProgressArgs: + def __init__(__self__, *, + aborted: Optional[pulumi.Input[_builtins.float]] = None, + cached: Optional[pulumi.Input[_builtins.float]] = None, + cpu_efficiency: Optional[pulumi.Input[_builtins.float]] = None, + cpu_load: Optional[pulumi.Input[_builtins.float]] = None, + cpu_time: Optional[pulumi.Input[_builtins.float]] = None, + cpus: Optional[pulumi.Input[_builtins.float]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + failed: Optional[pulumi.Input[_builtins.float]] = None, + inv_ctx_switch: Optional[pulumi.Input[_builtins.float]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + load_cpus: Optional[pulumi.Input[_builtins.float]] = None, + load_memory: Optional[pulumi.Input[_builtins.float]] = None, + load_tasks: Optional[pulumi.Input[_builtins.float]] = None, + memory_efficiency: Optional[pulumi.Input[_builtins.float]] = None, + memory_req: Optional[pulumi.Input[_builtins.float]] = None, + memory_rss: Optional[pulumi.Input[_builtins.float]] = None, + peak_cpus: Optional[pulumi.Input[_builtins.float]] = None, + peak_memory: Optional[pulumi.Input[_builtins.float]] = None, + peak_tasks: Optional[pulumi.Input[_builtins.float]] = None, + pending: Optional[pulumi.Input[_builtins.float]] = None, + process: Optional[pulumi.Input[_builtins.str]] = None, + read_bytes: Optional[pulumi.Input[_builtins.float]] = None, + running: Optional[pulumi.Input[_builtins.float]] = None, + submitted: Optional[pulumi.Input[_builtins.float]] = None, + succeeded: Optional[pulumi.Input[_builtins.float]] = None, + vol_ctx_switch: Optional[pulumi.Input[_builtins.float]] = None, + write_bytes: Optional[pulumi.Input[_builtins.float]] = None): + if aborted is not None: + pulumi.set(__self__, "aborted", aborted) + if cached is not None: + pulumi.set(__self__, "cached", cached) + if cpu_efficiency is not None: + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + if cpu_load is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""cpu_load is deprecated: Deprecated""") + if cpu_load is not None: + pulumi.set(__self__, "cpu_load", cpu_load) + if cpu_time is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""cpu_time is deprecated: Deprecated""") + if cpu_time is not None: + pulumi.set(__self__, "cpu_time", cpu_time) + if cpus is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""cpus is deprecated: Deprecated""") + if cpus is not None: + pulumi.set(__self__, "cpus", cpus) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if failed is not None: + pulumi.set(__self__, "failed", failed) + if inv_ctx_switch is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""inv_ctx_switch is deprecated: Deprecated""") + if inv_ctx_switch is not None: + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if load_cpus is not None: + pulumi.set(__self__, "load_cpus", load_cpus) + if load_memory is not None: + pulumi.set(__self__, "load_memory", load_memory) + if load_tasks is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""load_tasks is deprecated: Deprecated""") + if load_tasks is not None: + pulumi.set(__self__, "load_tasks", load_tasks) + if memory_efficiency is not None: + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + if memory_req is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""memory_req is deprecated: Deprecated""") + if memory_req is not None: + pulumi.set(__self__, "memory_req", memory_req) + if memory_rss is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""memory_rss is deprecated: Deprecated""") + if memory_rss is not None: + pulumi.set(__self__, "memory_rss", memory_rss) + if peak_cpus is not None: + pulumi.set(__self__, "peak_cpus", peak_cpus) + if peak_memory is not None: + pulumi.set(__self__, "peak_memory", peak_memory) + if peak_tasks is not None: + pulumi.set(__self__, "peak_tasks", peak_tasks) + if pending is not None: + pulumi.set(__self__, "pending", pending) + if process is not None: + pulumi.set(__self__, "process", process) + if read_bytes is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""read_bytes is deprecated: Deprecated""") + if read_bytes is not None: + pulumi.set(__self__, "read_bytes", read_bytes) + if running is not None: + pulumi.set(__self__, "running", running) + if submitted is not None: + pulumi.set(__self__, "submitted", submitted) + if succeeded is not None: + pulumi.set(__self__, "succeeded", succeeded) + if vol_ctx_switch is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""vol_ctx_switch is deprecated: Deprecated""") + if vol_ctx_switch is not None: + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + if write_bytes is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""write_bytes is deprecated: Deprecated""") + if write_bytes is not None: + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "aborted") + + @aborted.setter + def aborted(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "aborted", value) + + @_builtins.property + @pulumi.getter + def cached(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached") + + @cached.setter + def cached(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached", value) + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_efficiency") + + @cpu_efficiency.setter + def cpu_efficiency(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_efficiency", value) + + @_builtins.property + @pulumi.getter(name="cpuLoad") + @_utilities.deprecated("""Deprecated""") + def cpu_load(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_load") + + @cpu_load.setter + def cpu_load(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_load", value) + + @_builtins.property + @pulumi.getter(name="cpuTime") + @_utilities.deprecated("""Deprecated""") + def cpu_time(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_time") + + @cpu_time.setter + def cpu_time(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_time", value) + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpus") + + @cpus.setter + def cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpus", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def failed(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed") + + @failed.setter + def failed(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed", value) + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def inv_ctx_switch(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "inv_ctx_switch") + + @inv_ctx_switch.setter + def inv_ctx_switch(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "inv_ctx_switch", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_cpus") + + @load_cpus.setter + def load_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_cpus", value) + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_memory") + + @load_memory.setter + def load_memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_memory", value) + + @_builtins.property + @pulumi.getter(name="loadTasks") + @_utilities.deprecated("""Deprecated""") + def load_tasks(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_tasks") + + @load_tasks.setter + def load_tasks(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_tasks", value) + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_efficiency") + + @memory_efficiency.setter + def memory_efficiency(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_efficiency", value) + + @_builtins.property + @pulumi.getter(name="memoryReq") + @_utilities.deprecated("""Deprecated""") + def memory_req(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_req") + + @memory_req.setter + def memory_req(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_req", value) + + @_builtins.property + @pulumi.getter(name="memoryRss") + @_utilities.deprecated("""Deprecated""") + def memory_rss(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_rss") + + @memory_rss.setter + def memory_rss(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_rss", value) + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_cpus") + + @peak_cpus.setter + def peak_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_cpus", value) + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_memory") + + @peak_memory.setter + def peak_memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_memory", value) + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_tasks") + + @peak_tasks.setter + def peak_tasks(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_tasks", value) + + @_builtins.property + @pulumi.getter + def pending(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "pending") + + @pending.setter + def pending(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "pending", value) + + @_builtins.property + @pulumi.getter + def process(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "process") + + @process.setter + def process(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "process", value) + + @_builtins.property + @pulumi.getter(name="readBytes") + @_utilities.deprecated("""Deprecated""") + def read_bytes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "read_bytes") + + @read_bytes.setter + def read_bytes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "read_bytes", value) + + @_builtins.property + @pulumi.getter + def running(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "running") + + @running.setter + def running(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "running", value) + + @_builtins.property + @pulumi.getter + def submitted(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "submitted") + + @submitted.setter + def submitted(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "submitted", value) + + @_builtins.property + @pulumi.getter + def succeeded(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeeded") + + @succeeded.setter + def succeeded(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeeded", value) + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def vol_ctx_switch(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "vol_ctx_switch") + + @vol_ctx_switch.setter + def vol_ctx_switch(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "vol_ctx_switch", value) + + @_builtins.property + @pulumi.getter(name="writeBytes") + @_utilities.deprecated("""Deprecated""") + def write_bytes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "write_bytes") + + @write_bytes.setter + def write_bytes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "write_bytes", value) + + +if not MYPY: + class WorkflowsProgressWorkflowProgressArgsDict(TypedDict): + aborted: NotRequired[pulumi.Input[_builtins.float]] + cached: NotRequired[pulumi.Input[_builtins.float]] + cost: NotRequired[pulumi.Input[_builtins.float]] + cpu_efficiency: NotRequired[pulumi.Input[_builtins.float]] + cpu_load: NotRequired[pulumi.Input[_builtins.float]] + cpu_time: NotRequired[pulumi.Input[_builtins.float]] + cpus: NotRequired[pulumi.Input[_builtins.float]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + executors: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + failed: NotRequired[pulumi.Input[_builtins.float]] + inv_ctx_switch: NotRequired[pulumi.Input[_builtins.float]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + load_cpus: NotRequired[pulumi.Input[_builtins.float]] + load_memory: NotRequired[pulumi.Input[_builtins.float]] + load_tasks: NotRequired[pulumi.Input[_builtins.float]] + memory_efficiency: NotRequired[pulumi.Input[_builtins.float]] + memory_req: NotRequired[pulumi.Input[_builtins.float]] + memory_rss: NotRequired[pulumi.Input[_builtins.float]] + peak_cpus: NotRequired[pulumi.Input[_builtins.float]] + peak_memory: NotRequired[pulumi.Input[_builtins.float]] + peak_tasks: NotRequired[pulumi.Input[_builtins.float]] + pending: NotRequired[pulumi.Input[_builtins.float]] + read_bytes: NotRequired[pulumi.Input[_builtins.float]] + running: NotRequired[pulumi.Input[_builtins.float]] + submitted: NotRequired[pulumi.Input[_builtins.float]] + succeeded: NotRequired[pulumi.Input[_builtins.float]] + vol_ctx_switch: NotRequired[pulumi.Input[_builtins.float]] + write_bytes: NotRequired[pulumi.Input[_builtins.float]] +elif False: + WorkflowsProgressWorkflowProgressArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsProgressWorkflowProgressArgs: + def __init__(__self__, *, + aborted: Optional[pulumi.Input[_builtins.float]] = None, + cached: Optional[pulumi.Input[_builtins.float]] = None, + cost: Optional[pulumi.Input[_builtins.float]] = None, + cpu_efficiency: Optional[pulumi.Input[_builtins.float]] = None, + cpu_load: Optional[pulumi.Input[_builtins.float]] = None, + cpu_time: Optional[pulumi.Input[_builtins.float]] = None, + cpus: Optional[pulumi.Input[_builtins.float]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + executors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + failed: Optional[pulumi.Input[_builtins.float]] = None, + inv_ctx_switch: Optional[pulumi.Input[_builtins.float]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + load_cpus: Optional[pulumi.Input[_builtins.float]] = None, + load_memory: Optional[pulumi.Input[_builtins.float]] = None, + load_tasks: Optional[pulumi.Input[_builtins.float]] = None, + memory_efficiency: Optional[pulumi.Input[_builtins.float]] = None, + memory_req: Optional[pulumi.Input[_builtins.float]] = None, + memory_rss: Optional[pulumi.Input[_builtins.float]] = None, + peak_cpus: Optional[pulumi.Input[_builtins.float]] = None, + peak_memory: Optional[pulumi.Input[_builtins.float]] = None, + peak_tasks: Optional[pulumi.Input[_builtins.float]] = None, + pending: Optional[pulumi.Input[_builtins.float]] = None, + read_bytes: Optional[pulumi.Input[_builtins.float]] = None, + running: Optional[pulumi.Input[_builtins.float]] = None, + submitted: Optional[pulumi.Input[_builtins.float]] = None, + succeeded: Optional[pulumi.Input[_builtins.float]] = None, + vol_ctx_switch: Optional[pulumi.Input[_builtins.float]] = None, + write_bytes: Optional[pulumi.Input[_builtins.float]] = None): + if aborted is not None: + pulumi.set(__self__, "aborted", aborted) + if cached is not None: + pulumi.set(__self__, "cached", cached) + if cost is not None: + pulumi.set(__self__, "cost", cost) + if cpu_efficiency is not None: + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + if cpu_load is not None: + pulumi.set(__self__, "cpu_load", cpu_load) + if cpu_time is not None: + pulumi.set(__self__, "cpu_time", cpu_time) + if cpus is not None: + pulumi.set(__self__, "cpus", cpus) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if executors is not None: + pulumi.set(__self__, "executors", executors) + if failed is not None: + pulumi.set(__self__, "failed", failed) + if inv_ctx_switch is not None: + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if load_cpus is not None: + pulumi.set(__self__, "load_cpus", load_cpus) + if load_memory is not None: + pulumi.set(__self__, "load_memory", load_memory) + if load_tasks is not None: + pulumi.set(__self__, "load_tasks", load_tasks) + if memory_efficiency is not None: + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + if memory_req is not None: + pulumi.set(__self__, "memory_req", memory_req) + if memory_rss is not None: + pulumi.set(__self__, "memory_rss", memory_rss) + if peak_cpus is not None: + pulumi.set(__self__, "peak_cpus", peak_cpus) + if peak_memory is not None: + pulumi.set(__self__, "peak_memory", peak_memory) + if peak_tasks is not None: + pulumi.set(__self__, "peak_tasks", peak_tasks) + if pending is not None: + pulumi.set(__self__, "pending", pending) + if read_bytes is not None: + pulumi.set(__self__, "read_bytes", read_bytes) + if running is not None: + pulumi.set(__self__, "running", running) + if submitted is not None: + pulumi.set(__self__, "submitted", submitted) + if succeeded is not None: + pulumi.set(__self__, "succeeded", succeeded) + if vol_ctx_switch is not None: + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + if write_bytes is not None: + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "aborted") + + @aborted.setter + def aborted(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "aborted", value) + + @_builtins.property + @pulumi.getter + def cached(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached") + + @cached.setter + def cached(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached", value) + + @_builtins.property + @pulumi.getter + def cost(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cost") + + @cost.setter + def cost(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cost", value) + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_efficiency") + + @cpu_efficiency.setter + def cpu_efficiency(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_efficiency", value) + + @_builtins.property + @pulumi.getter(name="cpuLoad") + def cpu_load(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_load") + + @cpu_load.setter + def cpu_load(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_load", value) + + @_builtins.property + @pulumi.getter(name="cpuTime") + def cpu_time(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpu_time") + + @cpu_time.setter + def cpu_time(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpu_time", value) + + @_builtins.property + @pulumi.getter + def cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cpus") + + @cpus.setter + def cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cpus", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def executors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "executors") + + @executors.setter + def executors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "executors", value) + + @_builtins.property + @pulumi.getter + def failed(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed") + + @failed.setter + def failed(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed", value) + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + def inv_ctx_switch(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "inv_ctx_switch") + + @inv_ctx_switch.setter + def inv_ctx_switch(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "inv_ctx_switch", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_cpus") + + @load_cpus.setter + def load_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_cpus", value) + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_memory") + + @load_memory.setter + def load_memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_memory", value) + + @_builtins.property + @pulumi.getter(name="loadTasks") + def load_tasks(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "load_tasks") + + @load_tasks.setter + def load_tasks(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "load_tasks", value) + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_efficiency") + + @memory_efficiency.setter + def memory_efficiency(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_efficiency", value) + + @_builtins.property + @pulumi.getter(name="memoryReq") + def memory_req(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_req") + + @memory_req.setter + def memory_req(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_req", value) + + @_builtins.property + @pulumi.getter(name="memoryRss") + def memory_rss(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "memory_rss") + + @memory_rss.setter + def memory_rss(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "memory_rss", value) + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_cpus") + + @peak_cpus.setter + def peak_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_cpus", value) + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_memory") + + @peak_memory.setter + def peak_memory(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_memory", value) + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "peak_tasks") + + @peak_tasks.setter + def peak_tasks(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "peak_tasks", value) + + @_builtins.property + @pulumi.getter + def pending(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "pending") + + @pending.setter + def pending(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "pending", value) + + @_builtins.property + @pulumi.getter(name="readBytes") + def read_bytes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "read_bytes") + + @read_bytes.setter + def read_bytes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "read_bytes", value) + + @_builtins.property + @pulumi.getter + def running(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "running") + + @running.setter + def running(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "running", value) + + @_builtins.property + @pulumi.getter + def submitted(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "submitted") + + @submitted.setter + def submitted(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "submitted", value) + + @_builtins.property + @pulumi.getter + def succeeded(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeeded") + + @succeeded.setter + def succeeded(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeeded", value) + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + def vol_ctx_switch(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "vol_ctx_switch") + + @vol_ctx_switch.setter + def vol_ctx_switch(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "vol_ctx_switch", value) + + @_builtins.property + @pulumi.getter(name="writeBytes") + def write_bytes(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "write_bytes") + + @write_bytes.setter + def write_bytes(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "write_bytes", value) + + +if not MYPY: + class WorkflowsWorkflowArgsDict(TypedDict): + command_line: NotRequired[pulumi.Input[_builtins.str]] + commit_id: NotRequired[pulumi.Input[_builtins.str]] + complete: NotRequired[pulumi.Input[_builtins.str]] + config_files: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] + config_text: NotRequired[pulumi.Input[_builtins.str]] + container: NotRequired[pulumi.Input[_builtins.str]] + container_engine: NotRequired[pulumi.Input[_builtins.str]] + date_created: NotRequired[pulumi.Input[_builtins.str]] + deleted: NotRequired[pulumi.Input[_builtins.bool]] + duration: NotRequired[pulumi.Input[_builtins.float]] + error_message: NotRequired[pulumi.Input[_builtins.str]] + error_report: NotRequired[pulumi.Input[_builtins.str]] + exit_status: NotRequired[pulumi.Input[_builtins.float]] + home_dir: NotRequired[pulumi.Input[_builtins.str]] + id: NotRequired[pulumi.Input[_builtins.str]] + last_updated: NotRequired[pulumi.Input[_builtins.str]] + launch_dir: NotRequired[pulumi.Input[_builtins.str]] + launch_id: NotRequired[pulumi.Input[_builtins.str]] + log_file: NotRequired[pulumi.Input[_builtins.str]] + manifest: NotRequired[pulumi.Input['WorkflowsWorkflowManifestArgsDict']] + nextflow: NotRequired[pulumi.Input['WorkflowsWorkflowNextflowArgsDict']] + operation_id: NotRequired[pulumi.Input[_builtins.str]] + out_file: NotRequired[pulumi.Input[_builtins.str]] + owner_id: NotRequired[pulumi.Input[_builtins.float]] + params: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] + profile: NotRequired[pulumi.Input[_builtins.str]] + project_dir: NotRequired[pulumi.Input[_builtins.str]] + project_name: NotRequired[pulumi.Input[_builtins.str]] + repository: NotRequired[pulumi.Input[_builtins.str]] + requires_attention: NotRequired[pulumi.Input[_builtins.bool]] + resume: NotRequired[pulumi.Input[_builtins.bool]] + revision: NotRequired[pulumi.Input[_builtins.str]] + run_name: NotRequired[pulumi.Input[_builtins.str]] + script_file: NotRequired[pulumi.Input[_builtins.str]] + script_id: NotRequired[pulumi.Input[_builtins.str]] + script_name: NotRequired[pulumi.Input[_builtins.str]] + session_id: NotRequired[pulumi.Input[_builtins.str]] + start: NotRequired[pulumi.Input[_builtins.str]] + stats: NotRequired[pulumi.Input['WorkflowsWorkflowStatsArgsDict']] + status: NotRequired[pulumi.Input[_builtins.str]] + """ + must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + submit: NotRequired[pulumi.Input[_builtins.str]] + success: NotRequired[pulumi.Input[_builtins.bool]] + user_name: NotRequired[pulumi.Input[_builtins.str]] + work_dir: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsWorkflowArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsWorkflowArgs: + def __init__(__self__, *, + command_line: Optional[pulumi.Input[_builtins.str]] = None, + commit_id: Optional[pulumi.Input[_builtins.str]] = None, + complete: Optional[pulumi.Input[_builtins.str]] = None, + config_files: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + container: Optional[pulumi.Input[_builtins.str]] = None, + container_engine: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + duration: Optional[pulumi.Input[_builtins.float]] = None, + error_message: Optional[pulumi.Input[_builtins.str]] = None, + error_report: Optional[pulumi.Input[_builtins.str]] = None, + exit_status: Optional[pulumi.Input[_builtins.float]] = None, + home_dir: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch_dir: Optional[pulumi.Input[_builtins.str]] = None, + launch_id: Optional[pulumi.Input[_builtins.str]] = None, + log_file: Optional[pulumi.Input[_builtins.str]] = None, + manifest: Optional[pulumi.Input['WorkflowsWorkflowManifestArgs']] = None, + nextflow: Optional[pulumi.Input['WorkflowsWorkflowNextflowArgs']] = None, + operation_id: Optional[pulumi.Input[_builtins.str]] = None, + out_file: Optional[pulumi.Input[_builtins.str]] = None, + owner_id: Optional[pulumi.Input[_builtins.float]] = None, + params: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None, + profile: Optional[pulumi.Input[_builtins.str]] = None, + project_dir: Optional[pulumi.Input[_builtins.str]] = None, + project_name: Optional[pulumi.Input[_builtins.str]] = None, + repository: Optional[pulumi.Input[_builtins.str]] = None, + requires_attention: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + script_file: Optional[pulumi.Input[_builtins.str]] = None, + script_id: Optional[pulumi.Input[_builtins.str]] = None, + script_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + start: Optional[pulumi.Input[_builtins.str]] = None, + stats: Optional[pulumi.Input['WorkflowsWorkflowStatsArgs']] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + submit: Optional[pulumi.Input[_builtins.str]] = None, + success: Optional[pulumi.Input[_builtins.bool]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None): + """ + :param pulumi.Input[_builtins.str] status: must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + if command_line is not None: + pulumi.set(__self__, "command_line", command_line) + if commit_id is not None: + pulumi.set(__self__, "commit_id", commit_id) + if complete is not None: + pulumi.set(__self__, "complete", complete) + if config_files is not None: + pulumi.set(__self__, "config_files", config_files) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if container is not None: + pulumi.set(__self__, "container", container) + if container_engine is not None: + pulumi.set(__self__, "container_engine", container_engine) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error_message is not None: + pulumi.set(__self__, "error_message", error_message) + if error_report is not None: + pulumi.set(__self__, "error_report", error_report) + if exit_status is not None: + pulumi.set(__self__, "exit_status", exit_status) + if home_dir is not None: + pulumi.set(__self__, "home_dir", home_dir) + if id is not None: + pulumi.set(__self__, "id", id) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if launch_id is not None: + pulumi.set(__self__, "launch_id", launch_id) + if log_file is not None: + pulumi.set(__self__, "log_file", log_file) + if manifest is not None: + pulumi.set(__self__, "manifest", manifest) + if nextflow is not None: + pulumi.set(__self__, "nextflow", nextflow) + if operation_id is not None: + pulumi.set(__self__, "operation_id", operation_id) + if out_file is not None: + pulumi.set(__self__, "out_file", out_file) + if owner_id is not None: + pulumi.set(__self__, "owner_id", owner_id) + if params is not None: + pulumi.set(__self__, "params", params) + if profile is not None: + pulumi.set(__self__, "profile", profile) + if project_dir is not None: + pulumi.set(__self__, "project_dir", project_dir) + if project_name is not None: + pulumi.set(__self__, "project_name", project_name) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if requires_attention is not None: + pulumi.set(__self__, "requires_attention", requires_attention) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if script_file is not None: + pulumi.set(__self__, "script_file", script_file) + if script_id is not None: + pulumi.set(__self__, "script_id", script_id) + if script_name is not None: + pulumi.set(__self__, "script_name", script_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if start is not None: + pulumi.set(__self__, "start", start) + if stats is not None: + pulumi.set(__self__, "stats", stats) + if status is not None: + pulumi.set(__self__, "status", status) + if submit is not None: + pulumi.set(__self__, "submit", submit) + if success is not None: + pulumi.set(__self__, "success", success) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="commandLine") + def command_line(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "command_line") + + @command_line.setter + def command_line(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "command_line", value) + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "commit_id") + + @commit_id.setter + def commit_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "commit_id", value) + + @_builtins.property + @pulumi.getter + def complete(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "complete") + + @complete.setter + def complete(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "complete", value) + + @_builtins.property + @pulumi.getter(name="configFiles") + def config_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "config_files") + + @config_files.setter + def config_files(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_files", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter + def container(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "container") + + @container.setter + def container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "container", value) + + @_builtins.property + @pulumi.getter(name="containerEngine") + def container_engine(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "container_engine") + + @container_engine.setter + def container_engine(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "container_engine", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def duration(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "duration") + + @duration.setter + def duration(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "duration", value) + + @_builtins.property + @pulumi.getter(name="errorMessage") + def error_message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "error_message") + + @error_message.setter + def error_message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "error_message", value) + + @_builtins.property + @pulumi.getter(name="errorReport") + def error_report(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "error_report") + + @error_report.setter + def error_report(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "error_report", value) + + @_builtins.property + @pulumi.getter(name="exitStatus") + def exit_status(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "exit_status") + + @exit_status.setter + def exit_status(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "exit_status", value) + + @_builtins.property + @pulumi.getter(name="homeDir") + def home_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "home_dir") + + @home_dir.setter + def home_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "home_dir", value) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "id", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_dir") + + @launch_dir.setter + def launch_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_dir", value) + + @_builtins.property + @pulumi.getter(name="launchId") + def launch_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "launch_id") + + @launch_id.setter + def launch_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_id", value) + + @_builtins.property + @pulumi.getter(name="logFile") + def log_file(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "log_file") + + @log_file.setter + def log_file(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "log_file", value) + + @_builtins.property + @pulumi.getter + def manifest(self) -> Optional[pulumi.Input['WorkflowsWorkflowManifestArgs']]: + return pulumi.get(self, "manifest") + + @manifest.setter + def manifest(self, value: Optional[pulumi.Input['WorkflowsWorkflowManifestArgs']]): + pulumi.set(self, "manifest", value) + + @_builtins.property + @pulumi.getter + def nextflow(self) -> Optional[pulumi.Input['WorkflowsWorkflowNextflowArgs']]: + return pulumi.get(self, "nextflow") + + @nextflow.setter + def nextflow(self, value: Optional[pulumi.Input['WorkflowsWorkflowNextflowArgs']]): + pulumi.set(self, "nextflow", value) + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "operation_id") + + @operation_id.setter + def operation_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "operation_id", value) + + @_builtins.property + @pulumi.getter(name="outFile") + def out_file(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "out_file") + + @out_file.setter + def out_file(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "out_file", value) + + @_builtins.property + @pulumi.getter(name="ownerId") + def owner_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "owner_id") + + @owner_id.setter + def owner_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "owner_id", value) + + @_builtins.property + @pulumi.getter + def params(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "params") + + @params.setter + def params(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "params", value) + + @_builtins.property + @pulumi.getter + def profile(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "profile") + + @profile.setter + def profile(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "profile", value) + + @_builtins.property + @pulumi.getter(name="projectDir") + def project_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "project_dir") + + @project_dir.setter + def project_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_dir", value) + + @_builtins.property + @pulumi.getter(name="projectName") + def project_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "project_name") + + @project_name.setter + def project_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "project_name", value) + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "repository") + + @repository.setter + def repository(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "repository", value) + + @_builtins.property + @pulumi.getter(name="requiresAttention") + def requires_attention(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "requires_attention") + + @requires_attention.setter + def requires_attention(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "requires_attention", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="scriptFile") + def script_file(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "script_file") + + @script_file.setter + def script_file(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "script_file", value) + + @_builtins.property + @pulumi.getter(name="scriptId") + def script_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "script_id") + + @script_id.setter + def script_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "script_id", value) + + @_builtins.property + @pulumi.getter(name="scriptName") + def script_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "script_name") + + @script_name.setter + def script_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "script_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter + def start(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "start") + + @start.setter + def start(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "start", value) + + @_builtins.property + @pulumi.getter + def stats(self) -> Optional[pulumi.Input['WorkflowsWorkflowStatsArgs']]: + return pulumi.get(self, "stats") + + @stats.setter + def stats(self, value: Optional[pulumi.Input['WorkflowsWorkflowStatsArgs']]): + pulumi.set(self, "stats", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def submit(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "submit") + + @submit.setter + def submit(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "submit", value) + + @_builtins.property + @pulumi.getter + def success(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "success") + + @success.setter + def success(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "success", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + +if not MYPY: + class WorkflowsWorkflowManifestArgsDict(TypedDict): + author: NotRequired[pulumi.Input[_builtins.str]] + default_branch: NotRequired[pulumi.Input[_builtins.str]] + description: NotRequired[pulumi.Input[_builtins.str]] + gitmodules: NotRequired[pulumi.Input[_builtins.str]] + home_page: NotRequired[pulumi.Input[_builtins.str]] + icon: NotRequired[pulumi.Input[_builtins.str]] + main_script: NotRequired[pulumi.Input[_builtins.str]] + name: NotRequired[pulumi.Input[_builtins.str]] + nextflow_version: NotRequired[pulumi.Input[_builtins.str]] + version: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsWorkflowManifestArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsWorkflowManifestArgs: + def __init__(__self__, *, + author: Optional[pulumi.Input[_builtins.str]] = None, + default_branch: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + gitmodules: Optional[pulumi.Input[_builtins.str]] = None, + home_page: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + nextflow_version: Optional[pulumi.Input[_builtins.str]] = None, + version: Optional[pulumi.Input[_builtins.str]] = None): + if author is not None: + pulumi.set(__self__, "author", author) + if default_branch is not None: + pulumi.set(__self__, "default_branch", default_branch) + if description is not None: + pulumi.set(__self__, "description", description) + if gitmodules is not None: + pulumi.set(__self__, "gitmodules", gitmodules) + if home_page is not None: + pulumi.set(__self__, "home_page", home_page) + if icon is not None: + pulumi.set(__self__, "icon", icon) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if name is not None: + pulumi.set(__self__, "name", name) + if nextflow_version is not None: + pulumi.set(__self__, "nextflow_version", nextflow_version) + if version is not None: + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def author(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "author") + + @author.setter + def author(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "author", value) + + @_builtins.property + @pulumi.getter(name="defaultBranch") + def default_branch(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "default_branch") + + @default_branch.setter + def default_branch(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "default_branch", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def gitmodules(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "gitmodules") + + @gitmodules.setter + def gitmodules(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "gitmodules", value) + + @_builtins.property + @pulumi.getter(name="homePage") + def home_page(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "home_page") + + @home_page.setter + def home_page(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "home_page", value) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "icon") + + @icon.setter + def icon(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "icon", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="nextflowVersion") + def nextflow_version(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "nextflow_version") + + @nextflow_version.setter + def nextflow_version(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "nextflow_version", value) + + @_builtins.property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "version", value) + + +if not MYPY: + class WorkflowsWorkflowNextflowArgsDict(TypedDict): + build: NotRequired[pulumi.Input[_builtins.str]] + timestamp: NotRequired[pulumi.Input[_builtins.str]] + version: NotRequired[pulumi.Input[_builtins.str]] +elif False: + WorkflowsWorkflowNextflowArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsWorkflowNextflowArgs: + def __init__(__self__, *, + build: Optional[pulumi.Input[_builtins.str]] = None, + timestamp: Optional[pulumi.Input[_builtins.str]] = None, + version: Optional[pulumi.Input[_builtins.str]] = None): + if build is not None: + pulumi.set(__self__, "build", build) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + if version is not None: + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def build(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "build") + + @build.setter + def build(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "build", value) + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "timestamp") + + @timestamp.setter + def timestamp(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "timestamp", value) + + @_builtins.property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "version", value) + + +if not MYPY: + class WorkflowsWorkflowStatsArgsDict(TypedDict): + cached_count: NotRequired[pulumi.Input[_builtins.float]] + cached_count_fmt: NotRequired[pulumi.Input[_builtins.str]] + cached_duration: NotRequired[pulumi.Input[_builtins.float]] + cached_pct: NotRequired[pulumi.Input[_builtins.float]] + compute_time_fmt: NotRequired[pulumi.Input[_builtins.str]] + failed_count: NotRequired[pulumi.Input[_builtins.float]] + failed_count_fmt: NotRequired[pulumi.Input[_builtins.str]] + failed_duration: NotRequired[pulumi.Input[_builtins.float]] + failed_pct: NotRequired[pulumi.Input[_builtins.float]] + ignored_count: NotRequired[pulumi.Input[_builtins.float]] + ignored_count_fmt: NotRequired[pulumi.Input[_builtins.str]] + ignored_pct: NotRequired[pulumi.Input[_builtins.float]] + succeed_count: NotRequired[pulumi.Input[_builtins.float]] + succeed_count_fmt: NotRequired[pulumi.Input[_builtins.str]] + succeed_duration: NotRequired[pulumi.Input[_builtins.float]] + succeed_pct: NotRequired[pulumi.Input[_builtins.float]] +elif False: + WorkflowsWorkflowStatsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class WorkflowsWorkflowStatsArgs: + def __init__(__self__, *, + cached_count: Optional[pulumi.Input[_builtins.float]] = None, + cached_count_fmt: Optional[pulumi.Input[_builtins.str]] = None, + cached_duration: Optional[pulumi.Input[_builtins.float]] = None, + cached_pct: Optional[pulumi.Input[_builtins.float]] = None, + compute_time_fmt: Optional[pulumi.Input[_builtins.str]] = None, + failed_count: Optional[pulumi.Input[_builtins.float]] = None, + failed_count_fmt: Optional[pulumi.Input[_builtins.str]] = None, + failed_duration: Optional[pulumi.Input[_builtins.float]] = None, + failed_pct: Optional[pulumi.Input[_builtins.float]] = None, + ignored_count: Optional[pulumi.Input[_builtins.float]] = None, + ignored_count_fmt: Optional[pulumi.Input[_builtins.str]] = None, + ignored_pct: Optional[pulumi.Input[_builtins.float]] = None, + succeed_count: Optional[pulumi.Input[_builtins.float]] = None, + succeed_count_fmt: Optional[pulumi.Input[_builtins.str]] = None, + succeed_duration: Optional[pulumi.Input[_builtins.float]] = None, + succeed_pct: Optional[pulumi.Input[_builtins.float]] = None): + if cached_count is not None: + pulumi.set(__self__, "cached_count", cached_count) + if cached_count_fmt is not None: + pulumi.set(__self__, "cached_count_fmt", cached_count_fmt) + if cached_duration is not None: + pulumi.set(__self__, "cached_duration", cached_duration) + if cached_pct is not None: + pulumi.set(__self__, "cached_pct", cached_pct) + if compute_time_fmt is not None: + pulumi.set(__self__, "compute_time_fmt", compute_time_fmt) + if failed_count is not None: + pulumi.set(__self__, "failed_count", failed_count) + if failed_count_fmt is not None: + pulumi.set(__self__, "failed_count_fmt", failed_count_fmt) + if failed_duration is not None: + pulumi.set(__self__, "failed_duration", failed_duration) + if failed_pct is not None: + pulumi.set(__self__, "failed_pct", failed_pct) + if ignored_count is not None: + pulumi.set(__self__, "ignored_count", ignored_count) + if ignored_count_fmt is not None: + pulumi.set(__self__, "ignored_count_fmt", ignored_count_fmt) + if ignored_pct is not None: + pulumi.set(__self__, "ignored_pct", ignored_pct) + if succeed_count is not None: + pulumi.set(__self__, "succeed_count", succeed_count) + if succeed_count_fmt is not None: + pulumi.set(__self__, "succeed_count_fmt", succeed_count_fmt) + if succeed_duration is not None: + pulumi.set(__self__, "succeed_duration", succeed_duration) + if succeed_pct is not None: + pulumi.set(__self__, "succeed_pct", succeed_pct) + + @_builtins.property + @pulumi.getter(name="cachedCount") + def cached_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached_count") + + @cached_count.setter + def cached_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached_count", value) + + @_builtins.property + @pulumi.getter(name="cachedCountFmt") + def cached_count_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "cached_count_fmt") + + @cached_count_fmt.setter + def cached_count_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "cached_count_fmt", value) + + @_builtins.property + @pulumi.getter(name="cachedDuration") + def cached_duration(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached_duration") + + @cached_duration.setter + def cached_duration(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached_duration", value) + + @_builtins.property + @pulumi.getter(name="cachedPct") + def cached_pct(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "cached_pct") + + @cached_pct.setter + def cached_pct(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "cached_pct", value) + + @_builtins.property + @pulumi.getter(name="computeTimeFmt") + def compute_time_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "compute_time_fmt") + + @compute_time_fmt.setter + def compute_time_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_time_fmt", value) + + @_builtins.property + @pulumi.getter(name="failedCount") + def failed_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed_count") + + @failed_count.setter + def failed_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed_count", value) + + @_builtins.property + @pulumi.getter(name="failedCountFmt") + def failed_count_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "failed_count_fmt") + + @failed_count_fmt.setter + def failed_count_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "failed_count_fmt", value) + + @_builtins.property + @pulumi.getter(name="failedDuration") + def failed_duration(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed_duration") + + @failed_duration.setter + def failed_duration(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed_duration", value) + + @_builtins.property + @pulumi.getter(name="failedPct") + def failed_pct(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "failed_pct") + + @failed_pct.setter + def failed_pct(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "failed_pct", value) + + @_builtins.property + @pulumi.getter(name="ignoredCount") + def ignored_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ignored_count") + + @ignored_count.setter + def ignored_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ignored_count", value) + + @_builtins.property + @pulumi.getter(name="ignoredCountFmt") + def ignored_count_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "ignored_count_fmt") + + @ignored_count_fmt.setter + def ignored_count_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "ignored_count_fmt", value) + + @_builtins.property + @pulumi.getter(name="ignoredPct") + def ignored_pct(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "ignored_pct") + + @ignored_pct.setter + def ignored_pct(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "ignored_pct", value) + + @_builtins.property + @pulumi.getter(name="succeedCount") + def succeed_count(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeed_count") + + @succeed_count.setter + def succeed_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeed_count", value) + + @_builtins.property + @pulumi.getter(name="succeedCountFmt") + def succeed_count_fmt(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "succeed_count_fmt") + + @succeed_count_fmt.setter + def succeed_count_fmt(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "succeed_count_fmt", value) + + @_builtins.property + @pulumi.getter(name="succeedDuration") + def succeed_duration(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeed_duration") + + @succeed_duration.setter + def succeed_duration(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeed_duration", value) + + @_builtins.property + @pulumi.getter(name="succeedPct") + def succeed_pct(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "succeed_pct") + + @succeed_pct.setter + def succeed_pct(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "succeed_pct", value) + + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/_utilities.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/_utilities.py new file mode 100644 index 00000000..e2f4cfd3 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/_utilities.py @@ -0,0 +1,360 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + + +import asyncio +import functools +import importlib.metadata +import importlib.util +import inspect +import json +import os +import sys +import typing +import warnings +import base64 + +import pulumi +import pulumi.runtime +from pulumi.runtime.sync_await import _sync_await +from pulumi.runtime.proto import resource_pb2 + +from semver import VersionInfo as SemverVersion +from parver import Version as PEP440Version + +C = typing.TypeVar("C", bound=typing.Callable) + + +def get_env(*args): + for v in args: + value = os.getenv(v) + if value is not None: + return value + return None + + +def get_env_bool(*args): + str = get_env(*args) + if str is not None: + # NOTE: these values are taken from https://golang.org/src/strconv/atob.go?s=351:391#L1, which is what + # Terraform uses internally when parsing boolean values. + if str in ["1", "t", "T", "true", "TRUE", "True"]: + return True + if str in ["0", "f", "F", "false", "FALSE", "False"]: + return False + return None + + +def get_env_int(*args): + str = get_env(*args) + if str is not None: + try: + return int(str) + except: + return None + return None + + +def get_env_float(*args): + str = get_env(*args) + if str is not None: + try: + return float(str) + except: + return None + return None + + +def _get_semver_version(): + # __name__ is set to the fully-qualified name of the current module, In our case, it will be + # ._utilities. is the module we want to query the version for. + root_package, *rest = __name__.split('.') + + # pkg_resources uses setuptools to inspect the set of installed packages. We use it here to ask + # for the currently installed version of the root package (i.e. us) and get its version. + + # Unfortunately, PEP440 and semver differ slightly in incompatible ways. The Pulumi engine expects + # to receive a valid semver string when receiving requests from the language host, so it's our + # responsibility as the library to convert our own PEP440 version into a valid semver string. + + pep440_version_string = importlib.metadata.version(root_package) + pep440_version = PEP440Version.parse(pep440_version_string) + (major, minor, patch) = pep440_version.release + prerelease = None + if pep440_version.pre_tag == 'a': + prerelease = f"alpha.{pep440_version.pre}" + elif pep440_version.pre_tag == 'b': + prerelease = f"beta.{pep440_version.pre}" + elif pep440_version.pre_tag == 'rc': + prerelease = f"rc.{pep440_version.pre}" + elif pep440_version.dev is not None: + # PEP440 has explicit support for dev builds, while semver encodes them as "prerelease" versions. To bridge + # between the two, we convert our dev build version into a prerelease tag. This matches what all of our other + # packages do when constructing their own semver string. + prerelease = f"dev.{pep440_version.dev}" + elif pep440_version.local is not None: + # PEP440 only allows a small set of prerelease tags, so when converting an arbitrary prerelease, + # PypiVersion in /pkg/codegen/python/utilities.go converts it to a local version. Therefore, we need to + # do the reverse conversion here and set the local version as the prerelease tag. + prerelease = pep440_version.local + + return SemverVersion(major=major, minor=minor, patch=patch, prerelease=prerelease) + + +# Determine the version once and cache the value, which measurably improves program performance. +_version = _get_semver_version() +_version_str = str(_version) + +def get_resource_opts_defaults() -> pulumi.ResourceOptions: + return pulumi.ResourceOptions( + version=get_version(), + plugin_download_url=get_plugin_download_url(), + ) + +def get_invoke_opts_defaults() -> pulumi.InvokeOptions: + return pulumi.InvokeOptions( + version=get_version(), + plugin_download_url=get_plugin_download_url(), + ) + +def get_resource_args_opts(resource_args_type, resource_options_type, *args, **kwargs): + """ + Return the resource args and options given the *args and **kwargs of a resource's + __init__ method. + """ + + resource_args, opts = None, None + + # If the first item is the resource args type, save it and remove it from the args list. + if args and isinstance(args[0], resource_args_type): + resource_args, args = args[0], args[1:] + + # Now look at the first item in the args list again. + # If the first item is the resource options class, save it. + if args and isinstance(args[0], resource_options_type): + opts = args[0] + + # If resource_args is None, see if "args" is in kwargs, and, if so, if it's typed as the + # the resource args type. + if resource_args is None: + a = kwargs.get("args") + if isinstance(a, resource_args_type): + resource_args = a + + # If opts is None, look it up in kwargs. + if opts is None: + opts = kwargs.get("opts") + + return resource_args, opts + + +# Temporary: just use pulumi._utils.lazy_import once everyone upgrades. +def lazy_import(fullname): + + import pulumi._utils as u + f = getattr(u, 'lazy_import', None) + if f is None: + f = _lazy_import_temp + + return f(fullname) + + +# Copied from pulumi._utils.lazy_import, see comments there. +def _lazy_import_temp(fullname): + m = sys.modules.get(fullname, None) + if m is not None: + return m + + spec = importlib.util.find_spec(fullname) + + m = sys.modules.get(fullname, None) + if m is not None: + return m + + loader = importlib.util.LazyLoader(spec.loader) + spec.loader = loader + module = importlib.util.module_from_spec(spec) + + m = sys.modules.get(fullname, None) + if m is not None: + return m + + sys.modules[fullname] = module + loader.exec_module(module) + return module + + +class Package(pulumi.runtime.ResourcePackage): + def __init__(self, pkg_info): + super().__init__() + self.pkg_info = pkg_info + + def version(self): + return _version + + def construct_provider(self, name: str, typ: str, urn: str) -> pulumi.ProviderResource: + if typ != self.pkg_info['token']: + raise Exception(f"unknown provider type {typ}") + Provider = getattr(lazy_import(self.pkg_info['fqn']), self.pkg_info['class']) + return Provider(name, pulumi.ResourceOptions(urn=urn)) + + +class Module(pulumi.runtime.ResourceModule): + def __init__(self, mod_info): + super().__init__() + self.mod_info = mod_info + + def version(self): + return _version + + def construct(self, name: str, typ: str, urn: str) -> pulumi.Resource: + class_name = self.mod_info['classes'].get(typ, None) + + if class_name is None: + raise Exception(f"unknown resource type {typ}") + + TheClass = getattr(lazy_import(self.mod_info['fqn']), class_name) + return TheClass(name, pulumi.ResourceOptions(urn=urn)) + + +def register(resource_modules, resource_packages): + resource_modules = json.loads(resource_modules) + resource_packages = json.loads(resource_packages) + + for pkg_info in resource_packages: + pulumi.runtime.register_resource_package(pkg_info['pkg'], Package(pkg_info)) + + for mod_info in resource_modules: + pulumi.runtime.register_resource_module( + mod_info['pkg'], + mod_info['mod'], + Module(mod_info)) + + +_F = typing.TypeVar('_F', bound=typing.Callable[..., typing.Any]) + + +def lift_output_func(func: typing.Any) -> typing.Callable[[_F], _F]: + """Decorator internally used on {fn}_output lifted function versions + to implement them automatically from the un-lifted function.""" + + func_sig = inspect.signature(func) + + def lifted_func(*args, opts=None, **kwargs): + bound_args = func_sig.bind(*args, **kwargs) + # Convert tuple to list, see pulumi/pulumi#8172 + args_list = list(bound_args.args) + return pulumi.Output.from_input({ + 'args': args_list, + 'kwargs': bound_args.kwargs + }).apply(lambda resolved_args: func(*resolved_args['args'], + opts=opts, + **resolved_args['kwargs'])) + + return (lambda _: lifted_func) + + +def call_plain( + tok: str, + props: pulumi.Inputs, + res: typing.Optional[pulumi.Resource] = None, + typ: typing.Optional[type] = None, +) -> typing.Any: + """ + Wraps pulumi.runtime.plain to force the output and return it plainly. + """ + + output = pulumi.runtime.call(tok, props, res, typ) + + # Ingoring deps silently. They are typically non-empty, r.f() calls include r as a dependency. + result, known, secret, _ = _sync_await(asyncio.create_task(_await_output(output))) + + problem = None + if not known: + problem = ' an unknown value' + elif secret: + problem = ' a secret value' + + if problem: + raise AssertionError( + f"Plain resource method '{tok}' incorrectly returned {problem}. " + + "This is an error in the provider, please report this to the provider developer." + ) + + return result + + +async def _await_output(o: pulumi.Output[typing.Any]) -> typing.Tuple[object, bool, bool, set]: + return ( + await o._future, + await o._is_known, + await o._is_secret, + await o._resources, + ) + + +# This is included to provide an upgrade path for users who are using a version +# of the Pulumi SDK (<3.121.0) that does not include the `deprecated` decorator. +def deprecated(message: str) -> typing.Callable[[C], C]: + """ + Decorator to indicate a function is deprecated. + + As well as inserting appropriate statements to indicate that the function is + deprecated, this decorator also tags the function with a special attribute + so that Pulumi code can detect that it is deprecated and react appropriately + in certain situations. + + message is the deprecation message that should be printed if the function is called. + """ + + def decorator(fn: C) -> C: + if not callable(fn): + raise TypeError("Expected fn to be callable") + + @functools.wraps(fn) + def deprecated_fn(*args, **kwargs): + warnings.warn(message) + pulumi.warn(f"{fn.__name__} is deprecated: {message}") + + return fn(*args, **kwargs) + + deprecated_fn.__dict__["_pulumi_deprecated_callable"] = fn + return typing.cast(C, deprecated_fn) + + return decorator + +def get_plugin_download_url(): + return None + +def get_version(): + return "0.25.2" + +_package_lock = asyncio.Lock() +_package_ref = ... +async def get_package(): + global _package_ref + if _package_ref is ...: + if pulumi.runtime.settings._sync_monitor_supports_parameterization(): + async with _package_lock: + if _package_ref is ...: + monitor = pulumi.runtime.settings.get_monitor() + parameterization = resource_pb2.Parameterization( + name="seqera", + version=get_version(), + value=base64.b64decode("eyJyZW1vdGUiOnsidXJsIjoicmVnaXN0cnkudGVycmFmb3JtLmlvL3NlcWVyYWxhYnMvc2VxZXJhIiwidmVyc2lvbiI6IjAuMjUuMiJ9fQ=="), + ) + registerPackageResponse = monitor.RegisterPackage( + resource_pb2.RegisterPackageRequest( + name="terraform-provider", + version="0.13.0", + download_url=get_plugin_download_url(), + parameterization=parameterization, + )) + _package_ref = registerPackageResponse.ref + # TODO: This check is only needed for parameterized providers, normal providers can return None for get_package when we start + # using package with them. + if _package_ref is None or _package_ref is ...: + raise Exception("The Pulumi CLI does not support parameterization. Please update the Pulumi CLI.") + return _package_ref + \ No newline at end of file diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/action.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/action.py new file mode 100644 index 00000000..b7f4b577 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/action.py @@ -0,0 +1,556 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ActionArgs', 'Action'] + +@pulumi.input_type +class ActionArgs: + def __init__(__self__, *, + launch: pulumi.Input['ActionLaunchArgs'], + source: pulumi.Input[_builtins.str], + workspace_id: pulumi.Input[_builtins.float], + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Action resource. + :param pulumi.Input['ActionLaunchArgs'] launch: Requires replacement if changed. + :param pulumi.Input[_builtins.str] source: must be one of ["github", "tower"]; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + """ + pulumi.set(__self__, "launch", launch) + pulumi.set(__self__, "source", source) + pulumi.set(__self__, "workspace_id", workspace_id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def launch(self) -> pulumi.Input['ActionLaunchArgs']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch") + + @launch.setter + def launch(self, value: pulumi.Input['ActionLaunchArgs']): + pulumi.set(self, "launch", value) + + @_builtins.property + @pulumi.getter + def source(self) -> pulumi.Input[_builtins.str]: + """ + must be one of ["github", "tower"]; Requires replacement if changed. + """ + return pulumi.get(self, "source") + + @source.setter + def source(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "source", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _ActionState: + def __init__(__self__, *, + action_id: Optional[pulumi.Input[_builtins.str]] = None, + config: Optional[pulumi.Input['ActionConfigArgs']] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + event: Optional[pulumi.Input['ActionEventArgs']] = None, + hook_id: Optional[pulumi.Input[_builtins.str]] = None, + hook_url: Optional[pulumi.Input[_builtins.str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLabelArgs']]]] = None, + last_seen: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch: Optional[pulumi.Input['ActionLaunchArgs']] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + source: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Action resources. + :param pulumi.Input[_builtins.str] action_id: Action string identifier + :param pulumi.Input[_builtins.str] hook_id: Identifier for the webhook associated with this action + :param pulumi.Input[_builtins.str] hook_url: URL endpoint for the webhook that triggers this action + :param pulumi.Input['ActionLaunchArgs'] launch: Requires replacement if changed. + :param pulumi.Input[_builtins.str] message: Status or informational message about the action + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] source: must be one of ["github", "tower"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["CREATING", "ACTIVE", "ERROR", "PAUSED"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + if action_id is not None: + pulumi.set(__self__, "action_id", action_id) + if config is not None: + pulumi.set(__self__, "config", config) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if event is not None: + pulumi.set(__self__, "event", event) + if hook_id is not None: + pulumi.set(__self__, "hook_id", hook_id) + if hook_url is not None: + pulumi.set(__self__, "hook_url", hook_url) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_seen is not None: + pulumi.set(__self__, "last_seen", last_seen) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch is not None: + pulumi.set(__self__, "launch", launch) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if source is not None: + pulumi.set(__self__, "source", source) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="actionId") + def action_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Action string identifier + """ + return pulumi.get(self, "action_id") + + @action_id.setter + def action_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "action_id", value) + + @_builtins.property + @pulumi.getter + def config(self) -> Optional[pulumi.Input['ActionConfigArgs']]: + return pulumi.get(self, "config") + + @config.setter + def config(self, value: Optional[pulumi.Input['ActionConfigArgs']]): + pulumi.set(self, "config", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def event(self) -> Optional[pulumi.Input['ActionEventArgs']]: + return pulumi.get(self, "event") + + @event.setter + def event(self, value: Optional[pulumi.Input['ActionEventArgs']]): + pulumi.set(self, "event", value) + + @_builtins.property + @pulumi.getter(name="hookId") + def hook_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Identifier for the webhook associated with this action + """ + return pulumi.get(self, "hook_id") + + @hook_id.setter + def hook_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "hook_id", value) + + @_builtins.property + @pulumi.getter(name="hookUrl") + def hook_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + URL endpoint for the webhook that triggers this action + """ + return pulumi.get(self, "hook_url") + + @hook_url.setter + def hook_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "hook_url", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ActionLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ActionLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="lastSeen") + def last_seen(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_seen") + + @last_seen.setter + def last_seen(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_seen", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter + def launch(self) -> Optional[pulumi.Input['ActionLaunchArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch") + + @launch.setter + def launch(self, value: Optional[pulumi.Input['ActionLaunchArgs']]): + pulumi.set(self, "launch", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Status or informational message about the action + """ + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def source(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["github", "tower"]; Requires replacement if changed. + """ + return pulumi.get(self, "source") + + @source.setter + def source(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "source", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["CREATING", "ACTIVE", "ERROR", "PAUSED"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/action:Action") +class Action(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + launch: Optional[pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + source: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Action resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']] launch: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] source: must be one of ["github", "tower"]; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ActionArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Action resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param ActionArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(ActionArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + launch: Optional[pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + source: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ActionArgs.__new__(ActionArgs) + + if launch is None and not opts.urn: + raise TypeError("Missing required property 'launch'") + __props__.__dict__["launch"] = launch + __props__.__dict__["name"] = name + if source is None and not opts.urn: + raise TypeError("Missing required property 'source'") + __props__.__dict__["source"] = source + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["action_id"] = None + __props__.__dict__["config"] = None + __props__.__dict__["date_created"] = None + __props__.__dict__["event"] = None + __props__.__dict__["hook_id"] = None + __props__.__dict__["hook_url"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["last_seen"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["message"] = None + __props__.__dict__["status"] = None + super(Action, __self__).__init__( + 'seqera:index/action:Action', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + action_id: Optional[pulumi.Input[_builtins.str]] = None, + config: Optional[pulumi.Input[Union['ActionConfigArgs', 'ActionConfigArgsDict']]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + event: Optional[pulumi.Input[Union['ActionEventArgs', 'ActionEventArgsDict']]] = None, + hook_id: Optional[pulumi.Input[_builtins.str]] = None, + hook_url: Optional[pulumi.Input[_builtins.str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ActionLabelArgs', 'ActionLabelArgsDict']]]]] = None, + last_seen: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch: Optional[pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + source: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Action': + """ + Get an existing Action resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] action_id: Action string identifier + :param pulumi.Input[_builtins.str] hook_id: Identifier for the webhook associated with this action + :param pulumi.Input[_builtins.str] hook_url: URL endpoint for the webhook that triggers this action + :param pulumi.Input[Union['ActionLaunchArgs', 'ActionLaunchArgsDict']] launch: Requires replacement if changed. + :param pulumi.Input[_builtins.str] message: Status or informational message about the action + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] source: must be one of ["github", "tower"]; Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["CREATING", "ACTIVE", "ERROR", "PAUSED"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ActionState.__new__(_ActionState) + + __props__.__dict__["action_id"] = action_id + __props__.__dict__["config"] = config + __props__.__dict__["date_created"] = date_created + __props__.__dict__["event"] = event + __props__.__dict__["hook_id"] = hook_id + __props__.__dict__["hook_url"] = hook_url + __props__.__dict__["labels"] = labels + __props__.__dict__["last_seen"] = last_seen + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["launch"] = launch + __props__.__dict__["message"] = message + __props__.__dict__["name"] = name + __props__.__dict__["source"] = source + __props__.__dict__["status"] = status + __props__.__dict__["workspace_id"] = workspace_id + return Action(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="actionId") + def action_id(self) -> pulumi.Output[_builtins.str]: + """ + Action string identifier + """ + return pulumi.get(self, "action_id") + + @_builtins.property + @pulumi.getter + def config(self) -> pulumi.Output['outputs.ActionConfig']: + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def event(self) -> pulumi.Output['outputs.ActionEvent']: + return pulumi.get(self, "event") + + @_builtins.property + @pulumi.getter(name="hookId") + def hook_id(self) -> pulumi.Output[_builtins.str]: + """ + Identifier for the webhook associated with this action + """ + return pulumi.get(self, "hook_id") + + @_builtins.property + @pulumi.getter(name="hookUrl") + def hook_url(self) -> pulumi.Output[_builtins.str]: + """ + URL endpoint for the webhook that triggers this action + """ + return pulumi.get(self, "hook_url") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.ActionLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastSeen") + def last_seen(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_seen") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def launch(self) -> pulumi.Output['outputs.ActionLaunch']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch") + + @_builtins.property + @pulumi.getter + def message(self) -> pulumi.Output[_builtins.str]: + """ + Status or informational message about the action + """ + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def source(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["github", "tower"]; Requires replacement if changed. + """ + return pulumi.get(self, "source") + + @_builtins.property + @pulumi.getter + def status(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["CREATING", "ACTIVE", "ERROR", "PAUSED"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/compute_env.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/compute_env.py new file mode 100644 index 00000000..ec06971e --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/compute_env.py @@ -0,0 +1,276 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ComputeEnvArgs', 'ComputeEnv'] + +@pulumi.input_type +class ComputeEnvArgs: + def __init__(__self__, *, + compute_env: pulumi.Input['ComputeEnvComputeEnvArgs'], + workspace_id: pulumi.Input[_builtins.float], + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None): + """ + The set of arguments for constructing a ComputeEnv resource. + :param pulumi.Input['ComputeEnvComputeEnvArgs'] compute_env: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env", compute_env) + pulumi.set(__self__, "workspace_id", workspace_id) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> pulumi.Input['ComputeEnvComputeEnvArgs']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: pulumi.Input['ComputeEnvComputeEnvArgs']): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + +@pulumi.input_type +class _ComputeEnvState: + def __init__(__self__, *, + compute_env: Optional[pulumi.Input['ComputeEnvComputeEnvArgs']] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering ComputeEnv resources. + :param pulumi.Input['ComputeEnvComputeEnvArgs'] compute_env: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Compute environment string identifier + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional[pulumi.Input['ComputeEnvComputeEnvArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: Optional[pulumi.Input['ComputeEnvComputeEnvArgs']]): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Compute environment string identifier + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/computeEnv:ComputeEnv") +class ComputeEnv(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + compute_env: Optional[pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a ComputeEnv resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']] compute_env: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ComputeEnvArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a ComputeEnv resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param ComputeEnvArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(ComputeEnvArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + compute_env: Optional[pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ComputeEnvArgs.__new__(ComputeEnvArgs) + + if compute_env is None and not opts.urn: + raise TypeError("Missing required property 'compute_env'") + __props__.__dict__["compute_env"] = compute_env + __props__.__dict__["label_ids"] = label_ids + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["compute_env_id"] = None + super(ComputeEnv, __self__).__init__( + 'seqera:index/computeEnv:ComputeEnv', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + compute_env: Optional[pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'ComputeEnv': + """ + Get an existing ComputeEnv resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ComputeEnvComputeEnvArgs', 'ComputeEnvComputeEnvArgsDict']] compute_env: Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Compute environment string identifier + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ComputeEnvState.__new__(_ComputeEnvState) + + __props__.__dict__["compute_env"] = compute_env + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["workspace_id"] = workspace_id + return ComputeEnv(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> pulumi.Output['outputs.ComputeEnvComputeEnv']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Output[_builtins.str]: + """ + Compute environment string identifier + """ + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.float]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/config/__init__.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/config/__init__.py new file mode 100644 index 00000000..43ec6e26 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/config/__init__.py @@ -0,0 +1,9 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import sys +from .vars import _ExportableConfig + +sys.modules[__name__].__class__ = _ExportableConfig diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/config/vars.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/config/vars.py new file mode 100644 index 00000000..0f78b6a4 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/config/vars.py @@ -0,0 +1,33 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from .. import _utilities + +import types + +__config__ = pulumi.Config('seqera') + + +class _ExportableConfig(types.ModuleType): + @_builtins.property + def bearer_auth(self) -> Optional[str]: + return __config__.get('bearerAuth') + + @_builtins.property + def server_url(self) -> Optional[str]: + """ + Server URL (defaults to https://api.cloud.seqera.io) + """ + return __config__.get('serverUrl') + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/credential.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/credential.py new file mode 100644 index 00000000..2fee60a7 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/credential.py @@ -0,0 +1,610 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['CredentialArgs', 'Credential'] + +@pulumi.input_type +class CredentialArgs: + def __init__(__self__, *, + keys: pulumi.Input['CredentialKeysArgs'], + provider_type: pulumi.Input[_builtins.str], + workspace_id: pulumi.Input[_builtins.float], + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Credential resource. + :param pulumi.Input[_builtins.str] provider_type: Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + :param pulumi.Input[_builtins.bool] checked: If set credentials deletion will be blocked by running jobs that depend on them + :param pulumi.Input[_builtins.str] credentials_id: Unique identifier for the credential (max 22 characters) + :param pulumi.Input[_builtins.str] description: Optional description explaining the purpose of the credential + :param pulumi.Input[_builtins.str] name: Display name for the credential (max 100 characters) + """ + pulumi.set(__self__, "keys", keys) + pulumi.set(__self__, "provider_type", provider_type) + pulumi.set(__self__, "workspace_id", workspace_id) + if base_url is not None: + pulumi.set(__self__, "base_url", base_url) + if category is not None: + pulumi.set(__self__, "category", category) + if checked is not None: + pulumi.set(__self__, "checked", checked) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def keys(self) -> pulumi.Input['CredentialKeysArgs']: + return pulumi.get(self, "keys") + + @keys.setter + def keys(self, value: pulumi.Input['CredentialKeysArgs']): + pulumi.set(self, "keys", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> pulumi.Input[_builtins.str]: + """ + Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="baseUrl") + def base_url(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "base_url") + + @base_url.setter + def base_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "base_url", value) + + @_builtins.property + @pulumi.getter + def category(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "category") + + @category.setter + def category(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "category", value) + + @_builtins.property + @pulumi.getter + def checked(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + If set credentials deletion will be blocked by running jobs that depend on them + """ + return pulumi.get(self, "checked") + + @checked.setter + def checked(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "checked", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the credential (max 22 characters) + """ + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Optional description explaining the purpose of the credential + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Display name for the credential (max 100 characters) + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _CredentialState: + def __init__(__self__, *, + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + keys: Optional[pulumi.Input['CredentialKeysArgs']] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Credential resources. + :param pulumi.Input[_builtins.bool] checked: If set credentials deletion will be blocked by running jobs that depend on them + :param pulumi.Input[_builtins.str] credentials_id: Unique identifier for the credential (max 22 characters) + :param pulumi.Input[_builtins.str] date_created: Timestamp when the credential was created + :param pulumi.Input[_builtins.bool] deleted: Flag indicating if the credential has been soft-deleted + :param pulumi.Input[_builtins.str] description: Optional description explaining the purpose of the credential + :param pulumi.Input[_builtins.str] last_used: Timestamp when the credential was last used + :param pulumi.Input[_builtins.str] name: Display name for the credential (max 100 characters) + :param pulumi.Input[_builtins.str] provider_type: Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if base_url is not None: + pulumi.set(__self__, "base_url", base_url) + if category is not None: + pulumi.set(__self__, "category", category) + if checked is not None: + pulumi.set(__self__, "checked", checked) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if keys is not None: + pulumi.set(__self__, "keys", keys) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="baseUrl") + def base_url(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "base_url") + + @base_url.setter + def base_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "base_url", value) + + @_builtins.property + @pulumi.getter + def category(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "category") + + @category.setter + def category(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "category", value) + + @_builtins.property + @pulumi.getter + def checked(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + If set credentials deletion will be blocked by running jobs that depend on them + """ + return pulumi.get(self, "checked") + + @checked.setter + def checked(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "checked", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the credential (max 22 characters) + """ + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the credential was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Flag indicating if the credential has been soft-deleted + """ + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Optional description explaining the purpose of the credential + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def keys(self) -> Optional[pulumi.Input['CredentialKeysArgs']]: + return pulumi.get(self, "keys") + + @keys.setter + def keys(self, value: Optional[pulumi.Input['CredentialKeysArgs']]): + pulumi.set(self, "keys", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the credential was last used + """ + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Display name for the credential (max 100 characters) + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/credential:Credential") +class Credential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + keys: Optional[pulumi.Input[Union['CredentialKeysArgs', 'CredentialKeysArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Credential resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] checked: If set credentials deletion will be blocked by running jobs that depend on them + :param pulumi.Input[_builtins.str] credentials_id: Unique identifier for the credential (max 22 characters) + :param pulumi.Input[_builtins.str] description: Optional description explaining the purpose of the credential + :param pulumi.Input[_builtins.str] name: Display name for the credential (max 100 characters) + :param pulumi.Input[_builtins.str] provider_type: Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: CredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Credential resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param CredentialArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(CredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + keys: Optional[pulumi.Input[Union['CredentialKeysArgs', 'CredentialKeysArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = CredentialArgs.__new__(CredentialArgs) + + __props__.__dict__["base_url"] = base_url + __props__.__dict__["category"] = category + __props__.__dict__["checked"] = checked + __props__.__dict__["credentials_id"] = credentials_id + __props__.__dict__["description"] = description + if keys is None and not opts.urn: + raise TypeError("Missing required property 'keys'") + __props__.__dict__["keys"] = keys + __props__.__dict__["name"] = name + if provider_type is None and not opts.urn: + raise TypeError("Missing required property 'provider_type'") + __props__.__dict__["provider_type"] = provider_type + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["date_created"] = None + __props__.__dict__["deleted"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["last_used"] = None + super(Credential, __self__).__init__( + 'seqera:index/credential:Credential', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + base_url: Optional[pulumi.Input[_builtins.str]] = None, + category: Optional[pulumi.Input[_builtins.str]] = None, + checked: Optional[pulumi.Input[_builtins.bool]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + keys: Optional[pulumi.Input[Union['CredentialKeysArgs', 'CredentialKeysArgsDict']]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Credential': + """ + Get an existing Credential resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] checked: If set credentials deletion will be blocked by running jobs that depend on them + :param pulumi.Input[_builtins.str] credentials_id: Unique identifier for the credential (max 22 characters) + :param pulumi.Input[_builtins.str] date_created: Timestamp when the credential was created + :param pulumi.Input[_builtins.bool] deleted: Flag indicating if the credential has been soft-deleted + :param pulumi.Input[_builtins.str] description: Optional description explaining the purpose of the credential + :param pulumi.Input[_builtins.str] last_used: Timestamp when the credential was last used + :param pulumi.Input[_builtins.str] name: Display name for the credential (max 100 characters) + :param pulumi.Input[_builtins.str] provider_type: Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _CredentialState.__new__(_CredentialState) + + __props__.__dict__["base_url"] = base_url + __props__.__dict__["category"] = category + __props__.__dict__["checked"] = checked + __props__.__dict__["credentials_id"] = credentials_id + __props__.__dict__["date_created"] = date_created + __props__.__dict__["deleted"] = deleted + __props__.__dict__["description"] = description + __props__.__dict__["keys"] = keys + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["last_used"] = last_used + __props__.__dict__["name"] = name + __props__.__dict__["provider_type"] = provider_type + __props__.__dict__["workspace_id"] = workspace_id + return Credential(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="baseUrl") + def base_url(self) -> pulumi.Output[Optional[_builtins.str]]: + return pulumi.get(self, "base_url") + + @_builtins.property + @pulumi.getter + def category(self) -> pulumi.Output[Optional[_builtins.str]]: + return pulumi.get(self, "category") + + @_builtins.property + @pulumi.getter + def checked(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + If set credentials deletion will be blocked by running jobs that depend on them + """ + return pulumi.get(self, "checked") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> pulumi.Output[_builtins.str]: + """ + Unique identifier for the credential (max 22 characters) + """ + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + """ + Timestamp when the credential was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> pulumi.Output[_builtins.bool]: + """ + Flag indicating if the credential has been soft-deleted + """ + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Optional description explaining the purpose of the credential + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def keys(self) -> pulumi.Output['outputs.CredentialKeys']: + return pulumi.get(self, "keys") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> pulumi.Output[_builtins.str]: + """ + Timestamp when the credential was last used + """ + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Display name for the credential (max 100 characters) + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> pulumi.Output[_builtins.str]: + """ + Cloud or service provider type (e.g., aws, azure, gcp). must be one of ["aws", "azure", "azure_entra", "google", + "github", "gitlab", "bitbucket", "ssh", "k8s", "container-reg", "tw-agent", "codecommit", "gitea", "azurerepos", + "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/data_link.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/data_link.py new file mode 100644 index 00000000..31f5a9ff --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/data_link.py @@ -0,0 +1,601 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['DataLinkArgs', 'DataLink'] + +@pulumi.input_type +class DataLinkArgs: + def __init__(__self__, *, + credentials_id: pulumi.Input[_builtins.str], + description: pulumi.Input[_builtins.str], + provider_type: pulumi.Input[_builtins.str], + public_accessible: pulumi.Input[_builtins.bool], + resource_ref: pulumi.Input[_builtins.str], + type: pulumi.Input[_builtins.str], + workspace_id: pulumi.Input[_builtins.float], + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a DataLink resource. + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] public_accessible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] resource_ref: Requires replacement if changed. + :param pulumi.Input[_builtins.str] type: must be "bucket"; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "provider_type", provider_type) + pulumi.set(__self__, "public_accessible", public_accessible) + pulumi.set(__self__, "resource_ref", resource_ref) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "workspace_id", workspace_id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> pulumi.Input[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> pulumi.Input[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "public_accessible") + + @public_accessible.setter + def public_accessible(self, value: pulumi.Input[_builtins.bool]): + pulumi.set(self, "public_accessible", value) + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource_ref") + + @resource_ref.setter + def resource_ref(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "resource_ref", value) + + @_builtins.property + @pulumi.getter + def type(self) -> pulumi.Input[_builtins.str]: + """ + must be "bucket"; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _DataLinkState: + def __init__(__self__, *, + credentials: Optional[pulumi.Input[Sequence[pulumi.Input['DataLinkCredentialArgs']]]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + data_link_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + hidden: Optional[pulumi.Input[_builtins.bool]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering DataLink resources. + :param pulumi.Input[Sequence[pulumi.Input['DataLinkCredentialArgs']]] credentials: Array of credentials required to access the data link + :param pulumi.Input[_builtins.str] data_link_id: Unique identifier for the data link + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] public_accessible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Geographic region where the data link is hosted + :param pulumi.Input[_builtins.str] resource_ref: Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["VALID", "INVALID"] + :param pulumi.Input[_builtins.str] type: must be "bucket"; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if credentials is not None: + pulumi.set(__self__, "credentials", credentials) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if data_link_id is not None: + pulumi.set(__self__, "data_link_id", data_link_id) + if description is not None: + pulumi.set(__self__, "description", description) + if hidden is not None: + pulumi.set(__self__, "hidden", hidden) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + if public_accessible is not None: + pulumi.set(__self__, "public_accessible", public_accessible) + if region is not None: + pulumi.set(__self__, "region", region) + if resource_ref is not None: + pulumi.set(__self__, "resource_ref", resource_ref) + if status is not None: + pulumi.set(__self__, "status", status) + if type is not None: + pulumi.set(__self__, "type", type) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataLinkCredentialArgs']]]]: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @credentials.setter + def credentials(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataLinkCredentialArgs']]]]): + pulumi.set(self, "credentials", value) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "credentials_id") + + @credentials_id.setter + def credentials_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "credentials_id", value) + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @data_link_id.setter + def data_link_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "data_link_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def hidden(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "hidden") + + @hidden.setter + def hidden(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "hidden", value) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "message", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + """ + return pulumi.get(self, "provider_type") + + @provider_type.setter + def provider_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "provider_type", value) + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "public_accessible") + + @public_accessible.setter + def public_accessible(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "public_accessible", value) + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "region", value) + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource_ref") + + @resource_ref.setter + def resource_ref(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "resource_ref", value) + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["VALID", "INVALID"] + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "status", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be "bucket"; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/dataLink:DataLink") +class DataLink(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a DataLink resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] public_accessible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] resource_ref: Requires replacement if changed. + :param pulumi.Input[_builtins.str] type: must be "bucket"; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DataLinkArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a DataLink resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param DataLinkArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(DataLinkArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = DataLinkArgs.__new__(DataLinkArgs) + + if credentials_id is None and not opts.urn: + raise TypeError("Missing required property 'credentials_id'") + __props__.__dict__["credentials_id"] = credentials_id + if description is None and not opts.urn: + raise TypeError("Missing required property 'description'") + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + if provider_type is None and not opts.urn: + raise TypeError("Missing required property 'provider_type'") + __props__.__dict__["provider_type"] = provider_type + if public_accessible is None and not opts.urn: + raise TypeError("Missing required property 'public_accessible'") + __props__.__dict__["public_accessible"] = public_accessible + if resource_ref is None and not opts.urn: + raise TypeError("Missing required property 'resource_ref'") + __props__.__dict__["resource_ref"] = resource_ref + if type is None and not opts.urn: + raise TypeError("Missing required property 'type'") + __props__.__dict__["type"] = type + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["credentials"] = None + __props__.__dict__["data_link_id"] = None + __props__.__dict__["hidden"] = None + __props__.__dict__["message"] = None + __props__.__dict__["region"] = None + __props__.__dict__["status"] = None + super(DataLink, __self__).__init__( + 'seqera:index/dataLink:DataLink', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credentials: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DataLinkCredentialArgs', 'DataLinkCredentialArgsDict']]]]] = None, + credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + data_link_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + hidden: Optional[pulumi.Input[_builtins.bool]] = None, + message: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + provider_type: Optional[pulumi.Input[_builtins.str]] = None, + public_accessible: Optional[pulumi.Input[_builtins.bool]] = None, + region: Optional[pulumi.Input[_builtins.str]] = None, + resource_ref: Optional[pulumi.Input[_builtins.str]] = None, + status: Optional[pulumi.Input[_builtins.str]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'DataLink': + """ + Get an existing DataLink resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[Union['DataLinkCredentialArgs', 'DataLinkCredentialArgsDict']]]] credentials: Array of credentials required to access the data link + :param pulumi.Input[_builtins.str] data_link_id: Unique identifier for the data link + :param pulumi.Input[_builtins.str] provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + :param pulumi.Input[_builtins.bool] public_accessible: Requires replacement if changed. + :param pulumi.Input[_builtins.str] region: Geographic region where the data link is hosted + :param pulumi.Input[_builtins.str] resource_ref: Requires replacement if changed. + :param pulumi.Input[_builtins.str] status: must be one of ["VALID", "INVALID"] + :param pulumi.Input[_builtins.str] type: must be "bucket"; Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DataLinkState.__new__(_DataLinkState) + + __props__.__dict__["credentials"] = credentials + __props__.__dict__["credentials_id"] = credentials_id + __props__.__dict__["data_link_id"] = data_link_id + __props__.__dict__["description"] = description + __props__.__dict__["hidden"] = hidden + __props__.__dict__["message"] = message + __props__.__dict__["name"] = name + __props__.__dict__["provider_type"] = provider_type + __props__.__dict__["public_accessible"] = public_accessible + __props__.__dict__["region"] = region + __props__.__dict__["resource_ref"] = resource_ref + __props__.__dict__["status"] = status + __props__.__dict__["type"] = type + __props__.__dict__["workspace_id"] = workspace_id + return DataLink(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter + def credentials(self) -> pulumi.Output[Sequence['outputs.DataLinkCredential']]: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> pulumi.Output[_builtins.str]: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def hidden(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "hidden") + + @_builtins.property + @pulumi.getter + def message(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"]; Requires replacement if changed. + """ + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> pulumi.Output[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "public_accessible") + + @_builtins.property + @pulumi.getter + def region(self) -> pulumi.Output[_builtins.str]: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource_ref") + + @_builtins.property + @pulumi.getter + def status(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["VALID", "INVALID"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def type(self) -> pulumi.Output[_builtins.str]: + """ + must be "bucket"; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/datasets.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/datasets.py new file mode 100644 index 00000000..94e03e62 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/datasets.py @@ -0,0 +1,341 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['DatasetsArgs', 'Datasets'] + +@pulumi.input_type +class DatasetsArgs: + def __init__(__self__, *, + workspace_id: pulumi.Input[_builtins.float], + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Datasets resource. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + """ + pulumi.set(__self__, "workspace_id", workspace_id) + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _DatasetsState: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + media_type: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Datasets resources. + :param pulumi.Input[_builtins.bool] deleted: Read-only flag indicating if the dataset has been deleted + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] media_type: MIME type or media type of the dataset content (max 80 characters) + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if media_type is not None: + pulumi.set(__self__, "media_type", media_type) + if name is not None: + pulumi.set(__self__, "name", name) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Read-only flag indicating if the dataset has been deleted + """ + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="mediaType") + def media_type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + MIME type or media type of the dataset content (max 80 characters) + """ + return pulumi.get(self, "media_type") + + @media_type.setter + def media_type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "media_type", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/datasets:Datasets") +class Datasets(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Datasets resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DatasetsArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Datasets resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param DatasetsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(DatasetsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = DatasetsArgs.__new__(DatasetsArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["date_created"] = None + __props__.__dict__["deleted"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["media_type"] = None + super(Datasets, __self__).__init__( + 'seqera:index/datasets:Datasets', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + media_type: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Datasets': + """ + Get an existing Datasets resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] deleted: Read-only flag indicating if the dataset has been deleted + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.str] media_type: MIME type or media type of the dataset content (max 80 characters) + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DatasetsState.__new__(_DatasetsState) + + __props__.__dict__["date_created"] = date_created + __props__.__dict__["deleted"] = deleted + __props__.__dict__["description"] = description + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["media_type"] = media_type + __props__.__dict__["name"] = name + __props__.__dict__["workspace_id"] = workspace_id + return Datasets(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> pulumi.Output[_builtins.bool]: + """ + Read-only flag indicating if the dataset has been deleted + """ + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="mediaType") + def media_type(self) -> pulumi.Output[_builtins.str]: + """ + MIME type or media type of the dataset content (max 80 characters) + """ + return pulumi.get(self, "media_type") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_action.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_action.py new file mode 100644 index 00000000..87125ed0 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_action.py @@ -0,0 +1,256 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetActionResult', + 'AwaitableGetActionResult', + 'get_action', + 'get_action_output', +] + +@pulumi.output_type +class GetActionResult: + """ + A collection of values returned by getAction. + """ + def __init__(__self__, action_id=None, attributes=None, config=None, date_created=None, event=None, hook_id=None, hook_url=None, id=None, labels=None, last_seen=None, last_updated=None, launch=None, message=None, name=None, source=None, status=None, workspace_id=None): + if action_id and not isinstance(action_id, str): + raise TypeError("Expected argument 'action_id' to be a str") + pulumi.set(__self__, "action_id", action_id) + if attributes and not isinstance(attributes, list): + raise TypeError("Expected argument 'attributes' to be a list") + pulumi.set(__self__, "attributes", attributes) + if config and not isinstance(config, dict): + raise TypeError("Expected argument 'config' to be a dict") + pulumi.set(__self__, "config", config) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if event and not isinstance(event, dict): + raise TypeError("Expected argument 'event' to be a dict") + pulumi.set(__self__, "event", event) + if hook_id and not isinstance(hook_id, str): + raise TypeError("Expected argument 'hook_id' to be a str") + pulumi.set(__self__, "hook_id", hook_id) + if hook_url and not isinstance(hook_url, str): + raise TypeError("Expected argument 'hook_url' to be a str") + pulumi.set(__self__, "hook_url", hook_url) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if last_seen and not isinstance(last_seen, str): + raise TypeError("Expected argument 'last_seen' to be a str") + pulumi.set(__self__, "last_seen", last_seen) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if launch and not isinstance(launch, dict): + raise TypeError("Expected argument 'launch' to be a dict") + pulumi.set(__self__, "launch", launch) + if message and not isinstance(message, str): + raise TypeError("Expected argument 'message' to be a str") + pulumi.set(__self__, "message", message) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if source and not isinstance(source, str): + raise TypeError("Expected argument 'source' to be a str") + pulumi.set(__self__, "source", source) + if status and not isinstance(status, str): + raise TypeError("Expected argument 'status' to be a str") + pulumi.set(__self__, "status", status) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="actionId") + def action_id(self) -> _builtins.str: + return pulumi.get(self, "action_id") + + @_builtins.property + @pulumi.getter + def attributes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "attributes") + + @_builtins.property + @pulumi.getter + def config(self) -> 'outputs.GetActionConfigResult': + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def event(self) -> 'outputs.GetActionEventResult': + return pulumi.get(self, "event") + + @_builtins.property + @pulumi.getter(name="hookId") + def hook_id(self) -> _builtins.str: + return pulumi.get(self, "hook_id") + + @_builtins.property + @pulumi.getter(name="hookUrl") + def hook_url(self) -> _builtins.str: + return pulumi.get(self, "hook_url") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetActionLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastSeen") + def last_seen(self) -> _builtins.str: + return pulumi.get(self, "last_seen") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def launch(self) -> 'outputs.GetActionLaunchResult': + return pulumi.get(self, "launch") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def source(self) -> _builtins.str: + return pulumi.get(self, "source") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetActionResult(GetActionResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetActionResult( + action_id=self.action_id, + attributes=self.attributes, + config=self.config, + date_created=self.date_created, + event=self.event, + hook_id=self.hook_id, + hook_url=self.hook_url, + id=self.id, + labels=self.labels, + last_seen=self.last_seen, + last_updated=self.last_updated, + launch=self.launch, + message=self.message, + name=self.name, + source=self.source, + status=self.status, + workspace_id=self.workspace_id) + + +def get_action(action_id: Optional[_builtins.str] = None, + attributes: Optional[Sequence[_builtins.str]] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetActionResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['actionId'] = action_id + __args__['attributes'] = attributes + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getAction:getAction', __args__, opts=opts, typ=GetActionResult, package_ref=_utilities.get_package()).value + + return AwaitableGetActionResult( + action_id=pulumi.get(__ret__, 'action_id'), + attributes=pulumi.get(__ret__, 'attributes'), + config=pulumi.get(__ret__, 'config'), + date_created=pulumi.get(__ret__, 'date_created'), + event=pulumi.get(__ret__, 'event'), + hook_id=pulumi.get(__ret__, 'hook_id'), + hook_url=pulumi.get(__ret__, 'hook_url'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + last_seen=pulumi.get(__ret__, 'last_seen'), + last_updated=pulumi.get(__ret__, 'last_updated'), + launch=pulumi.get(__ret__, 'launch'), + message=pulumi.get(__ret__, 'message'), + name=pulumi.get(__ret__, 'name'), + source=pulumi.get(__ret__, 'source'), + status=pulumi.get(__ret__, 'status'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_action_output(action_id: Optional[pulumi.Input[_builtins.str]] = None, + attributes: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetActionResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['actionId'] = action_id + __args__['attributes'] = attributes + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getAction:getAction', __args__, opts=opts, typ=GetActionResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetActionResult( + action_id=pulumi.get(__response__, 'action_id'), + attributes=pulumi.get(__response__, 'attributes'), + config=pulumi.get(__response__, 'config'), + date_created=pulumi.get(__response__, 'date_created'), + event=pulumi.get(__response__, 'event'), + hook_id=pulumi.get(__response__, 'hook_id'), + hook_url=pulumi.get(__response__, 'hook_url'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + last_seen=pulumi.get(__response__, 'last_seen'), + last_updated=pulumi.get(__response__, 'last_updated'), + launch=pulumi.get(__response__, 'launch'), + message=pulumi.get(__response__, 'message'), + name=pulumi.get(__response__, 'name'), + source=pulumi.get(__response__, 'source'), + status=pulumi.get(__response__, 'status'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_compute_env.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_compute_env.py new file mode 100644 index 00000000..b55e68cb --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_compute_env.py @@ -0,0 +1,127 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetComputeEnvResult', + 'AwaitableGetComputeEnvResult', + 'get_compute_env', + 'get_compute_env_output', +] + +@pulumi.output_type +class GetComputeEnvResult: + """ + A collection of values returned by getComputeEnv. + """ + def __init__(__self__, attributes=None, compute_env=None, compute_env_id=None, id=None, workspace_id=None): + if attributes and not isinstance(attributes, list): + raise TypeError("Expected argument 'attributes' to be a list") + pulumi.set(__self__, "attributes", attributes) + if compute_env and not isinstance(compute_env, dict): + raise TypeError("Expected argument 'compute_env' to be a dict") + pulumi.set(__self__, "compute_env", compute_env) + if compute_env_id and not isinstance(compute_env_id, str): + raise TypeError("Expected argument 'compute_env_id' to be a str") + pulumi.set(__self__, "compute_env_id", compute_env_id) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def attributes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "attributes") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> 'outputs.GetComputeEnvComputeEnvResult': + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetComputeEnvResult(GetComputeEnvResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetComputeEnvResult( + attributes=self.attributes, + compute_env=self.compute_env, + compute_env_id=self.compute_env_id, + id=self.id, + workspace_id=self.workspace_id) + + +def get_compute_env(attributes: Optional[Sequence[_builtins.str]] = None, + compute_env_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetComputeEnvResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['computeEnvId'] = compute_env_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getComputeEnv:getComputeEnv', __args__, opts=opts, typ=GetComputeEnvResult, package_ref=_utilities.get_package()).value + + return AwaitableGetComputeEnvResult( + attributes=pulumi.get(__ret__, 'attributes'), + compute_env=pulumi.get(__ret__, 'compute_env'), + compute_env_id=pulumi.get(__ret__, 'compute_env_id'), + id=pulumi.get(__ret__, 'id'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_compute_env_output(attributes: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetComputeEnvResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['computeEnvId'] = compute_env_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getComputeEnv:getComputeEnv', __args__, opts=opts, typ=GetComputeEnvResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetComputeEnvResult( + attributes=pulumi.get(__response__, 'attributes'), + compute_env=pulumi.get(__response__, 'compute_env'), + compute_env_id=pulumi.get(__response__, 'compute_env_id'), + id=pulumi.get(__response__, 'id'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_credential.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_credential.py new file mode 100644 index 00000000..2c79ce65 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_credential.py @@ -0,0 +1,211 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetCredentialResult', + 'AwaitableGetCredentialResult', + 'get_credential', + 'get_credential_output', +] + +@pulumi.output_type +class GetCredentialResult: + """ + A collection of values returned by getCredential. + """ + def __init__(__self__, base_url=None, category=None, credentials_id=None, date_created=None, deleted=None, description=None, id=None, keys=None, last_updated=None, last_used=None, name=None, provider_type=None, workspace_id=None): + if base_url and not isinstance(base_url, str): + raise TypeError("Expected argument 'base_url' to be a str") + pulumi.set(__self__, "base_url", base_url) + if category and not isinstance(category, str): + raise TypeError("Expected argument 'category' to be a str") + pulumi.set(__self__, "category", category) + if credentials_id and not isinstance(credentials_id, str): + raise TypeError("Expected argument 'credentials_id' to be a str") + pulumi.set(__self__, "credentials_id", credentials_id) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if deleted and not isinstance(deleted, bool): + raise TypeError("Expected argument 'deleted' to be a bool") + pulumi.set(__self__, "deleted", deleted) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if keys and not isinstance(keys, dict): + raise TypeError("Expected argument 'keys' to be a dict") + pulumi.set(__self__, "keys", keys) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if last_used and not isinstance(last_used, str): + raise TypeError("Expected argument 'last_used' to be a str") + pulumi.set(__self__, "last_used", last_used) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if provider_type and not isinstance(provider_type, str): + raise TypeError("Expected argument 'provider_type' to be a str") + pulumi.set(__self__, "provider_type", provider_type) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="baseUrl") + def base_url(self) -> _builtins.str: + return pulumi.get(self, "base_url") + + @_builtins.property + @pulumi.getter + def category(self) -> _builtins.str: + return pulumi.get(self, "category") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def keys(self) -> 'outputs.GetCredentialKeysResult': + return pulumi.get(self, "keys") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetCredentialResult(GetCredentialResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetCredentialResult( + base_url=self.base_url, + category=self.category, + credentials_id=self.credentials_id, + date_created=self.date_created, + deleted=self.deleted, + description=self.description, + id=self.id, + keys=self.keys, + last_updated=self.last_updated, + last_used=self.last_used, + name=self.name, + provider_type=self.provider_type, + workspace_id=self.workspace_id) + + +def get_credential(credentials_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetCredentialResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['credentialsId'] = credentials_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getCredential:getCredential', __args__, opts=opts, typ=GetCredentialResult, package_ref=_utilities.get_package()).value + + return AwaitableGetCredentialResult( + base_url=pulumi.get(__ret__, 'base_url'), + category=pulumi.get(__ret__, 'category'), + credentials_id=pulumi.get(__ret__, 'credentials_id'), + date_created=pulumi.get(__ret__, 'date_created'), + deleted=pulumi.get(__ret__, 'deleted'), + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + keys=pulumi.get(__ret__, 'keys'), + last_updated=pulumi.get(__ret__, 'last_updated'), + last_used=pulumi.get(__ret__, 'last_used'), + name=pulumi.get(__ret__, 'name'), + provider_type=pulumi.get(__ret__, 'provider_type'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_credential_output(credentials_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetCredentialResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['credentialsId'] = credentials_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getCredential:getCredential', __args__, opts=opts, typ=GetCredentialResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetCredentialResult( + base_url=pulumi.get(__response__, 'base_url'), + category=pulumi.get(__response__, 'category'), + credentials_id=pulumi.get(__response__, 'credentials_id'), + date_created=pulumi.get(__response__, 'date_created'), + deleted=pulumi.get(__response__, 'deleted'), + description=pulumi.get(__response__, 'description'), + id=pulumi.get(__response__, 'id'), + keys=pulumi.get(__response__, 'keys'), + last_updated=pulumi.get(__response__, 'last_updated'), + last_used=pulumi.get(__response__, 'last_used'), + name=pulumi.get(__response__, 'name'), + provider_type=pulumi.get(__response__, 'provider_type'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_data_link.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_data_link.py new file mode 100644 index 00000000..c180a771 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_data_link.py @@ -0,0 +1,237 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetDataLinkResult', + 'AwaitableGetDataLinkResult', + 'get_data_link', + 'get_data_link_output', +] + +@pulumi.output_type +class GetDataLinkResult: + """ + A collection of values returned by getDataLink. + """ + def __init__(__self__, credentials=None, credentials_id=None, data_link_id=None, description=None, hidden=None, id=None, message=None, name=None, provider_type=None, public_accessible=None, region=None, resource_ref=None, status=None, type=None, workspace_id=None): + if credentials and not isinstance(credentials, list): + raise TypeError("Expected argument 'credentials' to be a list") + pulumi.set(__self__, "credentials", credentials) + if credentials_id and not isinstance(credentials_id, str): + raise TypeError("Expected argument 'credentials_id' to be a str") + pulumi.set(__self__, "credentials_id", credentials_id) + if data_link_id and not isinstance(data_link_id, str): + raise TypeError("Expected argument 'data_link_id' to be a str") + pulumi.set(__self__, "data_link_id", data_link_id) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if hidden and not isinstance(hidden, bool): + raise TypeError("Expected argument 'hidden' to be a bool") + pulumi.set(__self__, "hidden", hidden) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if message and not isinstance(message, str): + raise TypeError("Expected argument 'message' to be a str") + pulumi.set(__self__, "message", message) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if provider_type and not isinstance(provider_type, str): + raise TypeError("Expected argument 'provider_type' to be a str") + pulumi.set(__self__, "provider_type", provider_type) + if public_accessible and not isinstance(public_accessible, bool): + raise TypeError("Expected argument 'public_accessible' to be a bool") + pulumi.set(__self__, "public_accessible", public_accessible) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if resource_ref and not isinstance(resource_ref, str): + raise TypeError("Expected argument 'resource_ref' to be a str") + pulumi.set(__self__, "resource_ref", resource_ref) + if status and not isinstance(status, str): + raise TypeError("Expected argument 'status' to be a str") + pulumi.set(__self__, "status", status) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Sequence['outputs.GetDataLinkCredentialResult']: + return pulumi.get(self, "credentials") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> _builtins.str: + return pulumi.get(self, "data_link_id") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def hidden(self) -> _builtins.bool: + return pulumi.get(self, "hidden") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> _builtins.bool: + return pulumi.get(self, "public_accessible") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> _builtins.str: + return pulumi.get(self, "resource_ref") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetDataLinkResult(GetDataLinkResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetDataLinkResult( + credentials=self.credentials, + credentials_id=self.credentials_id, + data_link_id=self.data_link_id, + description=self.description, + hidden=self.hidden, + id=self.id, + message=self.message, + name=self.name, + provider_type=self.provider_type, + public_accessible=self.public_accessible, + region=self.region, + resource_ref=self.resource_ref, + status=self.status, + type=self.type, + workspace_id=self.workspace_id) + + +def get_data_link(credentials_id: Optional[_builtins.str] = None, + data_link_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDataLinkResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['credentialsId'] = credentials_id + __args__['dataLinkId'] = data_link_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getDataLink:getDataLink', __args__, opts=opts, typ=GetDataLinkResult, package_ref=_utilities.get_package()).value + + return AwaitableGetDataLinkResult( + credentials=pulumi.get(__ret__, 'credentials'), + credentials_id=pulumi.get(__ret__, 'credentials_id'), + data_link_id=pulumi.get(__ret__, 'data_link_id'), + description=pulumi.get(__ret__, 'description'), + hidden=pulumi.get(__ret__, 'hidden'), + id=pulumi.get(__ret__, 'id'), + message=pulumi.get(__ret__, 'message'), + name=pulumi.get(__ret__, 'name'), + provider_type=pulumi.get(__ret__, 'provider_type'), + public_accessible=pulumi.get(__ret__, 'public_accessible'), + region=pulumi.get(__ret__, 'region'), + resource_ref=pulumi.get(__ret__, 'resource_ref'), + status=pulumi.get(__ret__, 'status'), + type=pulumi.get(__ret__, 'type'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_data_link_output(credentials_id: Optional[pulumi.Input[Optional[_builtins.str]]] = None, + data_link_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDataLinkResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['credentialsId'] = credentials_id + __args__['dataLinkId'] = data_link_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getDataLink:getDataLink', __args__, opts=opts, typ=GetDataLinkResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetDataLinkResult( + credentials=pulumi.get(__response__, 'credentials'), + credentials_id=pulumi.get(__response__, 'credentials_id'), + data_link_id=pulumi.get(__response__, 'data_link_id'), + description=pulumi.get(__response__, 'description'), + hidden=pulumi.get(__response__, 'hidden'), + id=pulumi.get(__response__, 'id'), + message=pulumi.get(__response__, 'message'), + name=pulumi.get(__response__, 'name'), + provider_type=pulumi.get(__response__, 'provider_type'), + public_accessible=pulumi.get(__response__, 'public_accessible'), + region=pulumi.get(__response__, 'region'), + resource_ref=pulumi.get(__response__, 'resource_ref'), + status=pulumi.get(__response__, 'status'), + type=pulumi.get(__response__, 'type'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_dataset.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_dataset.py new file mode 100644 index 00000000..a77634c8 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_dataset.py @@ -0,0 +1,112 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetDatasetResult', + 'AwaitableGetDatasetResult', + 'get_dataset', + 'get_dataset_output', +] + +@pulumi.output_type +class GetDatasetResult: + """ + A collection of values returned by getDataset. + """ + def __init__(__self__, dataset=None, dataset_id=None, id=None, workspace_id=None): + if dataset and not isinstance(dataset, dict): + raise TypeError("Expected argument 'dataset' to be a dict") + pulumi.set(__self__, "dataset", dataset) + if dataset_id and not isinstance(dataset_id, str): + raise TypeError("Expected argument 'dataset_id' to be a str") + pulumi.set(__self__, "dataset_id", dataset_id) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def dataset(self) -> 'outputs.GetDatasetDatasetResult': + return pulumi.get(self, "dataset") + + @_builtins.property + @pulumi.getter(name="datasetId") + def dataset_id(self) -> _builtins.str: + return pulumi.get(self, "dataset_id") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetDatasetResult(GetDatasetResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetDatasetResult( + dataset=self.dataset, + dataset_id=self.dataset_id, + id=self.id, + workspace_id=self.workspace_id) + + +def get_dataset(dataset_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatasetResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['datasetId'] = dataset_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getDataset:getDataset', __args__, opts=opts, typ=GetDatasetResult, package_ref=_utilities.get_package()).value + + return AwaitableGetDatasetResult( + dataset=pulumi.get(__ret__, 'dataset'), + dataset_id=pulumi.get(__ret__, 'dataset_id'), + id=pulumi.get(__ret__, 'id'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_dataset_output(dataset_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDatasetResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['datasetId'] = dataset_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getDataset:getDataset', __args__, opts=opts, typ=GetDatasetResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetDatasetResult( + dataset=pulumi.get(__response__, 'dataset'), + dataset_id=pulumi.get(__response__, 'dataset_id'), + id=pulumi.get(__response__, 'id'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_labels.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_labels.py new file mode 100644 index 00000000..6c86d322 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_labels.py @@ -0,0 +1,183 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetLabelsResult', + 'AwaitableGetLabelsResult', + 'get_labels', + 'get_labels_output', +] + +@pulumi.output_type +class GetLabelsResult: + """ + A collection of values returned by getLabels. + """ + def __init__(__self__, id=None, is_default=None, labels=None, max=None, offset=None, search=None, total_size=None, type=None, workspace_id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if is_default and not isinstance(is_default, bool): + raise TypeError("Expected argument 'is_default' to be a bool") + pulumi.set(__self__, "is_default", is_default) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if max and not isinstance(max, float): + raise TypeError("Expected argument 'max' to be a float") + pulumi.set(__self__, "max", max) + if offset and not isinstance(offset, float): + raise TypeError("Expected argument 'offset' to be a float") + pulumi.set(__self__, "offset", offset) + if search and not isinstance(search, str): + raise TypeError("Expected argument 'search' to be a str") + pulumi.set(__self__, "search", search) + if total_size and not isinstance(total_size, float): + raise TypeError("Expected argument 'total_size' to be a float") + pulumi.set(__self__, "total_size", total_size) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetLabelsLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def max(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max") + + @_builtins.property + @pulumi.getter + def offset(self) -> Optional[_builtins.float]: + return pulumi.get(self, "offset") + + @_builtins.property + @pulumi.getter + def search(self) -> Optional[_builtins.str]: + return pulumi.get(self, "search") + + @_builtins.property + @pulumi.getter(name="totalSize") + def total_size(self) -> _builtins.float: + return pulumi.get(self, "total_size") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetLabelsResult(GetLabelsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetLabelsResult( + id=self.id, + is_default=self.is_default, + labels=self.labels, + max=self.max, + offset=self.offset, + search=self.search, + total_size=self.total_size, + type=self.type, + workspace_id=self.workspace_id) + + +def get_labels(is_default: Optional[_builtins.bool] = None, + max: Optional[_builtins.float] = None, + offset: Optional[_builtins.float] = None, + search: Optional[_builtins.str] = None, + type: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLabelsResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['isDefault'] = is_default + __args__['max'] = max + __args__['offset'] = offset + __args__['search'] = search + __args__['type'] = type + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getLabels:getLabels', __args__, opts=opts, typ=GetLabelsResult, package_ref=_utilities.get_package()).value + + return AwaitableGetLabelsResult( + id=pulumi.get(__ret__, 'id'), + is_default=pulumi.get(__ret__, 'is_default'), + labels=pulumi.get(__ret__, 'labels'), + max=pulumi.get(__ret__, 'max'), + offset=pulumi.get(__ret__, 'offset'), + search=pulumi.get(__ret__, 'search'), + total_size=pulumi.get(__ret__, 'total_size'), + type=pulumi.get(__ret__, 'type'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_labels_output(is_default: Optional[pulumi.Input[Optional[_builtins.bool]]] = None, + max: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + offset: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + search: Optional[pulumi.Input[Optional[_builtins.str]]] = None, + type: Optional[pulumi.Input[Optional[_builtins.str]]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetLabelsResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['isDefault'] = is_default + __args__['max'] = max + __args__['offset'] = offset + __args__['search'] = search + __args__['type'] = type + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getLabels:getLabels', __args__, opts=opts, typ=GetLabelsResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetLabelsResult( + id=pulumi.get(__response__, 'id'), + is_default=pulumi.get(__response__, 'is_default'), + labels=pulumi.get(__response__, 'labels'), + max=pulumi.get(__response__, 'max'), + offset=pulumi.get(__response__, 'offset'), + search=pulumi.get(__response__, 'search'), + total_size=pulumi.get(__response__, 'total_size'), + type=pulumi.get(__response__, 'type'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_orgs.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_orgs.py new file mode 100644 index 00000000..2da64c18 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_orgs.py @@ -0,0 +1,207 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetOrgsResult', + 'AwaitableGetOrgsResult', + 'get_orgs', + 'get_orgs_output', +] + +@pulumi.output_type +class GetOrgsResult: + """ + A collection of values returned by getOrgs. + """ + def __init__(__self__, description=None, full_name=None, id=None, location=None, logo_id=None, logo_url=None, member_id=None, member_role=None, name=None, org_id=None, paying=None, type=None, website=None): + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if full_name and not isinstance(full_name, str): + raise TypeError("Expected argument 'full_name' to be a str") + pulumi.set(__self__, "full_name", full_name) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if location and not isinstance(location, str): + raise TypeError("Expected argument 'location' to be a str") + pulumi.set(__self__, "location", location) + if logo_id and not isinstance(logo_id, str): + raise TypeError("Expected argument 'logo_id' to be a str") + pulumi.set(__self__, "logo_id", logo_id) + if logo_url and not isinstance(logo_url, str): + raise TypeError("Expected argument 'logo_url' to be a str") + pulumi.set(__self__, "logo_url", logo_url) + if member_id and not isinstance(member_id, float): + raise TypeError("Expected argument 'member_id' to be a float") + pulumi.set(__self__, "member_id", member_id) + if member_role and not isinstance(member_role, str): + raise TypeError("Expected argument 'member_role' to be a str") + pulumi.set(__self__, "member_role", member_role) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if paying and not isinstance(paying, bool): + raise TypeError("Expected argument 'paying' to be a bool") + pulumi.set(__self__, "paying", paying) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + if website and not isinstance(website, str): + raise TypeError("Expected argument 'website' to be a str") + pulumi.set(__self__, "website", website) + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> _builtins.str: + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="logoId") + def logo_id(self) -> _builtins.str: + return pulumi.get(self, "logo_id") + + @_builtins.property + @pulumi.getter(name="logoUrl") + def logo_url(self) -> _builtins.str: + return pulumi.get(self, "logo_url") + + @_builtins.property + @pulumi.getter(name="memberId") + def member_id(self) -> _builtins.float: + return pulumi.get(self, "member_id") + + @_builtins.property + @pulumi.getter(name="memberRole") + def member_role(self) -> _builtins.str: + return pulumi.get(self, "member_role") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def paying(self) -> _builtins.bool: + return pulumi.get(self, "paying") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter + def website(self) -> _builtins.str: + return pulumi.get(self, "website") + + +class AwaitableGetOrgsResult(GetOrgsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetOrgsResult( + description=self.description, + full_name=self.full_name, + id=self.id, + location=self.location, + logo_id=self.logo_id, + logo_url=self.logo_url, + member_id=self.member_id, + member_role=self.member_role, + name=self.name, + org_id=self.org_id, + paying=self.paying, + type=self.type, + website=self.website) + + +def get_orgs(org_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetOrgsResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getOrgs:getOrgs', __args__, opts=opts, typ=GetOrgsResult, package_ref=_utilities.get_package()).value + + return AwaitableGetOrgsResult( + description=pulumi.get(__ret__, 'description'), + full_name=pulumi.get(__ret__, 'full_name'), + id=pulumi.get(__ret__, 'id'), + location=pulumi.get(__ret__, 'location'), + logo_id=pulumi.get(__ret__, 'logo_id'), + logo_url=pulumi.get(__ret__, 'logo_url'), + member_id=pulumi.get(__ret__, 'member_id'), + member_role=pulumi.get(__ret__, 'member_role'), + name=pulumi.get(__ret__, 'name'), + org_id=pulumi.get(__ret__, 'org_id'), + paying=pulumi.get(__ret__, 'paying'), + type=pulumi.get(__ret__, 'type'), + website=pulumi.get(__ret__, 'website')) +def get_orgs_output(org_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetOrgsResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getOrgs:getOrgs', __args__, opts=opts, typ=GetOrgsResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetOrgsResult( + description=pulumi.get(__response__, 'description'), + full_name=pulumi.get(__response__, 'full_name'), + id=pulumi.get(__response__, 'id'), + location=pulumi.get(__response__, 'location'), + logo_id=pulumi.get(__response__, 'logo_id'), + logo_url=pulumi.get(__response__, 'logo_url'), + member_id=pulumi.get(__response__, 'member_id'), + member_role=pulumi.get(__response__, 'member_role'), + name=pulumi.get(__response__, 'name'), + org_id=pulumi.get(__response__, 'org_id'), + paying=pulumi.get(__response__, 'paying'), + type=pulumi.get(__response__, 'type'), + website=pulumi.get(__response__, 'website'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_pipeline.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_pipeline.py new file mode 100644 index 00000000..f9c3329e --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_pipeline.py @@ -0,0 +1,340 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetPipelineResult', + 'AwaitableGetPipelineResult', + 'get_pipeline', + 'get_pipeline_output', +] + +@pulumi.output_type +class GetPipelineResult: + """ + A collection of values returned by getPipeline. + """ + def __init__(__self__, attributes=None, compute_env=None, deleted=None, description=None, icon=None, id=None, labels=None, last_updated=None, name=None, optimization_id=None, optimization_status=None, optimization_targets=None, org_id=None, org_name=None, pipeline_id=None, repository=None, source_workspace_id=None, user_first_name=None, user_id=None, user_last_name=None, user_name=None, visibility=None, workspace_id=None, workspace_name=None): + if attributes and not isinstance(attributes, list): + raise TypeError("Expected argument 'attributes' to be a list") + pulumi.set(__self__, "attributes", attributes) + if compute_env and not isinstance(compute_env, dict): + raise TypeError("Expected argument 'compute_env' to be a dict") + pulumi.set(__self__, "compute_env", compute_env) + if deleted and not isinstance(deleted, bool): + raise TypeError("Expected argument 'deleted' to be a bool") + pulumi.set(__self__, "deleted", deleted) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if icon and not isinstance(icon, str): + raise TypeError("Expected argument 'icon' to be a str") + pulumi.set(__self__, "icon", icon) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if optimization_id and not isinstance(optimization_id, str): + raise TypeError("Expected argument 'optimization_id' to be a str") + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_status and not isinstance(optimization_status, str): + raise TypeError("Expected argument 'optimization_status' to be a str") + pulumi.set(__self__, "optimization_status", optimization_status) + if optimization_targets and not isinstance(optimization_targets, str): + raise TypeError("Expected argument 'optimization_targets' to be a str") + pulumi.set(__self__, "optimization_targets", optimization_targets) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if org_name and not isinstance(org_name, str): + raise TypeError("Expected argument 'org_name' to be a str") + pulumi.set(__self__, "org_name", org_name) + if pipeline_id and not isinstance(pipeline_id, float): + raise TypeError("Expected argument 'pipeline_id' to be a float") + pulumi.set(__self__, "pipeline_id", pipeline_id) + if repository and not isinstance(repository, str): + raise TypeError("Expected argument 'repository' to be a str") + pulumi.set(__self__, "repository", repository) + if source_workspace_id and not isinstance(source_workspace_id, float): + raise TypeError("Expected argument 'source_workspace_id' to be a float") + pulumi.set(__self__, "source_workspace_id", source_workspace_id) + if user_first_name and not isinstance(user_first_name, str): + raise TypeError("Expected argument 'user_first_name' to be a str") + pulumi.set(__self__, "user_first_name", user_first_name) + if user_id and not isinstance(user_id, float): + raise TypeError("Expected argument 'user_id' to be a float") + pulumi.set(__self__, "user_id", user_id) + if user_last_name and not isinstance(user_last_name, str): + raise TypeError("Expected argument 'user_last_name' to be a str") + pulumi.set(__self__, "user_last_name", user_last_name) + if user_name and not isinstance(user_name, str): + raise TypeError("Expected argument 'user_name' to be a str") + pulumi.set(__self__, "user_name", user_name) + if visibility and not isinstance(visibility, str): + raise TypeError("Expected argument 'visibility' to be a str") + pulumi.set(__self__, "visibility", visibility) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + if workspace_name and not isinstance(workspace_name, str): + raise TypeError("Expected argument 'workspace_name' to be a str") + pulumi.set(__self__, "workspace_name", workspace_name) + + @_builtins.property + @pulumi.getter + def attributes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "attributes") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> 'outputs.GetPipelineComputeEnvResult': + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def icon(self) -> _builtins.str: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetPipelineLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> _builtins.str: + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationStatus") + def optimization_status(self) -> _builtins.str: + return pulumi.get(self, "optimization_status") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> _builtins.str: + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> _builtins.str: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter(name="pipelineId") + def pipeline_id(self) -> _builtins.float: + return pulumi.get(self, "pipeline_id") + + @_builtins.property + @pulumi.getter + def repository(self) -> _builtins.str: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter(name="sourceWorkspaceId") + def source_workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "source_workspace_id") + + @_builtins.property + @pulumi.getter(name="userFirstName") + def user_first_name(self) -> _builtins.str: + return pulumi.get(self, "user_first_name") + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> _builtins.float: + return pulumi.get(self, "user_id") + + @_builtins.property + @pulumi.getter(name="userLastName") + def user_last_name(self) -> _builtins.str: + return pulumi.get(self, "user_last_name") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter + def visibility(self) -> _builtins.str: + return pulumi.get(self, "visibility") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> _builtins.str: + return pulumi.get(self, "workspace_name") + + +class AwaitableGetPipelineResult(GetPipelineResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPipelineResult( + attributes=self.attributes, + compute_env=self.compute_env, + deleted=self.deleted, + description=self.description, + icon=self.icon, + id=self.id, + labels=self.labels, + last_updated=self.last_updated, + name=self.name, + optimization_id=self.optimization_id, + optimization_status=self.optimization_status, + optimization_targets=self.optimization_targets, + org_id=self.org_id, + org_name=self.org_name, + pipeline_id=self.pipeline_id, + repository=self.repository, + source_workspace_id=self.source_workspace_id, + user_first_name=self.user_first_name, + user_id=self.user_id, + user_last_name=self.user_last_name, + user_name=self.user_name, + visibility=self.visibility, + workspace_id=self.workspace_id, + workspace_name=self.workspace_name) + + +def get_pipeline(attributes: Optional[Sequence[_builtins.str]] = None, + pipeline_id: Optional[_builtins.float] = None, + source_workspace_id: Optional[_builtins.float] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPipelineResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['pipelineId'] = pipeline_id + __args__['sourceWorkspaceId'] = source_workspace_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getPipeline:getPipeline', __args__, opts=opts, typ=GetPipelineResult, package_ref=_utilities.get_package()).value + + return AwaitableGetPipelineResult( + attributes=pulumi.get(__ret__, 'attributes'), + compute_env=pulumi.get(__ret__, 'compute_env'), + deleted=pulumi.get(__ret__, 'deleted'), + description=pulumi.get(__ret__, 'description'), + icon=pulumi.get(__ret__, 'icon'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + last_updated=pulumi.get(__ret__, 'last_updated'), + name=pulumi.get(__ret__, 'name'), + optimization_id=pulumi.get(__ret__, 'optimization_id'), + optimization_status=pulumi.get(__ret__, 'optimization_status'), + optimization_targets=pulumi.get(__ret__, 'optimization_targets'), + org_id=pulumi.get(__ret__, 'org_id'), + org_name=pulumi.get(__ret__, 'org_name'), + pipeline_id=pulumi.get(__ret__, 'pipeline_id'), + repository=pulumi.get(__ret__, 'repository'), + source_workspace_id=pulumi.get(__ret__, 'source_workspace_id'), + user_first_name=pulumi.get(__ret__, 'user_first_name'), + user_id=pulumi.get(__ret__, 'user_id'), + user_last_name=pulumi.get(__ret__, 'user_last_name'), + user_name=pulumi.get(__ret__, 'user_name'), + visibility=pulumi.get(__ret__, 'visibility'), + workspace_id=pulumi.get(__ret__, 'workspace_id'), + workspace_name=pulumi.get(__ret__, 'workspace_name')) +def get_pipeline_output(attributes: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None, + pipeline_id: Optional[pulumi.Input[_builtins.float]] = None, + source_workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPipelineResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['pipelineId'] = pipeline_id + __args__['sourceWorkspaceId'] = source_workspace_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getPipeline:getPipeline', __args__, opts=opts, typ=GetPipelineResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetPipelineResult( + attributes=pulumi.get(__response__, 'attributes'), + compute_env=pulumi.get(__response__, 'compute_env'), + deleted=pulumi.get(__response__, 'deleted'), + description=pulumi.get(__response__, 'description'), + icon=pulumi.get(__response__, 'icon'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + last_updated=pulumi.get(__response__, 'last_updated'), + name=pulumi.get(__response__, 'name'), + optimization_id=pulumi.get(__response__, 'optimization_id'), + optimization_status=pulumi.get(__response__, 'optimization_status'), + optimization_targets=pulumi.get(__response__, 'optimization_targets'), + org_id=pulumi.get(__response__, 'org_id'), + org_name=pulumi.get(__response__, 'org_name'), + pipeline_id=pulumi.get(__response__, 'pipeline_id'), + repository=pulumi.get(__response__, 'repository'), + source_workspace_id=pulumi.get(__response__, 'source_workspace_id'), + user_first_name=pulumi.get(__response__, 'user_first_name'), + user_id=pulumi.get(__response__, 'user_id'), + user_last_name=pulumi.get(__response__, 'user_last_name'), + user_name=pulumi.get(__response__, 'user_name'), + visibility=pulumi.get(__response__, 'visibility'), + workspace_id=pulumi.get(__response__, 'workspace_id'), + workspace_name=pulumi.get(__response__, 'workspace_name'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_pipeline_secret.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_pipeline_secret.py new file mode 100644 index 00000000..fa0aea82 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_pipeline_secret.py @@ -0,0 +1,141 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetPipelineSecretResult', + 'AwaitableGetPipelineSecretResult', + 'get_pipeline_secret', + 'get_pipeline_secret_output', +] + +@pulumi.output_type +class GetPipelineSecretResult: + """ + A collection of values returned by getPipelineSecret. + """ + def __init__(__self__, date_created=None, id=None, last_updated=None, last_used=None, name=None, secret_id=None, workspace_id=None): + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if id and not isinstance(id, float): + raise TypeError("Expected argument 'id' to be a float") + pulumi.set(__self__, "id", id) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if last_used and not isinstance(last_used, str): + raise TypeError("Expected argument 'last_used' to be a str") + pulumi.set(__self__, "last_used", last_used) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if secret_id and not isinstance(secret_id, float): + raise TypeError("Expected argument 'secret_id' to be a float") + pulumi.set(__self__, "secret_id", secret_id) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="secretId") + def secret_id(self) -> _builtins.float: + return pulumi.get(self, "secret_id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetPipelineSecretResult(GetPipelineSecretResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPipelineSecretResult( + date_created=self.date_created, + id=self.id, + last_updated=self.last_updated, + last_used=self.last_used, + name=self.name, + secret_id=self.secret_id, + workspace_id=self.workspace_id) + + +def get_pipeline_secret(secret_id: Optional[_builtins.float] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPipelineSecretResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['secretId'] = secret_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getPipelineSecret:getPipelineSecret', __args__, opts=opts, typ=GetPipelineSecretResult, package_ref=_utilities.get_package()).value + + return AwaitableGetPipelineSecretResult( + date_created=pulumi.get(__ret__, 'date_created'), + id=pulumi.get(__ret__, 'id'), + last_updated=pulumi.get(__ret__, 'last_updated'), + last_used=pulumi.get(__ret__, 'last_used'), + name=pulumi.get(__ret__, 'name'), + secret_id=pulumi.get(__ret__, 'secret_id'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_pipeline_secret_output(secret_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPipelineSecretResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['secretId'] = secret_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getPipelineSecret:getPipelineSecret', __args__, opts=opts, typ=GetPipelineSecretResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetPipelineSecretResult( + date_created=pulumi.get(__response__, 'date_created'), + id=pulumi.get(__response__, 'id'), + last_updated=pulumi.get(__response__, 'last_updated'), + last_used=pulumi.get(__response__, 'last_used'), + name=pulumi.get(__response__, 'name'), + secret_id=pulumi.get(__response__, 'secret_id'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_studios.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_studios.py new file mode 100644 index 00000000..c762d8c2 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_studios.py @@ -0,0 +1,328 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetStudiosResult', + 'AwaitableGetStudiosResult', + 'get_studios', + 'get_studios_output', +] + +@pulumi.output_type +class GetStudiosResult: + """ + A collection of values returned by getStudios. + """ + def __init__(__self__, active_connections=None, base_image=None, compute_env=None, configuration=None, custom_image=None, date_created=None, description=None, effective_lifespan_hours=None, id=None, is_private=None, labels=None, last_started=None, last_updated=None, mounted_data_links=None, name=None, parent_checkpoint=None, progresses=None, session_id=None, status_info=None, studio_url=None, template=None, user=None, wave_build_url=None, workspace_id=None): + if active_connections and not isinstance(active_connections, list): + raise TypeError("Expected argument 'active_connections' to be a list") + pulumi.set(__self__, "active_connections", active_connections) + if base_image and not isinstance(base_image, str): + raise TypeError("Expected argument 'base_image' to be a str") + pulumi.set(__self__, "base_image", base_image) + if compute_env and not isinstance(compute_env, dict): + raise TypeError("Expected argument 'compute_env' to be a dict") + pulumi.set(__self__, "compute_env", compute_env) + if configuration and not isinstance(configuration, dict): + raise TypeError("Expected argument 'configuration' to be a dict") + pulumi.set(__self__, "configuration", configuration) + if custom_image and not isinstance(custom_image, bool): + raise TypeError("Expected argument 'custom_image' to be a bool") + pulumi.set(__self__, "custom_image", custom_image) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if effective_lifespan_hours and not isinstance(effective_lifespan_hours, float): + raise TypeError("Expected argument 'effective_lifespan_hours' to be a float") + pulumi.set(__self__, "effective_lifespan_hours", effective_lifespan_hours) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if is_private and not isinstance(is_private, bool): + raise TypeError("Expected argument 'is_private' to be a bool") + pulumi.set(__self__, "is_private", is_private) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if last_started and not isinstance(last_started, str): + raise TypeError("Expected argument 'last_started' to be a str") + pulumi.set(__self__, "last_started", last_started) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if mounted_data_links and not isinstance(mounted_data_links, list): + raise TypeError("Expected argument 'mounted_data_links' to be a list") + pulumi.set(__self__, "mounted_data_links", mounted_data_links) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if parent_checkpoint and not isinstance(parent_checkpoint, dict): + raise TypeError("Expected argument 'parent_checkpoint' to be a dict") + pulumi.set(__self__, "parent_checkpoint", parent_checkpoint) + if progresses and not isinstance(progresses, list): + raise TypeError("Expected argument 'progresses' to be a list") + pulumi.set(__self__, "progresses", progresses) + if session_id and not isinstance(session_id, str): + raise TypeError("Expected argument 'session_id' to be a str") + pulumi.set(__self__, "session_id", session_id) + if status_info and not isinstance(status_info, dict): + raise TypeError("Expected argument 'status_info' to be a dict") + pulumi.set(__self__, "status_info", status_info) + if studio_url and not isinstance(studio_url, str): + raise TypeError("Expected argument 'studio_url' to be a str") + pulumi.set(__self__, "studio_url", studio_url) + if template and not isinstance(template, dict): + raise TypeError("Expected argument 'template' to be a dict") + pulumi.set(__self__, "template", template) + if user and not isinstance(user, dict): + raise TypeError("Expected argument 'user' to be a dict") + pulumi.set(__self__, "user", user) + if wave_build_url and not isinstance(wave_build_url, str): + raise TypeError("Expected argument 'wave_build_url' to be a str") + pulumi.set(__self__, "wave_build_url", wave_build_url) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="activeConnections") + def active_connections(self) -> Sequence['outputs.GetStudiosActiveConnectionResult']: + return pulumi.get(self, "active_connections") + + @_builtins.property + @pulumi.getter(name="baseImage") + def base_image(self) -> _builtins.str: + return pulumi.get(self, "base_image") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> 'outputs.GetStudiosComputeEnvResult': + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter + def configuration(self) -> 'outputs.GetStudiosConfigurationResult': + return pulumi.get(self, "configuration") + + @_builtins.property + @pulumi.getter(name="customImage") + def custom_image(self) -> _builtins.bool: + return pulumi.get(self, "custom_image") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="effectiveLifespanHours") + def effective_lifespan_hours(self) -> _builtins.float: + return pulumi.get(self, "effective_lifespan_hours") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isPrivate") + def is_private(self) -> _builtins.bool: + return pulumi.get(self, "is_private") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetStudiosLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastStarted") + def last_started(self) -> _builtins.str: + return pulumi.get(self, "last_started") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="mountedDataLinks") + def mounted_data_links(self) -> Sequence['outputs.GetStudiosMountedDataLinkResult']: + return pulumi.get(self, "mounted_data_links") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="parentCheckpoint") + def parent_checkpoint(self) -> 'outputs.GetStudiosParentCheckpointResult': + return pulumi.get(self, "parent_checkpoint") + + @_builtins.property + @pulumi.getter + def progresses(self) -> Sequence['outputs.GetStudiosProgressResult']: + return pulumi.get(self, "progresses") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> _builtins.str: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="statusInfo") + def status_info(self) -> 'outputs.GetStudiosStatusInfoResult': + return pulumi.get(self, "status_info") + + @_builtins.property + @pulumi.getter(name="studioUrl") + def studio_url(self) -> _builtins.str: + return pulumi.get(self, "studio_url") + + @_builtins.property + @pulumi.getter + def template(self) -> 'outputs.GetStudiosTemplateResult': + return pulumi.get(self, "template") + + @_builtins.property + @pulumi.getter + def user(self) -> 'outputs.GetStudiosUserResult': + return pulumi.get(self, "user") + + @_builtins.property + @pulumi.getter(name="waveBuildUrl") + def wave_build_url(self) -> _builtins.str: + return pulumi.get(self, "wave_build_url") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + +class AwaitableGetStudiosResult(GetStudiosResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetStudiosResult( + active_connections=self.active_connections, + base_image=self.base_image, + compute_env=self.compute_env, + configuration=self.configuration, + custom_image=self.custom_image, + date_created=self.date_created, + description=self.description, + effective_lifespan_hours=self.effective_lifespan_hours, + id=self.id, + is_private=self.is_private, + labels=self.labels, + last_started=self.last_started, + last_updated=self.last_updated, + mounted_data_links=self.mounted_data_links, + name=self.name, + parent_checkpoint=self.parent_checkpoint, + progresses=self.progresses, + session_id=self.session_id, + status_info=self.status_info, + studio_url=self.studio_url, + template=self.template, + user=self.user, + wave_build_url=self.wave_build_url, + workspace_id=self.workspace_id) + + +def get_studios(workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStudiosResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getStudios:getStudios', __args__, opts=opts, typ=GetStudiosResult, package_ref=_utilities.get_package()).value + + return AwaitableGetStudiosResult( + active_connections=pulumi.get(__ret__, 'active_connections'), + base_image=pulumi.get(__ret__, 'base_image'), + compute_env=pulumi.get(__ret__, 'compute_env'), + configuration=pulumi.get(__ret__, 'configuration'), + custom_image=pulumi.get(__ret__, 'custom_image'), + date_created=pulumi.get(__ret__, 'date_created'), + description=pulumi.get(__ret__, 'description'), + effective_lifespan_hours=pulumi.get(__ret__, 'effective_lifespan_hours'), + id=pulumi.get(__ret__, 'id'), + is_private=pulumi.get(__ret__, 'is_private'), + labels=pulumi.get(__ret__, 'labels'), + last_started=pulumi.get(__ret__, 'last_started'), + last_updated=pulumi.get(__ret__, 'last_updated'), + mounted_data_links=pulumi.get(__ret__, 'mounted_data_links'), + name=pulumi.get(__ret__, 'name'), + parent_checkpoint=pulumi.get(__ret__, 'parent_checkpoint'), + progresses=pulumi.get(__ret__, 'progresses'), + session_id=pulumi.get(__ret__, 'session_id'), + status_info=pulumi.get(__ret__, 'status_info'), + studio_url=pulumi.get(__ret__, 'studio_url'), + template=pulumi.get(__ret__, 'template'), + user=pulumi.get(__ret__, 'user'), + wave_build_url=pulumi.get(__ret__, 'wave_build_url'), + workspace_id=pulumi.get(__ret__, 'workspace_id')) +def get_studios_output(workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetStudiosResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getStudios:getStudios', __args__, opts=opts, typ=GetStudiosResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetStudiosResult( + active_connections=pulumi.get(__response__, 'active_connections'), + base_image=pulumi.get(__response__, 'base_image'), + compute_env=pulumi.get(__response__, 'compute_env'), + configuration=pulumi.get(__response__, 'configuration'), + custom_image=pulumi.get(__response__, 'custom_image'), + date_created=pulumi.get(__response__, 'date_created'), + description=pulumi.get(__response__, 'description'), + effective_lifespan_hours=pulumi.get(__response__, 'effective_lifespan_hours'), + id=pulumi.get(__response__, 'id'), + is_private=pulumi.get(__response__, 'is_private'), + labels=pulumi.get(__response__, 'labels'), + last_started=pulumi.get(__response__, 'last_started'), + last_updated=pulumi.get(__response__, 'last_updated'), + mounted_data_links=pulumi.get(__response__, 'mounted_data_links'), + name=pulumi.get(__response__, 'name'), + parent_checkpoint=pulumi.get(__response__, 'parent_checkpoint'), + progresses=pulumi.get(__response__, 'progresses'), + session_id=pulumi.get(__response__, 'session_id'), + status_info=pulumi.get(__response__, 'status_info'), + studio_url=pulumi.get(__response__, 'studio_url'), + template=pulumi.get(__response__, 'template'), + user=pulumi.get(__response__, 'user'), + wave_build_url=pulumi.get(__response__, 'wave_build_url'), + workspace_id=pulumi.get(__response__, 'workspace_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_teams.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_teams.py new file mode 100644 index 00000000..9ae0756b --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_teams.py @@ -0,0 +1,144 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetTeamsResult', + 'AwaitableGetTeamsResult', + 'get_teams', + 'get_teams_output', +] + +@pulumi.output_type +class GetTeamsResult: + """ + A collection of values returned by getTeams. + """ + def __init__(__self__, avatar_url=None, description=None, id=None, members_count=None, name=None, org_id=None, team_id=None): + if avatar_url and not isinstance(avatar_url, str): + raise TypeError("Expected argument 'avatar_url' to be a str") + pulumi.set(__self__, "avatar_url", avatar_url) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if members_count and not isinstance(members_count, float): + raise TypeError("Expected argument 'members_count' to be a float") + pulumi.set(__self__, "members_count", members_count) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if team_id and not isinstance(team_id, float): + raise TypeError("Expected argument 'team_id' to be a float") + pulumi.set(__self__, "team_id", team_id) + + @_builtins.property + @pulumi.getter(name="avatarUrl") + def avatar_url(self) -> _builtins.str: + return pulumi.get(self, "avatar_url") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="membersCount") + def members_count(self) -> _builtins.float: + return pulumi.get(self, "members_count") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="teamId") + def team_id(self) -> _builtins.float: + return pulumi.get(self, "team_id") + + +class AwaitableGetTeamsResult(GetTeamsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetTeamsResult( + avatar_url=self.avatar_url, + description=self.description, + id=self.id, + members_count=self.members_count, + name=self.name, + org_id=self.org_id, + team_id=self.team_id) + + +def get_teams(org_id: Optional[_builtins.float] = None, + team_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTeamsResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + __args__['teamId'] = team_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getTeams:getTeams', __args__, opts=opts, typ=GetTeamsResult, package_ref=_utilities.get_package()).value + + return AwaitableGetTeamsResult( + avatar_url=pulumi.get(__ret__, 'avatar_url'), + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + members_count=pulumi.get(__ret__, 'members_count'), + name=pulumi.get(__ret__, 'name'), + org_id=pulumi.get(__ret__, 'org_id'), + team_id=pulumi.get(__ret__, 'team_id')) +def get_teams_output(org_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + team_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTeamsResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + __args__['teamId'] = team_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getTeams:getTeams', __args__, opts=opts, typ=GetTeamsResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetTeamsResult( + avatar_url=pulumi.get(__response__, 'avatar_url'), + description=pulumi.get(__response__, 'description'), + id=pulumi.get(__response__, 'id'), + members_count=pulumi.get(__response__, 'members_count'), + name=pulumi.get(__response__, 'name'), + org_id=pulumi.get(__response__, 'org_id'), + team_id=pulumi.get(__response__, 'team_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_tokens.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_tokens.py new file mode 100644 index 00000000..0b2dec28 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_tokens.py @@ -0,0 +1,112 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetTokensResult', + 'AwaitableGetTokensResult', + 'get_tokens', + 'get_tokens_output', +] + +@pulumi.output_type +class GetTokensResult: + """ + A collection of values returned by getTokens. + """ + def __init__(__self__, basic_auth=None, date_created=None, id=None, last_used=None, name=None): + if basic_auth and not isinstance(basic_auth, str): + raise TypeError("Expected argument 'basic_auth' to be a str") + pulumi.set(__self__, "basic_auth", basic_auth) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if id and not isinstance(id, float): + raise TypeError("Expected argument 'id' to be a float") + pulumi.set(__self__, "id", id) + if last_used and not isinstance(last_used, str): + raise TypeError("Expected argument 'last_used' to be a str") + pulumi.set(__self__, "last_used", last_used) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> _builtins.str: + return pulumi.get(self, "basic_auth") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + +class AwaitableGetTokensResult(GetTokensResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetTokensResult( + basic_auth=self.basic_auth, + date_created=self.date_created, + id=self.id, + last_used=self.last_used, + name=self.name) + + +def get_tokens(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTokensResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getTokens:getTokens', __args__, opts=opts, typ=GetTokensResult, package_ref=_utilities.get_package()).value + + return AwaitableGetTokensResult( + basic_auth=pulumi.get(__ret__, 'basic_auth'), + date_created=pulumi.get(__ret__, 'date_created'), + id=pulumi.get(__ret__, 'id'), + last_used=pulumi.get(__ret__, 'last_used'), + name=pulumi.get(__ret__, 'name')) +def get_tokens_output(opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTokensResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getTokens:getTokens', __args__, opts=opts, typ=GetTokensResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetTokensResult( + basic_auth=pulumi.get(__response__, 'basic_auth'), + date_created=pulumi.get(__response__, 'date_created'), + id=pulumi.get(__response__, 'id'), + last_used=pulumi.get(__response__, 'last_used'), + name=pulumi.get(__response__, 'name'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_user.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_user.py new file mode 100644 index 00000000..5cb8d15d --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_user.py @@ -0,0 +1,269 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetUserResult', + 'AwaitableGetUserResult', + 'get_user', + 'get_user_output', +] + +@pulumi.output_type +class GetUserResult: + """ + A collection of values returned by getUser. + """ + def __init__(__self__, avatar=None, avatar_id=None, date_created=None, default_workspace_id=None, deleted=None, description=None, email=None, first_name=None, id=None, last_access=None, last_name=None, last_updated=None, marketing_consent=None, need_consent=None, notification=None, organization=None, terms_of_use_consent=None, user_id=None, user_name=None): + if avatar and not isinstance(avatar, str): + raise TypeError("Expected argument 'avatar' to be a str") + pulumi.set(__self__, "avatar", avatar) + if avatar_id and not isinstance(avatar_id, str): + raise TypeError("Expected argument 'avatar_id' to be a str") + pulumi.set(__self__, "avatar_id", avatar_id) + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if default_workspace_id and not isinstance(default_workspace_id, float): + raise TypeError("Expected argument 'default_workspace_id' to be a float") + pulumi.set(__self__, "default_workspace_id", default_workspace_id) + if deleted and not isinstance(deleted, bool): + raise TypeError("Expected argument 'deleted' to be a bool") + pulumi.set(__self__, "deleted", deleted) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if email and not isinstance(email, str): + raise TypeError("Expected argument 'email' to be a str") + pulumi.set(__self__, "email", email) + if first_name and not isinstance(first_name, str): + raise TypeError("Expected argument 'first_name' to be a str") + pulumi.set(__self__, "first_name", first_name) + if id and not isinstance(id, float): + raise TypeError("Expected argument 'id' to be a float") + pulumi.set(__self__, "id", id) + if last_access and not isinstance(last_access, str): + raise TypeError("Expected argument 'last_access' to be a str") + pulumi.set(__self__, "last_access", last_access) + if last_name and not isinstance(last_name, str): + raise TypeError("Expected argument 'last_name' to be a str") + pulumi.set(__self__, "last_name", last_name) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if marketing_consent and not isinstance(marketing_consent, bool): + raise TypeError("Expected argument 'marketing_consent' to be a bool") + pulumi.set(__self__, "marketing_consent", marketing_consent) + if need_consent and not isinstance(need_consent, bool): + raise TypeError("Expected argument 'need_consent' to be a bool") + pulumi.set(__self__, "need_consent", need_consent) + if notification and not isinstance(notification, bool): + raise TypeError("Expected argument 'notification' to be a bool") + pulumi.set(__self__, "notification", notification) + if organization and not isinstance(organization, str): + raise TypeError("Expected argument 'organization' to be a str") + pulumi.set(__self__, "organization", organization) + if terms_of_use_consent and not isinstance(terms_of_use_consent, bool): + raise TypeError("Expected argument 'terms_of_use_consent' to be a bool") + pulumi.set(__self__, "terms_of_use_consent", terms_of_use_consent) + if user_id and not isinstance(user_id, float): + raise TypeError("Expected argument 'user_id' to be a float") + pulumi.set(__self__, "user_id", user_id) + if user_name and not isinstance(user_name, str): + raise TypeError("Expected argument 'user_name' to be a str") + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> _builtins.str: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter(name="avatarId") + def avatar_id(self) -> _builtins.str: + return pulumi.get(self, "avatar_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="defaultWorkspaceId") + def default_workspace_id(self) -> _builtins.float: + return pulumi.get(self, "default_workspace_id") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def email(self) -> _builtins.str: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter(name="firstName") + def first_name(self) -> _builtins.str: + return pulumi.get(self, "first_name") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastAccess") + def last_access(self) -> _builtins.str: + return pulumi.get(self, "last_access") + + @_builtins.property + @pulumi.getter(name="lastName") + def last_name(self) -> _builtins.str: + return pulumi.get(self, "last_name") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="marketingConsent") + def marketing_consent(self) -> _builtins.bool: + return pulumi.get(self, "marketing_consent") + + @_builtins.property + @pulumi.getter(name="needConsent") + def need_consent(self) -> _builtins.bool: + return pulumi.get(self, "need_consent") + + @_builtins.property + @pulumi.getter + def notification(self) -> _builtins.bool: + return pulumi.get(self, "notification") + + @_builtins.property + @pulumi.getter + def organization(self) -> _builtins.str: + return pulumi.get(self, "organization") + + @_builtins.property + @pulumi.getter(name="termsOfUseConsent") + def terms_of_use_consent(self) -> _builtins.bool: + return pulumi.get(self, "terms_of_use_consent") + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> _builtins.float: + return pulumi.get(self, "user_id") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + +class AwaitableGetUserResult(GetUserResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetUserResult( + avatar=self.avatar, + avatar_id=self.avatar_id, + date_created=self.date_created, + default_workspace_id=self.default_workspace_id, + deleted=self.deleted, + description=self.description, + email=self.email, + first_name=self.first_name, + id=self.id, + last_access=self.last_access, + last_name=self.last_name, + last_updated=self.last_updated, + marketing_consent=self.marketing_consent, + need_consent=self.need_consent, + notification=self.notification, + organization=self.organization, + terms_of_use_consent=self.terms_of_use_consent, + user_id=self.user_id, + user_name=self.user_name) + + +def get_user(user_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetUserResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['userId'] = user_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getUser:getUser', __args__, opts=opts, typ=GetUserResult, package_ref=_utilities.get_package()).value + + return AwaitableGetUserResult( + avatar=pulumi.get(__ret__, 'avatar'), + avatar_id=pulumi.get(__ret__, 'avatar_id'), + date_created=pulumi.get(__ret__, 'date_created'), + default_workspace_id=pulumi.get(__ret__, 'default_workspace_id'), + deleted=pulumi.get(__ret__, 'deleted'), + description=pulumi.get(__ret__, 'description'), + email=pulumi.get(__ret__, 'email'), + first_name=pulumi.get(__ret__, 'first_name'), + id=pulumi.get(__ret__, 'id'), + last_access=pulumi.get(__ret__, 'last_access'), + last_name=pulumi.get(__ret__, 'last_name'), + last_updated=pulumi.get(__ret__, 'last_updated'), + marketing_consent=pulumi.get(__ret__, 'marketing_consent'), + need_consent=pulumi.get(__ret__, 'need_consent'), + notification=pulumi.get(__ret__, 'notification'), + organization=pulumi.get(__ret__, 'organization'), + terms_of_use_consent=pulumi.get(__ret__, 'terms_of_use_consent'), + user_id=pulumi.get(__ret__, 'user_id'), + user_name=pulumi.get(__ret__, 'user_name')) +def get_user_output(user_id: Optional[pulumi.Input[_builtins.float]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetUserResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['userId'] = user_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getUser:getUser', __args__, opts=opts, typ=GetUserResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetUserResult( + avatar=pulumi.get(__response__, 'avatar'), + avatar_id=pulumi.get(__response__, 'avatar_id'), + date_created=pulumi.get(__response__, 'date_created'), + default_workspace_id=pulumi.get(__response__, 'default_workspace_id'), + deleted=pulumi.get(__response__, 'deleted'), + description=pulumi.get(__response__, 'description'), + email=pulumi.get(__response__, 'email'), + first_name=pulumi.get(__response__, 'first_name'), + id=pulumi.get(__response__, 'id'), + last_access=pulumi.get(__response__, 'last_access'), + last_name=pulumi.get(__response__, 'last_name'), + last_updated=pulumi.get(__response__, 'last_updated'), + marketing_consent=pulumi.get(__response__, 'marketing_consent'), + need_consent=pulumi.get(__response__, 'need_consent'), + notification=pulumi.get(__response__, 'notification'), + organization=pulumi.get(__response__, 'organization'), + terms_of_use_consent=pulumi.get(__response__, 'terms_of_use_consent'), + user_id=pulumi.get(__response__, 'user_id'), + user_name=pulumi.get(__response__, 'user_name'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_user_workspaces.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_user_workspaces.py new file mode 100644 index 00000000..afb7ad38 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_user_workspaces.py @@ -0,0 +1,97 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetUserWorkspacesResult', + 'AwaitableGetUserWorkspacesResult', + 'get_user_workspaces', + 'get_user_workspaces_output', +] + +@pulumi.output_type +class GetUserWorkspacesResult: + """ + A collection of values returned by getUserWorkspaces. + """ + def __init__(__self__, id=None, orgs_and_workspaces=None, user_id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if orgs_and_workspaces and not isinstance(orgs_and_workspaces, list): + raise TypeError("Expected argument 'orgs_and_workspaces' to be a list") + pulumi.set(__self__, "orgs_and_workspaces", orgs_and_workspaces) + if user_id and not isinstance(user_id, float): + raise TypeError("Expected argument 'user_id' to be a float") + pulumi.set(__self__, "user_id", user_id) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="orgsAndWorkspaces") + def orgs_and_workspaces(self) -> Sequence['outputs.GetUserWorkspacesOrgsAndWorkspaceResult']: + return pulumi.get(self, "orgs_and_workspaces") + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> _builtins.float: + return pulumi.get(self, "user_id") + + +class AwaitableGetUserWorkspacesResult(GetUserWorkspacesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetUserWorkspacesResult( + id=self.id, + orgs_and_workspaces=self.orgs_and_workspaces, + user_id=self.user_id) + + +def get_user_workspaces(user_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetUserWorkspacesResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['userId'] = user_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getUserWorkspaces:getUserWorkspaces', __args__, opts=opts, typ=GetUserWorkspacesResult, package_ref=_utilities.get_package()).value + + return AwaitableGetUserWorkspacesResult( + id=pulumi.get(__ret__, 'id'), + orgs_and_workspaces=pulumi.get(__ret__, 'orgs_and_workspaces'), + user_id=pulumi.get(__ret__, 'user_id')) +def get_user_workspaces_output(user_id: Optional[pulumi.Input[_builtins.float]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetUserWorkspacesResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['userId'] = user_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getUserWorkspaces:getUserWorkspaces', __args__, opts=opts, typ=GetUserWorkspacesResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetUserWorkspacesResult( + id=pulumi.get(__response__, 'id'), + orgs_and_workspaces=pulumi.get(__response__, 'orgs_and_workspaces'), + user_id=pulumi.get(__response__, 'user_id'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workflows.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workflows.py new file mode 100644 index 00000000..d6917d59 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workflows.py @@ -0,0 +1,226 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetWorkflowsResult', + 'AwaitableGetWorkflowsResult', + 'get_workflows', + 'get_workflows_output', +] + +@pulumi.output_type +class GetWorkflowsResult: + """ + A collection of values returned by getWorkflows. + """ + def __init__(__self__, attributes=None, id=None, job_info=None, labels=None, messages=None, optimized=None, org_id=None, org_name=None, platform=None, progress=None, workflow=None, workflow_id=None, workspace_id=None, workspace_name=None): + if attributes and not isinstance(attributes, list): + raise TypeError("Expected argument 'attributes' to be a list") + pulumi.set(__self__, "attributes", attributes) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if job_info and not isinstance(job_info, dict): + raise TypeError("Expected argument 'job_info' to be a dict") + pulumi.set(__self__, "job_info", job_info) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if messages and not isinstance(messages, list): + raise TypeError("Expected argument 'messages' to be a list") + pulumi.set(__self__, "messages", messages) + if optimized and not isinstance(optimized, bool): + raise TypeError("Expected argument 'optimized' to be a bool") + pulumi.set(__self__, "optimized", optimized) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if org_name and not isinstance(org_name, str): + raise TypeError("Expected argument 'org_name' to be a str") + pulumi.set(__self__, "org_name", org_name) + if platform and not isinstance(platform, dict): + raise TypeError("Expected argument 'platform' to be a dict") + pulumi.set(__self__, "platform", platform) + if progress and not isinstance(progress, dict): + raise TypeError("Expected argument 'progress' to be a dict") + pulumi.set(__self__, "progress", progress) + if workflow and not isinstance(workflow, dict): + raise TypeError("Expected argument 'workflow' to be a dict") + pulumi.set(__self__, "workflow", workflow) + if workflow_id and not isinstance(workflow_id, str): + raise TypeError("Expected argument 'workflow_id' to be a str") + pulumi.set(__self__, "workflow_id", workflow_id) + if workspace_id and not isinstance(workspace_id, float): + raise TypeError("Expected argument 'workspace_id' to be a float") + pulumi.set(__self__, "workspace_id", workspace_id) + if workspace_name and not isinstance(workspace_name, str): + raise TypeError("Expected argument 'workspace_name' to be a str") + pulumi.set(__self__, "workspace_name", workspace_name) + + @_builtins.property + @pulumi.getter + def attributes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "attributes") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="jobInfo") + def job_info(self) -> 'outputs.GetWorkflowsJobInfoResult': + return pulumi.get(self, "job_info") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetWorkflowsLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def messages(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "messages") + + @_builtins.property + @pulumi.getter + def optimized(self) -> _builtins.bool: + return pulumi.get(self, "optimized") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> _builtins.str: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter + def platform(self) -> 'outputs.GetWorkflowsPlatformResult': + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def progress(self) -> 'outputs.GetWorkflowsProgressResult': + return pulumi.get(self, "progress") + + @_builtins.property + @pulumi.getter + def workflow(self) -> 'outputs.GetWorkflowsWorkflowResult': + return pulumi.get(self, "workflow") + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> _builtins.str: + return pulumi.get(self, "workflow_id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> _builtins.str: + return pulumi.get(self, "workspace_name") + + +class AwaitableGetWorkflowsResult(GetWorkflowsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetWorkflowsResult( + attributes=self.attributes, + id=self.id, + job_info=self.job_info, + labels=self.labels, + messages=self.messages, + optimized=self.optimized, + org_id=self.org_id, + org_name=self.org_name, + platform=self.platform, + progress=self.progress, + workflow=self.workflow, + workflow_id=self.workflow_id, + workspace_id=self.workspace_id, + workspace_name=self.workspace_name) + + +def get_workflows(attributes: Optional[Sequence[_builtins.str]] = None, + workflow_id: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetWorkflowsResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['workflowId'] = workflow_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getWorkflows:getWorkflows', __args__, opts=opts, typ=GetWorkflowsResult, package_ref=_utilities.get_package()).value + + return AwaitableGetWorkflowsResult( + attributes=pulumi.get(__ret__, 'attributes'), + id=pulumi.get(__ret__, 'id'), + job_info=pulumi.get(__ret__, 'job_info'), + labels=pulumi.get(__ret__, 'labels'), + messages=pulumi.get(__ret__, 'messages'), + optimized=pulumi.get(__ret__, 'optimized'), + org_id=pulumi.get(__ret__, 'org_id'), + org_name=pulumi.get(__ret__, 'org_name'), + platform=pulumi.get(__ret__, 'platform'), + progress=pulumi.get(__ret__, 'progress'), + workflow=pulumi.get(__ret__, 'workflow'), + workflow_id=pulumi.get(__ret__, 'workflow_id'), + workspace_id=pulumi.get(__ret__, 'workspace_id'), + workspace_name=pulumi.get(__ret__, 'workspace_name')) +def get_workflows_output(attributes: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None, + workflow_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetWorkflowsResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['attributes'] = attributes + __args__['workflowId'] = workflow_id + __args__['workspaceId'] = workspace_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getWorkflows:getWorkflows', __args__, opts=opts, typ=GetWorkflowsResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetWorkflowsResult( + attributes=pulumi.get(__response__, 'attributes'), + id=pulumi.get(__response__, 'id'), + job_info=pulumi.get(__response__, 'job_info'), + labels=pulumi.get(__response__, 'labels'), + messages=pulumi.get(__response__, 'messages'), + optimized=pulumi.get(__response__, 'optimized'), + org_id=pulumi.get(__response__, 'org_id'), + org_name=pulumi.get(__response__, 'org_name'), + platform=pulumi.get(__response__, 'platform'), + progress=pulumi.get(__response__, 'progress'), + workflow=pulumi.get(__response__, 'workflow'), + workflow_id=pulumi.get(__response__, 'workflow_id'), + workspace_id=pulumi.get(__response__, 'workspace_id'), + workspace_name=pulumi.get(__response__, 'workspace_name'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workspace.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workspace.py new file mode 100644 index 00000000..dea4d112 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workspace.py @@ -0,0 +1,164 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetWorkspaceResult', + 'AwaitableGetWorkspaceResult', + 'get_workspace', + 'get_workspace_output', +] + +@pulumi.output_type +class GetWorkspaceResult: + """ + A collection of values returned by getWorkspace. + """ + def __init__(__self__, date_created=None, description=None, full_name=None, id=None, last_updated=None, name=None, org_id=None, visibility=None): + if date_created and not isinstance(date_created, str): + raise TypeError("Expected argument 'date_created' to be a str") + pulumi.set(__self__, "date_created", date_created) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if full_name and not isinstance(full_name, str): + raise TypeError("Expected argument 'full_name' to be a str") + pulumi.set(__self__, "full_name", full_name) + if id and not isinstance(id, float): + raise TypeError("Expected argument 'id' to be a float") + pulumi.set(__self__, "id", id) + if last_updated and not isinstance(last_updated, str): + raise TypeError("Expected argument 'last_updated' to be a str") + pulumi.set(__self__, "last_updated", last_updated) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if visibility and not isinstance(visibility, str): + raise TypeError("Expected argument 'visibility' to be a str") + pulumi.set(__self__, "visibility", visibility) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> _builtins.str: + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def visibility(self) -> _builtins.str: + return pulumi.get(self, "visibility") + + +class AwaitableGetWorkspaceResult(GetWorkspaceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetWorkspaceResult( + date_created=self.date_created, + description=self.description, + full_name=self.full_name, + id=self.id, + last_updated=self.last_updated, + name=self.name, + org_id=self.org_id, + visibility=self.visibility) + + +def get_workspace(description: Optional[_builtins.str] = None, + full_name: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + name: Optional[_builtins.str] = None, + org_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetWorkspaceResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['description'] = description + __args__['fullName'] = full_name + __args__['id'] = id + __args__['name'] = name + __args__['orgId'] = org_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getWorkspace:getWorkspace', __args__, opts=opts, typ=GetWorkspaceResult, package_ref=_utilities.get_package()).value + + return AwaitableGetWorkspaceResult( + date_created=pulumi.get(__ret__, 'date_created'), + description=pulumi.get(__ret__, 'description'), + full_name=pulumi.get(__ret__, 'full_name'), + id=pulumi.get(__ret__, 'id'), + last_updated=pulumi.get(__ret__, 'last_updated'), + name=pulumi.get(__ret__, 'name'), + org_id=pulumi.get(__ret__, 'org_id'), + visibility=pulumi.get(__ret__, 'visibility')) +def get_workspace_output(description: Optional[pulumi.Input[Optional[_builtins.str]]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetWorkspaceResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['description'] = description + __args__['fullName'] = full_name + __args__['id'] = id + __args__['name'] = name + __args__['orgId'] = org_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getWorkspace:getWorkspace', __args__, opts=opts, typ=GetWorkspaceResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetWorkspaceResult( + date_created=pulumi.get(__response__, 'date_created'), + description=pulumi.get(__response__, 'description'), + full_name=pulumi.get(__response__, 'full_name'), + id=pulumi.get(__response__, 'id'), + last_updated=pulumi.get(__response__, 'last_updated'), + name=pulumi.get(__response__, 'name'), + org_id=pulumi.get(__response__, 'org_id'), + visibility=pulumi.get(__response__, 'visibility'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workspaces.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workspaces.py new file mode 100644 index 00000000..947c0491 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/get_workspaces.py @@ -0,0 +1,97 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetWorkspacesResult', + 'AwaitableGetWorkspacesResult', + 'get_workspaces', + 'get_workspaces_output', +] + +@pulumi.output_type +class GetWorkspacesResult: + """ + A collection of values returned by getWorkspaces. + """ + def __init__(__self__, id=None, org_id=None, workspaces=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if org_id and not isinstance(org_id, float): + raise TypeError("Expected argument 'org_id' to be a float") + pulumi.set(__self__, "org_id", org_id) + if workspaces and not isinstance(workspaces, list): + raise TypeError("Expected argument 'workspaces' to be a list") + pulumi.set(__self__, "workspaces", workspaces) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def workspaces(self) -> Sequence['outputs.GetWorkspacesWorkspaceResult']: + return pulumi.get(self, "workspaces") + + +class AwaitableGetWorkspacesResult(GetWorkspacesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetWorkspacesResult( + id=self.id, + org_id=self.org_id, + workspaces=self.workspaces) + + +def get_workspaces(org_id: Optional[_builtins.float] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetWorkspacesResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('seqera:index/getWorkspaces:getWorkspaces', __args__, opts=opts, typ=GetWorkspacesResult, package_ref=_utilities.get_package()).value + + return AwaitableGetWorkspacesResult( + id=pulumi.get(__ret__, 'id'), + org_id=pulumi.get(__ret__, 'org_id'), + workspaces=pulumi.get(__ret__, 'workspaces')) +def get_workspaces_output(org_id: Optional[pulumi.Input[Optional[_builtins.float]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetWorkspacesResult]: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['orgId'] = org_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('seqera:index/getWorkspaces:getWorkspaces', __args__, opts=opts, typ=GetWorkspacesResult, package_ref=_utilities.get_package()) + return __ret__.apply(lambda __response__: GetWorkspacesResult( + id=pulumi.get(__response__, 'id'), + org_id=pulumi.get(__response__, 'org_id'), + workspaces=pulumi.get(__response__, 'workspaces'))) diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/labels.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/labels.py new file mode 100644 index 00000000..7200fb70 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/labels.py @@ -0,0 +1,395 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['LabelsArgs', 'Labels'] + +@pulumi.input_type +class LabelsArgs: + def __init__(__self__, *, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Labels resource. + :param pulumi.Input[_builtins.str] name: Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.bool] resource: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _LabelsState: + def __init__(__self__, *, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + label_id: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['LabelsLabelArgs']]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + total_size: Optional[pulumi.Input[_builtins.float]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Labels resources. + :param pulumi.Input[_builtins.float] label_id: Label numeric identifier + :param pulumi.Input[_builtins.str] name: Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.bool] resource: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if label_id is not None: + pulumi.set(__self__, "label_id", label_id) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if total_size is not None: + pulumi.set(__self__, "total_size", total_size) + if value is not None: + pulumi.set(__self__, "value", value) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "is_default") + + @is_default.setter + def is_default(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_default", value) + + @_builtins.property + @pulumi.getter(name="labelId") + def label_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Label numeric identifier + """ + return pulumi.get(self, "label_id") + + @label_id.setter + def label_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "label_id", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LabelsLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LabelsLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource") + + @resource.setter + def resource(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resource", value) + + @_builtins.property + @pulumi.getter(name="totalSize") + def total_size(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "total_size") + + @total_size.setter + def total_size(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "total_size", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/labels:Labels") +class Labels(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Labels resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] name: Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.bool] resource: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[LabelsArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Labels resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param LabelsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(LabelsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = LabelsArgs.__new__(LabelsArgs) + + __props__.__dict__["is_default"] = is_default + __props__.__dict__["name"] = name + __props__.__dict__["resource"] = resource + __props__.__dict__["value"] = value + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["label_id"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["total_size"] = None + super(Labels, __self__).__init__( + 'seqera:index/labels:Labels', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + is_default: Optional[pulumi.Input[_builtins.bool]] = None, + label_id: Optional[pulumi.Input[_builtins.float]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LabelsLabelArgs', 'LabelsLabelArgsDict']]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + resource: Optional[pulumi.Input[_builtins.bool]] = None, + total_size: Optional[pulumi.Input[_builtins.float]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Labels': + """ + Get an existing Labels resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.float] label_id: Label numeric identifier + :param pulumi.Input[_builtins.str] name: Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.bool] resource: Requires replacement if changed. + :param pulumi.Input[_builtins.str] value: Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _LabelsState.__new__(_LabelsState) + + __props__.__dict__["is_default"] = is_default + __props__.__dict__["label_id"] = label_id + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["resource"] = resource + __props__.__dict__["total_size"] = total_size + __props__.__dict__["value"] = value + __props__.__dict__["workspace_id"] = workspace_id + return Labels(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter(name="labelId") + def label_id(self) -> pulumi.Output[_builtins.float]: + """ + Label numeric identifier + """ + return pulumi.get(self, "label_id") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.LabelsLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Label name must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> pulumi.Output[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter(name="totalSize") + def total_size(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "total_size") + + @_builtins.property + @pulumi.getter + def value(self) -> pulumi.Output[_builtins.str]: + """ + Label value must contain a minimum of 1 and a maximum of 39 alphanumeric characters separated by dashes or underscores + """ + return pulumi.get(self, "value") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/orgs.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/orgs.py new file mode 100644 index 00000000..6d3652d5 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/orgs.py @@ -0,0 +1,465 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['OrgsArgs', 'Orgs'] + +@pulumi.input_type +class OrgsArgs: + def __init__(__self__, *, + full_name: pulumi.Input[_builtins.str], + description: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Orgs resource. + """ + pulumi.set(__self__, "full_name", full_name) + if description is not None: + pulumi.set(__self__, "description", description) + if location is not None: + pulumi.set(__self__, "location", location) + if logo_id is not None: + pulumi.set(__self__, "logo_id", logo_id) + if name is not None: + pulumi.set(__self__, "name", name) + if website is not None: + pulumi.set(__self__, "website", website) + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "full_name") + + @full_name.setter + def full_name(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "full_name", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="logoId") + def logo_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "logo_id") + + @logo_id.setter + def logo_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "logo_id", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def website(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "website") + + @website.setter + def website(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "website", value) + + +@pulumi.input_type +class _OrgsState: + def __init__(__self__, *, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + logo_url: Optional[pulumi.Input[_builtins.str]] = None, + member_id: Optional[pulumi.Input[_builtins.float]] = None, + member_role: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + paying: Optional[pulumi.Input[_builtins.bool]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None): + """ + Input properties used for looking up and filtering Orgs resources. + :param pulumi.Input[_builtins.str] member_role: must be one of ["owner", "member", "collaborator"] + :param pulumi.Input[_builtins.float] org_id: Unique numeric identifier for the organization + :param pulumi.Input[_builtins.bool] paying: Deprecated flag indicating if organization has paid subscription + :param pulumi.Input[_builtins.str] type: must be one of ["academic", "evaluating", "pro", "basic", "internal"] + """ + if description is not None: + pulumi.set(__self__, "description", description) + if full_name is not None: + pulumi.set(__self__, "full_name", full_name) + if location is not None: + pulumi.set(__self__, "location", location) + if logo_id is not None: + pulumi.set(__self__, "logo_id", logo_id) + if logo_url is not None: + pulumi.set(__self__, "logo_url", logo_url) + if member_id is not None: + pulumi.set(__self__, "member_id", member_id) + if member_role is not None: + pulumi.set(__self__, "member_role", member_role) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if paying is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""paying is deprecated: Deprecated""") + if paying is not None: + pulumi.set(__self__, "paying", paying) + if type is not None: + pulumi.set(__self__, "type", type) + if website is not None: + pulumi.set(__self__, "website", website) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "full_name") + + @full_name.setter + def full_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "full_name", value) + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "location") + + @location.setter + def location(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "location", value) + + @_builtins.property + @pulumi.getter(name="logoId") + def logo_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "logo_id") + + @logo_id.setter + def logo_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "logo_id", value) + + @_builtins.property + @pulumi.getter(name="logoUrl") + def logo_url(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "logo_url") + + @logo_url.setter + def logo_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "logo_url", value) + + @_builtins.property + @pulumi.getter(name="memberId") + def member_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "member_id") + + @member_id.setter + def member_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "member_id", value) + + @_builtins.property + @pulumi.getter(name="memberRole") + def member_role(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["owner", "member", "collaborator"] + """ + return pulumi.get(self, "member_role") + + @member_role.setter + def member_role(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "member_role", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the organization + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def paying(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Deprecated flag indicating if organization has paid subscription + """ + return pulumi.get(self, "paying") + + @paying.setter + def paying(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "paying", value) + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["academic", "evaluating", "pro", "basic", "internal"] + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "type", value) + + @_builtins.property + @pulumi.getter + def website(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "website") + + @website.setter + def website(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "website", value) + + +@pulumi.type_token("seqera:index/orgs:Orgs") +class Orgs(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None, + __props__=None): + """ + Create a Orgs resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: OrgsArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Orgs resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param OrgsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(OrgsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = OrgsArgs.__new__(OrgsArgs) + + __props__.__dict__["description"] = description + if full_name is None and not opts.urn: + raise TypeError("Missing required property 'full_name'") + __props__.__dict__["full_name"] = full_name + __props__.__dict__["location"] = location + __props__.__dict__["logo_id"] = logo_id + __props__.__dict__["name"] = name + __props__.__dict__["website"] = website + __props__.__dict__["logo_url"] = None + __props__.__dict__["member_id"] = None + __props__.__dict__["member_role"] = None + __props__.__dict__["org_id"] = None + __props__.__dict__["paying"] = None + __props__.__dict__["type"] = None + super(Orgs, __self__).__init__( + 'seqera:index/orgs:Orgs', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + location: Optional[pulumi.Input[_builtins.str]] = None, + logo_id: Optional[pulumi.Input[_builtins.str]] = None, + logo_url: Optional[pulumi.Input[_builtins.str]] = None, + member_id: Optional[pulumi.Input[_builtins.float]] = None, + member_role: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + paying: Optional[pulumi.Input[_builtins.bool]] = None, + type: Optional[pulumi.Input[_builtins.str]] = None, + website: Optional[pulumi.Input[_builtins.str]] = None) -> 'Orgs': + """ + Get an existing Orgs resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] member_role: must be one of ["owner", "member", "collaborator"] + :param pulumi.Input[_builtins.float] org_id: Unique numeric identifier for the organization + :param pulumi.Input[_builtins.bool] paying: Deprecated flag indicating if organization has paid subscription + :param pulumi.Input[_builtins.str] type: must be one of ["academic", "evaluating", "pro", "basic", "internal"] + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _OrgsState.__new__(_OrgsState) + + __props__.__dict__["description"] = description + __props__.__dict__["full_name"] = full_name + __props__.__dict__["location"] = location + __props__.__dict__["logo_id"] = logo_id + __props__.__dict__["logo_url"] = logo_url + __props__.__dict__["member_id"] = member_id + __props__.__dict__["member_role"] = member_role + __props__.__dict__["name"] = name + __props__.__dict__["org_id"] = org_id + __props__.__dict__["paying"] = paying + __props__.__dict__["type"] = type + __props__.__dict__["website"] = website + return Orgs(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter + def location(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="logoId") + def logo_id(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "logo_id") + + @_builtins.property + @pulumi.getter(name="logoUrl") + def logo_url(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "logo_url") + + @_builtins.property + @pulumi.getter(name="memberId") + def member_id(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "member_id") + + @_builtins.property + @pulumi.getter(name="memberRole") + def member_role(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["owner", "member", "collaborator"] + """ + return pulumi.get(self, "member_role") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the organization + """ + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def paying(self) -> pulumi.Output[_builtins.bool]: + """ + Deprecated flag indicating if organization has paid subscription + """ + return pulumi.get(self, "paying") + + @_builtins.property + @pulumi.getter + def type(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["academic", "evaluating", "pro", "basic", "internal"] + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter + def website(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "website") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/outputs.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/outputs.py new file mode 100644 index 00000000..b2e321b7 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/outputs.py @@ -0,0 +1,25334 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'ActionConfig', + 'ActionConfigGithub', + 'ActionConfigTower', + 'ActionEvent', + 'ActionEventGithub', + 'ActionEventTower', + 'ActionLabel', + 'ActionLaunch', + 'ActionLaunchComputeEnv', + 'ActionLaunchComputeEnvConfig', + 'ActionLaunchComputeEnvConfigAltairPlatform', + 'ActionLaunchComputeEnvConfigAltairPlatformEnvironment', + 'ActionLaunchComputeEnvConfigAwsBatch', + 'ActionLaunchComputeEnvConfigAwsBatchEnvironment', + 'ActionLaunchComputeEnvConfigAwsBatchForge', + 'ActionLaunchComputeEnvConfigAwsCloud', + 'ActionLaunchComputeEnvConfigAwsCloudEnvironment', + 'ActionLaunchComputeEnvConfigAzureBatch', + 'ActionLaunchComputeEnvConfigAzureBatchEnvironment', + 'ActionLaunchComputeEnvConfigAzureBatchForge', + 'ActionLaunchComputeEnvConfigEksPlatform', + 'ActionLaunchComputeEnvConfigEksPlatformEnvironment', + 'ActionLaunchComputeEnvConfigGkePlatform', + 'ActionLaunchComputeEnvConfigGkePlatformEnvironment', + 'ActionLaunchComputeEnvConfigGoogleBatch', + 'ActionLaunchComputeEnvConfigGoogleBatchEnvironment', + 'ActionLaunchComputeEnvConfigGoogleLifesciences', + 'ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironment', + 'ActionLaunchComputeEnvConfigK8sPlatform', + 'ActionLaunchComputeEnvConfigK8sPlatformEnvironment', + 'ActionLaunchComputeEnvConfigLsfPlatform', + 'ActionLaunchComputeEnvConfigLsfPlatformEnvironment', + 'ActionLaunchComputeEnvConfigMoabPlatform', + 'ActionLaunchComputeEnvConfigMoabPlatformEnvironment', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatform', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironment', + 'ActionLaunchComputeEnvConfigSeqeracomputePlatformForge', + 'ActionLaunchComputeEnvConfigSlurmPlatform', + 'ActionLaunchComputeEnvConfigSlurmPlatformEnvironment', + 'ActionLaunchComputeEnvConfigUgePlatform', + 'ActionLaunchComputeEnvConfigUgePlatformEnvironment', + 'ComputeEnvComputeEnv', + 'ComputeEnvComputeEnvConfig', + 'ComputeEnvComputeEnvConfigAltairPlatform', + 'ComputeEnvComputeEnvConfigAltairPlatformEnvironment', + 'ComputeEnvComputeEnvConfigAwsBatch', + 'ComputeEnvComputeEnvConfigAwsBatchEnvironment', + 'ComputeEnvComputeEnvConfigAwsBatchForge', + 'ComputeEnvComputeEnvConfigAwsCloud', + 'ComputeEnvComputeEnvConfigAwsCloudEnvironment', + 'ComputeEnvComputeEnvConfigAzureBatch', + 'ComputeEnvComputeEnvConfigAzureBatchEnvironment', + 'ComputeEnvComputeEnvConfigAzureBatchForge', + 'ComputeEnvComputeEnvConfigEksPlatform', + 'ComputeEnvComputeEnvConfigEksPlatformEnvironment', + 'ComputeEnvComputeEnvConfigGkePlatform', + 'ComputeEnvComputeEnvConfigGkePlatformEnvironment', + 'ComputeEnvComputeEnvConfigGoogleBatch', + 'ComputeEnvComputeEnvConfigGoogleBatchEnvironment', + 'ComputeEnvComputeEnvConfigGoogleLifesciences', + 'ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironment', + 'ComputeEnvComputeEnvConfigK8sPlatform', + 'ComputeEnvComputeEnvConfigK8sPlatformEnvironment', + 'ComputeEnvComputeEnvConfigLsfPlatform', + 'ComputeEnvComputeEnvConfigLsfPlatformEnvironment', + 'ComputeEnvComputeEnvConfigMoabPlatform', + 'ComputeEnvComputeEnvConfigMoabPlatformEnvironment', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatform', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironment', + 'ComputeEnvComputeEnvConfigSeqeracomputePlatformForge', + 'ComputeEnvComputeEnvConfigSlurmPlatform', + 'ComputeEnvComputeEnvConfigSlurmPlatformEnvironment', + 'ComputeEnvComputeEnvConfigUgePlatform', + 'ComputeEnvComputeEnvConfigUgePlatformEnvironment', + 'ComputeEnvComputeEnvLabel', + 'CredentialKeys', + 'CredentialKeysAws', + 'CredentialKeysAzure', + 'CredentialKeysAzureEntra', + 'CredentialKeysAzurerepos', + 'CredentialKeysBitbucket', + 'CredentialKeysCodecommit', + 'CredentialKeysContainerReg', + 'CredentialKeysGitea', + 'CredentialKeysGithub', + 'CredentialKeysGitlab', + 'CredentialKeysGoogle', + 'CredentialKeysK8s', + 'CredentialKeysSeqeracompute', + 'CredentialKeysSsh', + 'CredentialKeysTwAgent', + 'DataLinkCredential', + 'LabelsLabel', + 'PipelineComputeEnv', + 'PipelineLabel', + 'PipelineLaunch', + 'StudiosActiveConnection', + 'StudiosComputeEnv', + 'StudiosConfiguration', + 'StudiosLabel', + 'StudiosMountedDataLink', + 'StudiosMountedDataLinkCredential', + 'StudiosParentCheckpoint', + 'StudiosProgress', + 'StudiosStatusInfo', + 'StudiosTemplate', + 'StudiosUser', + 'TokensToken', + 'WorkflowsJobInfo', + 'WorkflowsLabel', + 'WorkflowsPlatform', + 'WorkflowsProgress', + 'WorkflowsProgressProcessesProgress', + 'WorkflowsProgressWorkflowProgress', + 'WorkflowsWorkflow', + 'WorkflowsWorkflowManifest', + 'WorkflowsWorkflowNextflow', + 'WorkflowsWorkflowStats', + 'GetActionConfigResult', + 'GetActionConfigGithubResult', + 'GetActionConfigTowerResult', + 'GetActionEventResult', + 'GetActionEventGithubResult', + 'GetActionEventTowerResult', + 'GetActionLabelResult', + 'GetActionLaunchResult', + 'GetActionLaunchComputeEnvResult', + 'GetActionLaunchComputeEnvConfigResult', + 'GetActionLaunchComputeEnvConfigAltairPlatformResult', + 'GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigAwsBatchResult', + 'GetActionLaunchComputeEnvConfigAwsBatchEnvironmentResult', + 'GetActionLaunchComputeEnvConfigAwsBatchForgeResult', + 'GetActionLaunchComputeEnvConfigAwsCloudResult', + 'GetActionLaunchComputeEnvConfigAwsCloudEnvironmentResult', + 'GetActionLaunchComputeEnvConfigAzureBatchResult', + 'GetActionLaunchComputeEnvConfigAzureBatchEnvironmentResult', + 'GetActionLaunchComputeEnvConfigAzureBatchForgeResult', + 'GetActionLaunchComputeEnvConfigEksPlatformResult', + 'GetActionLaunchComputeEnvConfigEksPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigGkePlatformResult', + 'GetActionLaunchComputeEnvConfigGkePlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigGoogleBatchResult', + 'GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentResult', + 'GetActionLaunchComputeEnvConfigGoogleLifesciencesResult', + 'GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentResult', + 'GetActionLaunchComputeEnvConfigK8sPlatformResult', + 'GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigLsfPlatformResult', + 'GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigMoabPlatformResult', + 'GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigSeqeracomputePlatformResult', + 'GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigSeqeracomputePlatformForgeResult', + 'GetActionLaunchComputeEnvConfigSlurmPlatformResult', + 'GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentResult', + 'GetActionLaunchComputeEnvConfigUgePlatformResult', + 'GetActionLaunchComputeEnvConfigUgePlatformEnvironmentResult', + 'GetComputeEnvComputeEnvResult', + 'GetComputeEnvComputeEnvConfigResult', + 'GetComputeEnvComputeEnvConfigAltairPlatformResult', + 'GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigAwsBatchResult', + 'GetComputeEnvComputeEnvConfigAwsBatchEnvironmentResult', + 'GetComputeEnvComputeEnvConfigAwsBatchForgeResult', + 'GetComputeEnvComputeEnvConfigAwsCloudResult', + 'GetComputeEnvComputeEnvConfigAwsCloudEnvironmentResult', + 'GetComputeEnvComputeEnvConfigAzureBatchResult', + 'GetComputeEnvComputeEnvConfigAzureBatchEnvironmentResult', + 'GetComputeEnvComputeEnvConfigAzureBatchForgeResult', + 'GetComputeEnvComputeEnvConfigEksPlatformResult', + 'GetComputeEnvComputeEnvConfigEksPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigGkePlatformResult', + 'GetComputeEnvComputeEnvConfigGkePlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigGoogleBatchResult', + 'GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentResult', + 'GetComputeEnvComputeEnvConfigGoogleLifesciencesResult', + 'GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentResult', + 'GetComputeEnvComputeEnvConfigK8sPlatformResult', + 'GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigLsfPlatformResult', + 'GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigMoabPlatformResult', + 'GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigSeqeracomputePlatformResult', + 'GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigSeqeracomputePlatformForgeResult', + 'GetComputeEnvComputeEnvConfigSlurmPlatformResult', + 'GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentResult', + 'GetComputeEnvComputeEnvConfigUgePlatformResult', + 'GetComputeEnvComputeEnvConfigUgePlatformEnvironmentResult', + 'GetComputeEnvComputeEnvLabelResult', + 'GetCredentialKeysResult', + 'GetCredentialKeysAwsResult', + 'GetCredentialKeysAzureResult', + 'GetCredentialKeysAzureEntraResult', + 'GetCredentialKeysAzurereposResult', + 'GetCredentialKeysBitbucketResult', + 'GetCredentialKeysCodecommitResult', + 'GetCredentialKeysContainerRegResult', + 'GetCredentialKeysGiteaResult', + 'GetCredentialKeysGithubResult', + 'GetCredentialKeysGitlabResult', + 'GetCredentialKeysGoogleResult', + 'GetCredentialKeysK8sResult', + 'GetCredentialKeysSeqeracomputeResult', + 'GetCredentialKeysSshResult', + 'GetCredentialKeysTwAgentResult', + 'GetDataLinkCredentialResult', + 'GetDatasetDatasetResult', + 'GetLabelsLabelResult', + 'GetPipelineComputeEnvResult', + 'GetPipelineLabelResult', + 'GetStudiosActiveConnectionResult', + 'GetStudiosComputeEnvResult', + 'GetStudiosConfigurationResult', + 'GetStudiosLabelResult', + 'GetStudiosMountedDataLinkResult', + 'GetStudiosMountedDataLinkCredentialResult', + 'GetStudiosParentCheckpointResult', + 'GetStudiosProgressResult', + 'GetStudiosStatusInfoResult', + 'GetStudiosTemplateResult', + 'GetStudiosUserResult', + 'GetUserWorkspacesOrgsAndWorkspaceResult', + 'GetWorkflowsJobInfoResult', + 'GetWorkflowsLabelResult', + 'GetWorkflowsPlatformResult', + 'GetWorkflowsProgressResult', + 'GetWorkflowsProgressProcessesProgressResult', + 'GetWorkflowsProgressWorkflowProgressResult', + 'GetWorkflowsWorkflowResult', + 'GetWorkflowsWorkflowManifestResult', + 'GetWorkflowsWorkflowNextflowResult', + 'GetWorkflowsWorkflowStatsResult', + 'GetWorkspacesWorkspaceResult', +] + +@pulumi.output_type +class ActionConfig(dict): + def __init__(__self__, *, + github: Optional['outputs.ActionConfigGithub'] = None, + tower: Optional['outputs.ActionConfigTower'] = None): + if github is not None: + pulumi.set(__self__, "github", github) + if tower is not None: + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional['outputs.ActionConfigGithub']: + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def tower(self) -> Optional['outputs.ActionConfigTower']: + return pulumi.get(self, "tower") + + +@pulumi.output_type +class ActionConfigGithub(dict): + def __init__(__self__, *, + discriminator: Optional[_builtins.str] = None, + events: Optional[Sequence[_builtins.str]] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if events is not None: + pulumi.set(__self__, "events", events) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[_builtins.str]: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter + def events(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "events") + + +@pulumi.output_type +class ActionConfigTower(dict): + def __init__(__self__, *, + discriminator: Optional[_builtins.str] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[_builtins.str]: + return pulumi.get(self, "discriminator") + + +@pulumi.output_type +class ActionEvent(dict): + def __init__(__self__, *, + github: Optional['outputs.ActionEventGithub'] = None, + tower: Optional['outputs.ActionEventTower'] = None): + if github is not None: + pulumi.set(__self__, "github", github) + if tower is not None: + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> Optional['outputs.ActionEventGithub']: + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def tower(self) -> Optional['outputs.ActionEventTower']: + return pulumi.get(self, "tower") + + +@pulumi.output_type +class ActionEventGithub(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "commitId": + suggest = "commit_id" + elif key == "commitMessage": + suggest = "commit_message" + elif key == "pusherEmail": + suggest = "pusher_email" + elif key == "pusherName": + suggest = "pusher_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionEventGithub. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionEventGithub.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionEventGithub.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + commit_id: Optional[_builtins.str] = None, + commit_message: Optional[_builtins.str] = None, + discriminator: Optional[_builtins.str] = None, + pusher_email: Optional[_builtins.str] = None, + pusher_name: Optional[_builtins.str] = None, + ref: Optional[_builtins.str] = None, + timestamp: Optional[_builtins.str] = None): + if commit_id is not None: + pulumi.set(__self__, "commit_id", commit_id) + if commit_message is not None: + pulumi.set(__self__, "commit_message", commit_message) + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if pusher_email is not None: + pulumi.set(__self__, "pusher_email", pusher_email) + if pusher_name is not None: + pulumi.set(__self__, "pusher_name", pusher_name) + if ref is not None: + pulumi.set(__self__, "ref", ref) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "commit_id") + + @_builtins.property + @pulumi.getter(name="commitMessage") + def commit_message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "commit_message") + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[_builtins.str]: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter(name="pusherEmail") + def pusher_email(self) -> Optional[_builtins.str]: + return pulumi.get(self, "pusher_email") + + @_builtins.property + @pulumi.getter(name="pusherName") + def pusher_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "pusher_name") + + @_builtins.property + @pulumi.getter + def ref(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ref") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[_builtins.str]: + return pulumi.get(self, "timestamp") + + +@pulumi.output_type +class ActionEventTower(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "workflowId": + suggest = "workflow_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionEventTower. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionEventTower.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionEventTower.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + discriminator: Optional[_builtins.str] = None, + timestamp: Optional[_builtins.str] = None, + workflow_id: Optional[_builtins.str] = None): + if discriminator is not None: + pulumi.set(__self__, "discriminator", discriminator) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + if workflow_id is not None: + pulumi.set(__self__, "workflow_id", workflow_id) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> Optional[_builtins.str]: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[_builtins.str]: + return pulumi.get(self, "timestamp") + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "workflow_id") + + +@pulumi.output_type +class ActionLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeEnvId": + suggest = "compute_env_id" + elif key == "workDir": + suggest = "work_dir" + elif key == "computeEnv": + suggest = "compute_env" + elif key == "configProfiles": + suggest = "config_profiles" + elif key == "configText": + suggest = "config_text" + elif key == "dateCreated": + suggest = "date_created" + elif key == "entryName": + suggest = "entry_name" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "labelIds": + suggest = "label_ids" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "launchContainer": + suggest = "launch_container" + elif key == "mainScript": + suggest = "main_script" + elif key == "optimizationId": + suggest = "optimization_id" + elif key == "optimizationTargets": + suggest = "optimization_targets" + elif key == "paramsText": + suggest = "params_text" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "pullLatest": + suggest = "pull_latest" + elif key == "resumeLaunchId": + suggest = "resume_launch_id" + elif key == "runName": + suggest = "run_name" + elif key == "schemaName": + suggest = "schema_name" + elif key == "sessionId": + suggest = "session_id" + elif key == "stubRun": + suggest = "stub_run" + elif key == "towerConfig": + suggest = "tower_config" + elif key == "userSecrets": + suggest = "user_secrets" + elif key == "workspaceSecrets": + suggest = "workspace_secrets" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_env_id: _builtins.str, + pipeline: _builtins.str, + work_dir: _builtins.str, + compute_env: Optional['outputs.ActionLaunchComputeEnv'] = None, + config_profiles: Optional[Sequence[_builtins.str]] = None, + config_text: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + entry_name: Optional[_builtins.str] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + id: Optional[_builtins.str] = None, + label_ids: Optional[Sequence[_builtins.float]] = None, + last_updated: Optional[_builtins.str] = None, + launch_container: Optional[_builtins.str] = None, + main_script: Optional[_builtins.str] = None, + optimization_id: Optional[_builtins.str] = None, + optimization_targets: Optional[_builtins.str] = None, + params_text: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + pull_latest: Optional[_builtins.bool] = None, + resume: Optional[_builtins.bool] = None, + resume_launch_id: Optional[_builtins.str] = None, + revision: Optional[_builtins.str] = None, + run_name: Optional[_builtins.str] = None, + schema_name: Optional[_builtins.str] = None, + session_id: Optional[_builtins.str] = None, + stub_run: Optional[_builtins.bool] = None, + tower_config: Optional[_builtins.str] = None, + user_secrets: Optional[Sequence[_builtins.str]] = None, + workspace_secrets: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str compute_env_id: Requires replacement if changed. + :param _builtins.str pipeline: Requires replacement if changed. + :param _builtins.str work_dir: Requires replacement if changed. + :param Sequence[_builtins.str] config_profiles: Requires replacement if changed. + :param _builtins.str config_text: Requires replacement if changed. + :param _builtins.str date_created: Requires replacement if changed. + :param _builtins.str entry_name: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param Sequence[_builtins.float] label_ids: Requires replacement if changed. + :param _builtins.str launch_container: Requires replacement if changed. + :param _builtins.str main_script: Requires replacement if changed. + :param _builtins.str optimization_id: Requires replacement if changed. + :param _builtins.str optimization_targets: Requires replacement if changed. + :param _builtins.str params_text: Requires replacement if changed. + :param _builtins.str post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + :param _builtins.str pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + :param _builtins.bool pull_latest: Requires replacement if changed. + :param _builtins.bool resume: Requires replacement if changed. + :param _builtins.str revision: Requires replacement if changed. + :param _builtins.str run_name: Requires replacement if changed. + :param _builtins.str schema_name: Requires replacement if changed. + :param _builtins.str session_id: Requires replacement if changed. + :param _builtins.bool stub_run: Requires replacement if changed. + :param _builtins.str tower_config: Requires replacement if changed. + :param Sequence[_builtins.str] user_secrets: Requires replacement if changed. + :param Sequence[_builtins.str] workspace_secrets: Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if id is not None: + pulumi.set(__self__, "id", id) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if resume_launch_id is not None: + pulumi.set(__self__, "resume_launch_id", resume_launch_id) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def pipeline(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional['outputs.ActionLaunchComputeEnv']: + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[Sequence[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter(name="resumeLaunchId") + def resume_launch_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "resume_launch_id") + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + + +@pulumi.output_type +class ActionLaunchComputeEnv(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeEnvId": + suggest = "compute_env_id" + elif key == "credentialsId": + suggest = "credentials_id" + elif key == "dateCreated": + suggest = "date_created" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "lastUsed": + suggest = "last_used" + elif key == "orgId": + suggest = "org_id" + elif key == "workspaceId": + suggest = "workspace_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnv. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnv.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnv.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_env_id: Optional[_builtins.str] = None, + config: Optional['outputs.ActionLaunchComputeEnvConfig'] = None, + credentials_id: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + deleted: Optional[_builtins.bool] = None, + description: Optional[_builtins.str] = None, + last_updated: Optional[_builtins.str] = None, + last_used: Optional[_builtins.str] = None, + message: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + org_id: Optional[_builtins.float] = None, + platform: Optional[_builtins.str] = None, + primary: Optional[_builtins.bool] = None, + status: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None): + """ + :param 'ActionLaunchComputeEnvConfigArgs' config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + :param _builtins.str platform: must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + :param _builtins.str status: must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if config is not None: + pulumi.set(__self__, "config", config) + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if primary is not None: + pulumi.set(__self__, "primary", primary) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def config(self) -> Optional['outputs.ActionLaunchComputeEnvConfig']: + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[_builtins.str]: + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"] + """ + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def primary(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "primary") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "altairPlatform": + suggest = "altair_platform" + elif key == "awsBatch": + suggest = "aws_batch" + elif key == "awsCloud": + suggest = "aws_cloud" + elif key == "azureBatch": + suggest = "azure_batch" + elif key == "eksPlatform": + suggest = "eks_platform" + elif key == "gkePlatform": + suggest = "gke_platform" + elif key == "googleBatch": + suggest = "google_batch" + elif key == "googleLifesciences": + suggest = "google_lifesciences" + elif key == "k8sPlatform": + suggest = "k8s_platform" + elif key == "lsfPlatform": + suggest = "lsf_platform" + elif key == "moabPlatform": + suggest = "moab_platform" + elif key == "seqeracomputePlatform": + suggest = "seqeracompute_platform" + elif key == "slurmPlatform": + suggest = "slurm_platform" + elif key == "ugePlatform": + suggest = "uge_platform" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + altair_platform: Optional['outputs.ActionLaunchComputeEnvConfigAltairPlatform'] = None, + aws_batch: Optional['outputs.ActionLaunchComputeEnvConfigAwsBatch'] = None, + aws_cloud: Optional['outputs.ActionLaunchComputeEnvConfigAwsCloud'] = None, + azure_batch: Optional['outputs.ActionLaunchComputeEnvConfigAzureBatch'] = None, + eks_platform: Optional['outputs.ActionLaunchComputeEnvConfigEksPlatform'] = None, + gke_platform: Optional['outputs.ActionLaunchComputeEnvConfigGkePlatform'] = None, + google_batch: Optional['outputs.ActionLaunchComputeEnvConfigGoogleBatch'] = None, + google_lifesciences: Optional['outputs.ActionLaunchComputeEnvConfigGoogleLifesciences'] = None, + k8s_platform: Optional['outputs.ActionLaunchComputeEnvConfigK8sPlatform'] = None, + lsf_platform: Optional['outputs.ActionLaunchComputeEnvConfigLsfPlatform'] = None, + moab_platform: Optional['outputs.ActionLaunchComputeEnvConfigMoabPlatform'] = None, + seqeracompute_platform: Optional['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatform'] = None, + slurm_platform: Optional['outputs.ActionLaunchComputeEnvConfigSlurmPlatform'] = None, + uge_platform: Optional['outputs.ActionLaunchComputeEnvConfigUgePlatform'] = None): + if altair_platform is not None: + pulumi.set(__self__, "altair_platform", altair_platform) + if aws_batch is not None: + pulumi.set(__self__, "aws_batch", aws_batch) + if aws_cloud is not None: + pulumi.set(__self__, "aws_cloud", aws_cloud) + if azure_batch is not None: + pulumi.set(__self__, "azure_batch", azure_batch) + if eks_platform is not None: + pulumi.set(__self__, "eks_platform", eks_platform) + if gke_platform is not None: + pulumi.set(__self__, "gke_platform", gke_platform) + if google_batch is not None: + pulumi.set(__self__, "google_batch", google_batch) + if google_lifesciences is not None: + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + if k8s_platform is not None: + pulumi.set(__self__, "k8s_platform", k8s_platform) + if lsf_platform is not None: + pulumi.set(__self__, "lsf_platform", lsf_platform) + if moab_platform is not None: + pulumi.set(__self__, "moab_platform", moab_platform) + if seqeracompute_platform is not None: + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + if slurm_platform is not None: + pulumi.set(__self__, "slurm_platform", slurm_platform) + if uge_platform is not None: + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAltairPlatform']: + return pulumi.get(self, "altair_platform") + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAwsBatch']: + return pulumi.get(self, "aws_batch") + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAwsCloud']: + return pulumi.get(self, "aws_cloud") + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAzureBatch']: + return pulumi.get(self, "azure_batch") + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigEksPlatform']: + return pulumi.get(self, "eks_platform") + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigGkePlatform']: + return pulumi.get(self, "gke_platform") + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> Optional['outputs.ActionLaunchComputeEnvConfigGoogleBatch']: + return pulumi.get(self, "google_batch") + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> Optional['outputs.ActionLaunchComputeEnvConfigGoogleLifesciences']: + return pulumi.get(self, "google_lifesciences") + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigK8sPlatform']: + return pulumi.get(self, "k8s_platform") + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigLsfPlatform']: + return pulumi.get(self, "lsf_platform") + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigMoabPlatform']: + return pulumi.get(self, "moab_platform") + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatform']: + return pulumi.get(self, "seqeracompute_platform") + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigSlurmPlatform']: + return pulumi.get(self, "slurm_platform") + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> Optional['outputs.ActionLaunchComputeEnvConfigUgePlatform']: + return pulumi.get(self, "uge_platform") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAltairPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAltairPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAltairPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAltairPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAltairPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAltairPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAltairPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cliPath": + suggest = "cli_path" + elif key == "computeJobRole": + suggest = "compute_job_role" + elif key == "computeQueue": + suggest = "compute_queue" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "dragenQueue": + suggest = "dragen_queue" + elif key == "executionRole": + suggest = "execution_role" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "fusionSnapshots": + suggest = "fusion_snapshots" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headJobRole": + suggest = "head_job_role" + elif key == "headQueue": + suggest = "head_queue" + elif key == "logGroup": + suggest = "log_group" + elif key == "lustreId": + suggest = "lustre_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nvnmeStorageEnabled": + suggest = "nvnme_storage_enabled" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "storageType": + suggest = "storage_type" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAwsBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAwsBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAwsBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cli_path: Optional[_builtins.str] = None, + compute_job_role: Optional[_builtins.str] = None, + compute_queue: Optional[_builtins.str] = None, + dragen_instance_type: Optional[_builtins.str] = None, + dragen_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAwsBatchEnvironment']] = None, + execution_role: Optional[_builtins.str] = None, + forge: Optional['outputs.ActionLaunchComputeEnvConfigAwsBatchForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + fusion_snapshots: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_job_role: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + lustre_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nvnme_storage_enabled: Optional[_builtins.bool] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + storage_type: Optional[_builtins.str] = None, + volumes: Optional[Sequence[_builtins.str]] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAwsBatchEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAwsBatchForge']: + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsBatchForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allocStrategy": + suggest = "alloc_strategy" + elif key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "bidPercentage": + suggest = "bid_percentage" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "dragenAmiId": + suggest = "dragen_ami_id" + elif key == "dragenEnabled": + suggest = "dragen_enabled" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "ebsAutoScale": + suggest = "ebs_auto_scale" + elif key == "ebsBlockSize": + suggest = "ebs_block_size" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "ecsConfig": + suggest = "ecs_config" + elif key == "efsCreate": + suggest = "efs_create" + elif key == "efsId": + suggest = "efs_id" + elif key == "efsMount": + suggest = "efs_mount" + elif key == "fargateHeadEnabled": + suggest = "fargate_head_enabled" + elif key == "fsxMount": + suggest = "fsx_mount" + elif key == "fsxName": + suggest = "fsx_name" + elif key == "fsxSize": + suggest = "fsx_size" + elif key == "fusionEnabled": + suggest = "fusion_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceTypes": + suggest = "instance_types" + elif key == "maxCpus": + suggest = "max_cpus" + elif key == "minCpus": + suggest = "min_cpus" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "vpcId": + suggest = "vpc_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAwsBatchForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAwsBatchForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAwsBatchForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alloc_strategy: Optional[_builtins.str] = None, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + bid_percentage: Optional[_builtins.float] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + dragen_ami_id: Optional[_builtins.str] = None, + dragen_enabled: Optional[_builtins.bool] = None, + dragen_instance_type: Optional[_builtins.str] = None, + ebs_auto_scale: Optional[_builtins.bool] = None, + ebs_block_size: Optional[_builtins.float] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + ecs_config: Optional[_builtins.str] = None, + efs_create: Optional[_builtins.bool] = None, + efs_id: Optional[_builtins.str] = None, + efs_mount: Optional[_builtins.str] = None, + fargate_head_enabled: Optional[_builtins.bool] = None, + fsx_mount: Optional[_builtins.str] = None, + fsx_name: Optional[_builtins.str] = None, + fsx_size: Optional[_builtins.float] = None, + fusion_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_types: Optional[Sequence[_builtins.str]] = None, + max_cpus: Optional[_builtins.float] = None, + min_cpus: Optional[_builtins.float] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnets: Optional[Sequence[_builtins.str]] = None, + type: Optional[_builtins.str] = None, + vpc_id: Optional[_builtins.str] = None): + """ + :param _builtins.str alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + :param _builtins.str type: must be one of ["SPOT", "EC2"] + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[_builtins.str]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[_builtins.float]: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + must be one of ["SPOT", "EC2"] + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsCloud(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceProfileArn": + suggest = "instance_profile_arn" + elif key == "instanceType": + suggest = "instance_type" + elif key == "logGroup": + suggest = "log_group" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "subnetId": + suggest = "subnet_id" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAwsCloud. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAwsCloud.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAwsCloud.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAwsCloudEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_profile_arn: Optional[_builtins.str] = None, + instance_type: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnet_id: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_profile_arn is not None: + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + if instance_type is not None: + pulumi.set(__self__, "instance_type", instance_type) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnet_id is not None: + pulumi.set(__self__, "subnet_id", subnet_id) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAwsCloudEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> Optional[_builtins.str]: + return pulumi.get(self, "instance_profile_arn") + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "instance_type") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "subnet_id") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAwsCloudEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAzureBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "autoPoolMode": + suggest = "auto_pool_mode" + elif key == "deleteJobsOnCompletion": + suggest = "delete_jobs_on_completion" + elif key == "deletePoolsOnCompletion": + suggest = "delete_pools_on_completion" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headPool": + suggest = "head_pool" + elif key == "managedIdentityClientId": + suggest = "managed_identity_client_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "tokenDuration": + suggest = "token_duration" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAzureBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAzureBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAzureBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auto_pool_mode: Optional[_builtins.bool] = None, + delete_jobs_on_completion: Optional[_builtins.str] = None, + delete_pools_on_completion: Optional[_builtins.bool] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAzureBatchEnvironment']] = None, + forge: Optional['outputs.ActionLaunchComputeEnvConfigAzureBatchForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_pool: Optional[_builtins.str] = None, + managed_identity_client_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + token_duration: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str delete_jobs_on_completion: must be one of ["on_success", "always", "never"] + :param Sequence['ActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if auto_pool_mode is not None: + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + if delete_jobs_on_completion is not None: + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + if delete_pools_on_completion is not None: + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_pool is not None: + pulumi.set(__self__, "head_pool", head_pool) + if managed_identity_client_id is not None: + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if token_duration is not None: + pulumi.set(__self__, "token_duration", token_duration) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "auto_pool_mode") + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "delete_jobs_on_completion") + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "delete_pools_on_completion") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigAzureBatchEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ActionLaunchComputeEnvConfigAzureBatchForge']: + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_pool") + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "managed_identity_client_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> Optional[_builtins.str]: + return pulumi.get(self, "token_duration") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAzureBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigAzureBatchForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "autoScale": + suggest = "auto_scale" + elif key == "containerRegIds": + suggest = "container_reg_ids" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "vmCount": + suggest = "vm_count" + elif key == "vmType": + suggest = "vm_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigAzureBatchForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigAzureBatchForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigAzureBatchForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auto_scale: Optional[_builtins.bool] = None, + container_reg_ids: Optional[Sequence[_builtins.str]] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + vm_count: Optional[_builtins.float] = None, + vm_type: Optional[_builtins.str] = None): + if auto_scale is not None: + pulumi.set(__self__, "auto_scale", auto_scale) + if container_reg_ids is not None: + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if vm_count is not None: + pulumi.set(__self__, "vm_count", vm_count) + if vm_type is not None: + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "auto_scale") + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "container_reg_ids") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "vm_count") + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "vm_type") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigEksPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterName": + suggest = "cluster_name" + elif key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigEksPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigEksPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigEksPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_name: Optional[_builtins.str] = None, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigEksPlatformEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cluster_name: The AWS EKS cluster name + :param Sequence['ActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"] + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: AWS region + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[_builtins.str]: + """ + The AWS EKS cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigEksPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + AWS region + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigEksPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGkePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterName": + suggest = "cluster_name" + elif key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigGkePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigGkePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigGkePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_name: Optional[_builtins.str] = None, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGkePlatformEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cluster_name: The GKE cluster name + :param Sequence['ActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"] + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: The GKE cluster region - or - zone + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[_builtins.str]: + """ + The GKE cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGkePlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + The GKE cluster region - or - zone + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGkePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGoogleBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootDiskSizeGb": + suggest = "boot_disk_size_gb" + elif key == "computeJobsInstanceTemplate": + suggest = "compute_jobs_instance_template" + elif key == "copyImage": + suggest = "copy_image" + elif key == "cpuPlatform": + suggest = "cpu_platform" + elif key == "debugMode": + suggest = "debug_mode" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobInstanceTemplate": + suggest = "head_job_instance_template" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "machineType": + suggest = "machine_type" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nfsMount": + suggest = "nfs_mount" + elif key == "nfsTarget": + suggest = "nfs_target" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "projectId": + suggest = "project_id" + elif key == "serviceAccount": + suggest = "service_account" + elif key == "sshDaemon": + suggest = "ssh_daemon" + elif key == "sshImage": + suggest = "ssh_image" + elif key == "usePrivateAddress": + suggest = "use_private_address" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigGoogleBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigGoogleBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigGoogleBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_disk_size_gb: Optional[_builtins.float] = None, + compute_jobs_instance_template: Optional[_builtins.str] = None, + copy_image: Optional[_builtins.str] = None, + cpu_platform: Optional[_builtins.str] = None, + debug_mode: Optional[_builtins.float] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGoogleBatchEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_instance_template: Optional[_builtins.str] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + location: Optional[_builtins.str] = None, + machine_type: Optional[_builtins.str] = None, + network: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nfs_mount: Optional[_builtins.str] = None, + nfs_target: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + project_id: Optional[_builtins.str] = None, + service_account: Optional[_builtins.str] = None, + spot: Optional[_builtins.bool] = None, + ssh_daemon: Optional[_builtins.bool] = None, + ssh_image: Optional[_builtins.str] = None, + subnetwork: Optional[_builtins.str] = None, + use_private_address: Optional[_builtins.bool] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if compute_jobs_instance_template is not None: + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if cpu_platform is not None: + pulumi.set(__self__, "cpu_platform", cpu_platform) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_instance_template is not None: + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if network is not None: + pulumi.set(__self__, "network", network) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if subnetwork is not None: + pulumi.set(__self__, "subnetwork", subnetwork) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_jobs_instance_template") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[_builtins.str]: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> Optional[_builtins.str]: + return pulumi.get(self, "cpu_platform") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[_builtins.float]: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGoogleBatchEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_instance_template") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[_builtins.str]: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "machine_type") + + @_builtins.property + @pulumi.getter + def network(self) -> Optional[_builtins.str]: + return pulumi.get(self, "network") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "service_account") + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> Optional[_builtins.str]: + return pulumi.get(self, "subnetwork") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGoogleBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGoogleLifesciences(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootDiskSizeGb": + suggest = "boot_disk_size_gb" + elif key == "copyImage": + suggest = "copy_image" + elif key == "debugMode": + suggest = "debug_mode" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nfsMount": + suggest = "nfs_mount" + elif key == "nfsTarget": + suggest = "nfs_target" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "projectId": + suggest = "project_id" + elif key == "sshDaemon": + suggest = "ssh_daemon" + elif key == "sshImage": + suggest = "ssh_image" + elif key == "usePrivateAddress": + suggest = "use_private_address" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigGoogleLifesciences. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigGoogleLifesciences.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigGoogleLifesciences.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_disk_size_gb: Optional[_builtins.float] = None, + copy_image: Optional[_builtins.str] = None, + debug_mode: Optional[_builtins.float] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironment']] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + location: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nfs_mount: Optional[_builtins.str] = None, + nfs_target: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + preemptible: Optional[_builtins.bool] = None, + project_id: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + ssh_daemon: Optional[_builtins.bool] = None, + ssh_image: Optional[_builtins.str] = None, + use_private_address: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None, + zones: Optional[Sequence[_builtins.str]] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if preemptible is not None: + pulumi.set(__self__, "preemptible", preemptible) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[_builtins.str]: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[_builtins.float]: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[_builtins.str]: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def preemptible(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "preemptible") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def zones(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "zones") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigGoogleLifesciencesEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigK8sPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigK8sPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigK8sPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigK8sPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigK8sPlatformEnvironment']] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"] + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigK8sPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"] + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigK8sPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigLsfPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "perJobMemLimit": + suggest = "per_job_mem_limit" + elif key == "perTaskReserve": + suggest = "per_task_reserve" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "unitForLimits": + suggest = "unit_for_limits" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigLsfPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigLsfPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigLsfPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigLsfPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + per_job_mem_limit: Optional[_builtins.bool] = None, + per_task_reserve: Optional[_builtins.bool] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + unit_for_limits: Optional[_builtins.str] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if per_job_mem_limit is not None: + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + if per_task_reserve is not None: + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if unit_for_limits is not None: + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigLsfPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "per_job_mem_limit") + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "per_task_reserve") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> Optional[_builtins.str]: + return pulumi.get(self, "unit_for_limits") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigLsfPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigMoabPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigMoabPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigMoabPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigMoabPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigMoabPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigMoabPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigMoabPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cliPath": + suggest = "cli_path" + elif key == "computeJobRole": + suggest = "compute_job_role" + elif key == "computeQueue": + suggest = "compute_queue" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "dragenQueue": + suggest = "dragen_queue" + elif key == "executionRole": + suggest = "execution_role" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "fusionSnapshots": + suggest = "fusion_snapshots" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headJobRole": + suggest = "head_job_role" + elif key == "headQueue": + suggest = "head_queue" + elif key == "logGroup": + suggest = "log_group" + elif key == "lustreId": + suggest = "lustre_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nvnmeStorageEnabled": + suggest = "nvnme_storage_enabled" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "storageType": + suggest = "storage_type" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigSeqeracomputePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigSeqeracomputePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigSeqeracomputePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cli_path: Optional[_builtins.str] = None, + compute_job_role: Optional[_builtins.str] = None, + compute_queue: Optional[_builtins.str] = None, + dragen_instance_type: Optional[_builtins.str] = None, + dragen_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironment']] = None, + execution_role: Optional[_builtins.str] = None, + forge: Optional['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatformForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + fusion_snapshots: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_job_role: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + lustre_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nvnme_storage_enabled: Optional[_builtins.bool] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + storage_type: Optional[_builtins.str] = None, + volumes: Optional[Sequence[_builtins.str]] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[_builtins.str]: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ActionLaunchComputeEnvConfigSeqeracomputePlatformForge']: + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSeqeracomputePlatformForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allocStrategy": + suggest = "alloc_strategy" + elif key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "bidPercentage": + suggest = "bid_percentage" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "dragenAmiId": + suggest = "dragen_ami_id" + elif key == "dragenEnabled": + suggest = "dragen_enabled" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "ebsAutoScale": + suggest = "ebs_auto_scale" + elif key == "ebsBlockSize": + suggest = "ebs_block_size" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "ecsConfig": + suggest = "ecs_config" + elif key == "efsCreate": + suggest = "efs_create" + elif key == "efsId": + suggest = "efs_id" + elif key == "efsMount": + suggest = "efs_mount" + elif key == "fargateHeadEnabled": + suggest = "fargate_head_enabled" + elif key == "fsxMount": + suggest = "fsx_mount" + elif key == "fsxName": + suggest = "fsx_name" + elif key == "fsxSize": + suggest = "fsx_size" + elif key == "fusionEnabled": + suggest = "fusion_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceTypes": + suggest = "instance_types" + elif key == "maxCpus": + suggest = "max_cpus" + elif key == "minCpus": + suggest = "min_cpus" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "vpcId": + suggest = "vpc_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigSeqeracomputePlatformForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigSeqeracomputePlatformForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigSeqeracomputePlatformForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alloc_strategy: Optional[_builtins.str] = None, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + bid_percentage: Optional[_builtins.float] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + dragen_ami_id: Optional[_builtins.str] = None, + dragen_enabled: Optional[_builtins.bool] = None, + dragen_instance_type: Optional[_builtins.str] = None, + ebs_auto_scale: Optional[_builtins.bool] = None, + ebs_block_size: Optional[_builtins.float] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + ecs_config: Optional[_builtins.str] = None, + efs_create: Optional[_builtins.bool] = None, + efs_id: Optional[_builtins.str] = None, + efs_mount: Optional[_builtins.str] = None, + fargate_head_enabled: Optional[_builtins.bool] = None, + fsx_mount: Optional[_builtins.str] = None, + fsx_name: Optional[_builtins.str] = None, + fsx_size: Optional[_builtins.float] = None, + fusion_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_types: Optional[Sequence[_builtins.str]] = None, + max_cpus: Optional[_builtins.float] = None, + min_cpus: Optional[_builtins.float] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnets: Optional[Sequence[_builtins.str]] = None, + type: Optional[_builtins.str] = None, + vpc_id: Optional[_builtins.str] = None): + """ + :param _builtins.str alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + :param _builtins.str type: must be one of ["SPOT", "EC2"] + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[_builtins.str]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"] + """ + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[_builtins.float]: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[_builtins.str]: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + must be one of ["SPOT", "EC2"] + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSlurmPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigSlurmPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigSlurmPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigSlurmPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigSlurmPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigSlurmPlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigSlurmPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigUgePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ActionLaunchComputeEnvConfigUgePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ActionLaunchComputeEnvConfigUgePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ActionLaunchComputeEnvConfigUgePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ActionLaunchComputeEnvConfigUgePlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence['ActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ActionLaunchComputeEnvConfigUgePlatformEnvironment']]: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ActionLaunchComputeEnvConfigUgePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnv(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "credentialsId": + suggest = "credentials_id" + elif key == "computeEnvId": + suggest = "compute_env_id" + elif key == "dateCreated": + suggest = "date_created" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "lastUsed": + suggest = "last_used" + elif key == "managedIdentityId": + suggest = "managed_identity_id" + elif key == "orgId": + suggest = "org_id" + elif key == "workspaceId": + suggest = "workspace_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnv. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnv.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnv.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + config: 'outputs.ComputeEnvComputeEnvConfig', + credentials_id: _builtins.str, + name: _builtins.str, + platform: _builtins.str, + compute_env_id: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + deleted: Optional[_builtins.bool] = None, + description: Optional[_builtins.str] = None, + labels: Optional[Sequence['outputs.ComputeEnvComputeEnvLabel']] = None, + last_updated: Optional[_builtins.str] = None, + last_used: Optional[_builtins.str] = None, + managed_identity_id: Optional[_builtins.str] = None, + message: Optional[_builtins.str] = None, + org_id: Optional[_builtins.float] = None, + primary: Optional[_builtins.bool] = None, + status: Optional[_builtins.str] = None, + workspace_id: Optional[_builtins.float] = None): + """ + :param 'ComputeEnvComputeEnvConfigArgs' config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + :param _builtins.str credentials_id: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str platform: must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + :param _builtins.str description: Requires replacement if changed. + :param _builtins.str message: Requires replacement if changed. + :param _builtins.str status: must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "platform", platform) + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if managed_identity_id is not None: + pulumi.set(__self__, "managed_identity_id", managed_identity_id) + if message is not None: + pulumi.set(__self__, "message", message) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if primary is not None: + pulumi.set(__self__, "primary", primary) + if status is not None: + pulumi.set(__self__, "status", status) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def config(self) -> 'outputs.ComputeEnvComputeEnvConfig': + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + Requires replacement if changed. + """ + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + """ + must be one of ["aws-batch", "aws-cloud", "google-lifesciences", "google-batch", "azure-batch", "k8s-platform", "eks-platform", "gke-platform", "uge-platform", "slurm-platform", "lsf-platform", "altair-platform", "moab-platform", "local-platform", "seqeracompute-platform"]; Requires replacement if changed. + """ + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter(name="managedIdentityId") + def managed_identity_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "managed_identity_id") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def primary(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "primary") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["CREATING", "AVAILABLE", "ERRORED", "INVALID"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "workspace_id") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "altairPlatform": + suggest = "altair_platform" + elif key == "awsBatch": + suggest = "aws_batch" + elif key == "awsCloud": + suggest = "aws_cloud" + elif key == "azureBatch": + suggest = "azure_batch" + elif key == "eksPlatform": + suggest = "eks_platform" + elif key == "gkePlatform": + suggest = "gke_platform" + elif key == "googleBatch": + suggest = "google_batch" + elif key == "googleLifesciences": + suggest = "google_lifesciences" + elif key == "k8sPlatform": + suggest = "k8s_platform" + elif key == "lsfPlatform": + suggest = "lsf_platform" + elif key == "moabPlatform": + suggest = "moab_platform" + elif key == "seqeracomputePlatform": + suggest = "seqeracompute_platform" + elif key == "slurmPlatform": + suggest = "slurm_platform" + elif key == "ugePlatform": + suggest = "uge_platform" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + altair_platform: Optional['outputs.ComputeEnvComputeEnvConfigAltairPlatform'] = None, + aws_batch: Optional['outputs.ComputeEnvComputeEnvConfigAwsBatch'] = None, + aws_cloud: Optional['outputs.ComputeEnvComputeEnvConfigAwsCloud'] = None, + azure_batch: Optional['outputs.ComputeEnvComputeEnvConfigAzureBatch'] = None, + eks_platform: Optional['outputs.ComputeEnvComputeEnvConfigEksPlatform'] = None, + gke_platform: Optional['outputs.ComputeEnvComputeEnvConfigGkePlatform'] = None, + google_batch: Optional['outputs.ComputeEnvComputeEnvConfigGoogleBatch'] = None, + google_lifesciences: Optional['outputs.ComputeEnvComputeEnvConfigGoogleLifesciences'] = None, + k8s_platform: Optional['outputs.ComputeEnvComputeEnvConfigK8sPlatform'] = None, + lsf_platform: Optional['outputs.ComputeEnvComputeEnvConfigLsfPlatform'] = None, + moab_platform: Optional['outputs.ComputeEnvComputeEnvConfigMoabPlatform'] = None, + seqeracompute_platform: Optional['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatform'] = None, + slurm_platform: Optional['outputs.ComputeEnvComputeEnvConfigSlurmPlatform'] = None, + uge_platform: Optional['outputs.ComputeEnvComputeEnvConfigUgePlatform'] = None): + """ + :param 'ComputeEnvComputeEnvConfigAltairPlatformArgs' altair_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAwsBatchArgs' aws_batch: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAwsCloudArgs' aws_cloud: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAzureBatchArgs' azure_batch: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigEksPlatformArgs' eks_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigGkePlatformArgs' gke_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigGoogleBatchArgs' google_batch: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigGoogleLifesciencesArgs' google_lifesciences: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigK8sPlatformArgs' k8s_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigLsfPlatformArgs' lsf_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigMoabPlatformArgs' moab_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigSeqeracomputePlatformArgs' seqeracompute_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigSlurmPlatformArgs' slurm_platform: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigUgePlatformArgs' uge_platform: Requires replacement if changed. + """ + if altair_platform is not None: + pulumi.set(__self__, "altair_platform", altair_platform) + if aws_batch is not None: + pulumi.set(__self__, "aws_batch", aws_batch) + if aws_cloud is not None: + pulumi.set(__self__, "aws_cloud", aws_cloud) + if azure_batch is not None: + pulumi.set(__self__, "azure_batch", azure_batch) + if eks_platform is not None: + pulumi.set(__self__, "eks_platform", eks_platform) + if gke_platform is not None: + pulumi.set(__self__, "gke_platform", gke_platform) + if google_batch is not None: + pulumi.set(__self__, "google_batch", google_batch) + if google_lifesciences is not None: + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + if k8s_platform is not None: + pulumi.set(__self__, "k8s_platform", k8s_platform) + if lsf_platform is not None: + pulumi.set(__self__, "lsf_platform", lsf_platform) + if moab_platform is not None: + pulumi.set(__self__, "moab_platform", moab_platform) + if seqeracompute_platform is not None: + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + if slurm_platform is not None: + pulumi.set(__self__, "slurm_platform", slurm_platform) + if uge_platform is not None: + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAltairPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "altair_platform") + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAwsBatch']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "aws_batch") + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAwsCloud']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "aws_cloud") + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAzureBatch']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "azure_batch") + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigEksPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "eks_platform") + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigGkePlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gke_platform") + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> Optional['outputs.ComputeEnvComputeEnvConfigGoogleBatch']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "google_batch") + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> Optional['outputs.ComputeEnvComputeEnvConfigGoogleLifesciences']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "google_lifesciences") + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigK8sPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "k8s_platform") + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigLsfPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lsf_platform") + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigMoabPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "moab_platform") + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "seqeracompute_platform") + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigSlurmPlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "slurm_platform") + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> Optional['outputs.ComputeEnvComputeEnvConfigUgePlatform']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "uge_platform") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAltairPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAltairPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAltairPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAltairPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAltairPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAltairPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAltairPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cliPath": + suggest = "cli_path" + elif key == "computeJobRole": + suggest = "compute_job_role" + elif key == "computeQueue": + suggest = "compute_queue" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "dragenQueue": + suggest = "dragen_queue" + elif key == "executionRole": + suggest = "execution_role" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "fusionSnapshots": + suggest = "fusion_snapshots" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headJobRole": + suggest = "head_job_role" + elif key == "headQueue": + suggest = "head_queue" + elif key == "logGroup": + suggest = "log_group" + elif key == "lustreId": + suggest = "lustre_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nvnmeStorageEnabled": + suggest = "nvnme_storage_enabled" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "storageType": + suggest = "storage_type" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAwsBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAwsBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAwsBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cli_path: Optional[_builtins.str] = None, + compute_job_role: Optional[_builtins.str] = None, + compute_queue: Optional[_builtins.str] = None, + dragen_instance_type: Optional[_builtins.str] = None, + dragen_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAwsBatchEnvironment']] = None, + execution_role: Optional[_builtins.str] = None, + forge: Optional['outputs.ComputeEnvComputeEnvConfigAwsBatchForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + fusion_snapshots: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_job_role: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + lustre_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nvnme_storage_enabled: Optional[_builtins.bool] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + storage_type: Optional[_builtins.str] = None, + volumes: Optional[Sequence[_builtins.str]] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cli_path: Requires replacement if changed. + :param _builtins.str compute_job_role: Requires replacement if changed. + :param _builtins.str compute_queue: Requires replacement if changed. + :param _builtins.str dragen_instance_type: Requires replacement if changed. + :param _builtins.str dragen_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str execution_role: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAwsBatchForgeArgs' forge: Not Null; Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.bool fusion_snapshots: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_job_role: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str log_group: Requires replacement if changed. + :param _builtins.str lustre_id: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.bool nvnme_storage_enabled: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: Not Null; Requires replacement if changed. + :param _builtins.str storage_type: Requires replacement if changed. + :param Sequence[_builtins.str] volumes: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAwsBatchEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAwsBatchForge']: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsBatchForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allocStrategy": + suggest = "alloc_strategy" + elif key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "bidPercentage": + suggest = "bid_percentage" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "dragenAmiId": + suggest = "dragen_ami_id" + elif key == "dragenEnabled": + suggest = "dragen_enabled" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "ebsAutoScale": + suggest = "ebs_auto_scale" + elif key == "ebsBlockSize": + suggest = "ebs_block_size" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "ecsConfig": + suggest = "ecs_config" + elif key == "efsCreate": + suggest = "efs_create" + elif key == "efsId": + suggest = "efs_id" + elif key == "efsMount": + suggest = "efs_mount" + elif key == "fargateHeadEnabled": + suggest = "fargate_head_enabled" + elif key == "fsxMount": + suggest = "fsx_mount" + elif key == "fsxName": + suggest = "fsx_name" + elif key == "fsxSize": + suggest = "fsx_size" + elif key == "fusionEnabled": + suggest = "fusion_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceTypes": + suggest = "instance_types" + elif key == "maxCpus": + suggest = "max_cpus" + elif key == "minCpus": + suggest = "min_cpus" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "vpcId": + suggest = "vpc_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAwsBatchForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAwsBatchForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAwsBatchForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alloc_strategy: Optional[_builtins.str] = None, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + bid_percentage: Optional[_builtins.float] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + dragen_ami_id: Optional[_builtins.str] = None, + dragen_enabled: Optional[_builtins.bool] = None, + dragen_instance_type: Optional[_builtins.str] = None, + ebs_auto_scale: Optional[_builtins.bool] = None, + ebs_block_size: Optional[_builtins.float] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + ecs_config: Optional[_builtins.str] = None, + efs_create: Optional[_builtins.bool] = None, + efs_id: Optional[_builtins.str] = None, + efs_mount: Optional[_builtins.str] = None, + fargate_head_enabled: Optional[_builtins.bool] = None, + fsx_mount: Optional[_builtins.str] = None, + fsx_name: Optional[_builtins.str] = None, + fsx_size: Optional[_builtins.float] = None, + fusion_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_types: Optional[Sequence[_builtins.str]] = None, + max_cpus: Optional[_builtins.float] = None, + min_cpus: Optional[_builtins.float] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnets: Optional[Sequence[_builtins.str]] = None, + type: Optional[_builtins.str] = None, + vpc_id: Optional[_builtins.str] = None): + """ + :param _builtins.str alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + :param Sequence[_builtins.str] allow_buckets: Requires replacement if changed. + :param _builtins.bool arm64_enabled: Requires replacement if changed. + :param _builtins.float bid_percentage: Requires replacement if changed. + :param _builtins.bool dispose_on_deletion: Requires replacement if changed. + :param _builtins.str dragen_ami_id: Requires replacement if changed. + :param _builtins.bool dragen_enabled: Requires replacement if changed. + :param _builtins.str dragen_instance_type: Requires replacement if changed. + :param _builtins.bool ebs_auto_scale: Requires replacement if changed. + :param _builtins.float ebs_block_size: Requires replacement if changed. + :param _builtins.float ebs_boot_size: Requires replacement if changed. + :param _builtins.str ec2_key_pair: Requires replacement if changed. + :param _builtins.str ecs_config: Requires replacement if changed. + :param _builtins.bool efs_create: Requires replacement if changed. + :param _builtins.str efs_id: Requires replacement if changed. + :param _builtins.str efs_mount: Requires replacement if changed. + :param _builtins.bool fargate_head_enabled: Requires replacement if changed. + :param _builtins.str fsx_mount: Requires replacement if changed. + :param _builtins.str fsx_name: Requires replacement if changed. + :param _builtins.float fsx_size: Requires replacement if changed. + :param _builtins.bool fusion_enabled: Requires replacement if changed. + :param _builtins.bool gpu_enabled: Requires replacement if changed. + :param _builtins.str image_id: Requires replacement if changed. + :param Sequence[_builtins.str] instance_types: Requires replacement if changed. + :param _builtins.float max_cpus: Not Null; Requires replacement if changed. + :param _builtins.float min_cpus: Not Null; Requires replacement if changed. + :param Sequence[_builtins.str] security_groups: Requires replacement if changed. + :param Sequence[_builtins.str] subnets: Requires replacement if changed. + :param _builtins.str type: Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + :param _builtins.str vpc_id: Requires replacement if changed. + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[_builtins.str]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsCloud(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceProfileArn": + suggest = "instance_profile_arn" + elif key == "instanceType": + suggest = "instance_type" + elif key == "logGroup": + suggest = "log_group" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "subnetId": + suggest = "subnet_id" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAwsCloud. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAwsCloud.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAwsCloud.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAwsCloudEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_profile_arn: Optional[_builtins.str] = None, + instance_type: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnet_id: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param Sequence[_builtins.str] allow_buckets: Requires replacement if changed. + :param _builtins.bool arm64_enabled: Requires replacement if changed. + :param _builtins.float ebs_boot_size: Requires replacement if changed. + :param _builtins.str ec2_key_pair: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.bool gpu_enabled: Requires replacement if changed. + :param _builtins.str image_id: Requires replacement if changed. + :param _builtins.str instance_profile_arn: Requires replacement if changed. + :param _builtins.str instance_type: Requires replacement if changed. + :param _builtins.str log_group: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: Not Null; Requires replacement if changed. + :param Sequence[_builtins.str] security_groups: Requires replacement if changed. + :param _builtins.str subnet_id: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_profile_arn is not None: + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + if instance_type is not None: + pulumi.set(__self__, "instance_type", instance_type) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnet_id is not None: + pulumi.set(__self__, "subnet_id", subnet_id) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAwsCloudEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_profile_arn") + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_type") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnet_id") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAwsCloudEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAzureBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "autoPoolMode": + suggest = "auto_pool_mode" + elif key == "deleteJobsOnCompletion": + suggest = "delete_jobs_on_completion" + elif key == "deletePoolsOnCompletion": + suggest = "delete_pools_on_completion" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headPool": + suggest = "head_pool" + elif key == "managedIdentityClientId": + suggest = "managed_identity_client_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "tokenDuration": + suggest = "token_duration" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAzureBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAzureBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAzureBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auto_pool_mode: Optional[_builtins.bool] = None, + delete_jobs_on_completion: Optional[_builtins.str] = None, + delete_pools_on_completion: Optional[_builtins.bool] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAzureBatchEnvironment']] = None, + forge: Optional['outputs.ComputeEnvComputeEnvConfigAzureBatchForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_pool: Optional[_builtins.str] = None, + managed_identity_client_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + token_duration: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.bool auto_pool_mode: Requires replacement if changed. + :param _builtins.str delete_jobs_on_completion: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param _builtins.bool delete_pools_on_completion: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigAzureBatchForgeArgs' forge: Not Null; Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.str head_pool: Requires replacement if changed. + :param _builtins.str managed_identity_client_id: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: Not Null; Requires replacement if changed. + :param _builtins.str token_duration: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if auto_pool_mode is not None: + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + if delete_jobs_on_completion is not None: + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + if delete_pools_on_completion is not None: + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_pool is not None: + pulumi.set(__self__, "head_pool", head_pool) + if managed_identity_client_id is not None: + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if token_duration is not None: + pulumi.set(__self__, "token_duration", token_duration) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "auto_pool_mode") + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "delete_jobs_on_completion") + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "delete_pools_on_completion") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigAzureBatchEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ComputeEnvComputeEnvConfigAzureBatchForge']: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pool") + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "managed_identity_client_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "token_duration") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAzureBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigAzureBatchForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "autoScale": + suggest = "auto_scale" + elif key == "containerRegIds": + suggest = "container_reg_ids" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "vmCount": + suggest = "vm_count" + elif key == "vmType": + suggest = "vm_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigAzureBatchForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigAzureBatchForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigAzureBatchForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auto_scale: Optional[_builtins.bool] = None, + container_reg_ids: Optional[Sequence[_builtins.str]] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + vm_count: Optional[_builtins.float] = None, + vm_type: Optional[_builtins.str] = None): + """ + :param _builtins.bool auto_scale: Requires replacement if changed. + :param Sequence[_builtins.str] container_reg_ids: Requires replacement if changed. + :param _builtins.bool dispose_on_deletion: Requires replacement if changed. + :param _builtins.float vm_count: Not Null; Requires replacement if changed. + :param _builtins.str vm_type: Requires replacement if changed. + """ + if auto_scale is not None: + pulumi.set(__self__, "auto_scale", auto_scale) + if container_reg_ids is not None: + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if vm_count is not None: + pulumi.set(__self__, "vm_count", vm_count) + if vm_type is not None: + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "auto_scale") + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "container_reg_ids") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "vm_count") + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vm_type") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigEksPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterName": + suggest = "cluster_name" + elif key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigEksPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigEksPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigEksPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_name: Optional[_builtins.str] = None, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigEksPlatformEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cluster_name: The AWS EKS cluster name. Not Null; Requires replacement if changed. + :param _builtins.str compute_service_account: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_pod_spec: Requires replacement if changed. + :param _builtins.str head_service_account: Not Null; Requires replacement if changed. + :param _builtins.str namespace: Not Null; Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: AWS region. Not Null; Requires replacement if changed. + :param _builtins.str server: Not Null; Requires replacement if changed. + :param _builtins.str service_pod_spec: Requires replacement if changed. + :param _builtins.str ssl_cert: Not Null; Requires replacement if changed. + :param _builtins.str storage_claim_name: Not Null; Requires replacement if changed. + :param _builtins.str storage_mount_path: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[_builtins.str]: + """ + The AWS EKS cluster name. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigEksPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + AWS region. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigEksPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGkePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clusterName": + suggest = "cluster_name" + elif key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigGkePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigGkePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigGkePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cluster_name: Optional[_builtins.str] = None, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGkePlatformEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cluster_name: The GKE cluster name. Not Null; Requires replacement if changed. + :param _builtins.str compute_service_account: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_pod_spec: Requires replacement if changed. + :param _builtins.str head_service_account: Not Null; Requires replacement if changed. + :param _builtins.str namespace: Not Null; Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + :param _builtins.str server: Not Null; Requires replacement if changed. + :param _builtins.str service_pod_spec: Requires replacement if changed. + :param _builtins.str ssl_cert: Not Null; Requires replacement if changed. + :param _builtins.str storage_claim_name: Not Null; Requires replacement if changed. + :param _builtins.str storage_mount_path: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[_builtins.str]: + """ + The GKE cluster name. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGkePlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + The GKE cluster region - or - zone. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGkePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGoogleBatch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootDiskSizeGb": + suggest = "boot_disk_size_gb" + elif key == "computeJobsInstanceTemplate": + suggest = "compute_jobs_instance_template" + elif key == "copyImage": + suggest = "copy_image" + elif key == "cpuPlatform": + suggest = "cpu_platform" + elif key == "debugMode": + suggest = "debug_mode" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobInstanceTemplate": + suggest = "head_job_instance_template" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "machineType": + suggest = "machine_type" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nfsMount": + suggest = "nfs_mount" + elif key == "nfsTarget": + suggest = "nfs_target" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "projectId": + suggest = "project_id" + elif key == "serviceAccount": + suggest = "service_account" + elif key == "sshDaemon": + suggest = "ssh_daemon" + elif key == "sshImage": + suggest = "ssh_image" + elif key == "usePrivateAddress": + suggest = "use_private_address" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigGoogleBatch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigGoogleBatch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigGoogleBatch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_disk_size_gb: Optional[_builtins.float] = None, + compute_jobs_instance_template: Optional[_builtins.str] = None, + copy_image: Optional[_builtins.str] = None, + cpu_platform: Optional[_builtins.str] = None, + debug_mode: Optional[_builtins.float] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGoogleBatchEnvironment']] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_instance_template: Optional[_builtins.str] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + location: Optional[_builtins.str] = None, + machine_type: Optional[_builtins.str] = None, + network: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nfs_mount: Optional[_builtins.str] = None, + nfs_target: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + project_id: Optional[_builtins.str] = None, + service_account: Optional[_builtins.str] = None, + spot: Optional[_builtins.bool] = None, + ssh_daemon: Optional[_builtins.bool] = None, + ssh_image: Optional[_builtins.str] = None, + subnetwork: Optional[_builtins.str] = None, + use_private_address: Optional[_builtins.bool] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.float boot_disk_size_gb: Requires replacement if changed. + :param _builtins.str compute_jobs_instance_template: Requires replacement if changed. + :param _builtins.str copy_image: Requires replacement if changed. + :param _builtins.str cpu_platform: Requires replacement if changed. + :param _builtins.float debug_mode: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.str head_job_instance_template: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param Mapping[str, _builtins.str] labels: Requires replacement if changed. + :param _builtins.str location: Requires replacement if changed. + :param _builtins.str machine_type: Requires replacement if changed. + :param _builtins.str network: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str nfs_mount: Requires replacement if changed. + :param _builtins.str nfs_target: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str project_id: Requires replacement if changed. + :param _builtins.str service_account: Requires replacement if changed. + :param _builtins.bool spot: Requires replacement if changed. + :param _builtins.bool ssh_daemon: Requires replacement if changed. + :param _builtins.str ssh_image: Requires replacement if changed. + :param _builtins.str subnetwork: Requires replacement if changed. + :param _builtins.bool use_private_address: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if compute_jobs_instance_template is not None: + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if cpu_platform is not None: + pulumi.set(__self__, "cpu_platform", cpu_platform) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_instance_template is not None: + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if network is not None: + pulumi.set(__self__, "network", network) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if subnetwork is not None: + pulumi.set(__self__, "subnetwork", subnetwork) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_jobs_instance_template") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cpu_platform") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGoogleBatchEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_instance_template") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "machine_type") + + @_builtins.property + @pulumi.getter + def network(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "network") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_account") + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnetwork") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGoogleBatchEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGoogleLifesciences(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootDiskSizeGb": + suggest = "boot_disk_size_gb" + elif key == "copyImage": + suggest = "copy_image" + elif key == "debugMode": + suggest = "debug_mode" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nfsMount": + suggest = "nfs_mount" + elif key == "nfsTarget": + suggest = "nfs_target" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "projectId": + suggest = "project_id" + elif key == "sshDaemon": + suggest = "ssh_daemon" + elif key == "sshImage": + suggest = "ssh_image" + elif key == "usePrivateAddress": + suggest = "use_private_address" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigGoogleLifesciences. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigGoogleLifesciences.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigGoogleLifesciences.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_disk_size_gb: Optional[_builtins.float] = None, + copy_image: Optional[_builtins.str] = None, + debug_mode: Optional[_builtins.float] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironment']] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + labels: Optional[Mapping[str, _builtins.str]] = None, + location: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nfs_mount: Optional[_builtins.str] = None, + nfs_target: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + preemptible: Optional[_builtins.bool] = None, + project_id: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + ssh_daemon: Optional[_builtins.bool] = None, + ssh_image: Optional[_builtins.str] = None, + use_private_address: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None, + zones: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.float boot_disk_size_gb: Requires replacement if changed. + :param _builtins.str copy_image: Requires replacement if changed. + :param _builtins.float debug_mode: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param Mapping[str, _builtins.str] labels: Requires replacement if changed. + :param _builtins.str location: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str nfs_mount: Requires replacement if changed. + :param _builtins.str nfs_target: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool preemptible: Requires replacement if changed. + :param _builtins.str project_id: Requires replacement if changed. + :param _builtins.str region: Requires replacement if changed. + :param _builtins.bool ssh_daemon: Requires replacement if changed. + :param _builtins.str ssh_image: Requires replacement if changed. + :param _builtins.bool use_private_address: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + :param Sequence[_builtins.str] zones: Requires replacement if changed. + """ + if boot_disk_size_gb is not None: + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + if copy_image is not None: + pulumi.set(__self__, "copy_image", copy_image) + if debug_mode is not None: + pulumi.set(__self__, "debug_mode", debug_mode) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if location is not None: + pulumi.set(__self__, "location", location) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nfs_mount is not None: + pulumi.set(__self__, "nfs_mount", nfs_mount) + if nfs_target is not None: + pulumi.set(__self__, "nfs_target", nfs_target) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if preemptible is not None: + pulumi.set(__self__, "preemptible", preemptible) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if ssh_daemon is not None: + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + if ssh_image is not None: + pulumi.set(__self__, "ssh_image", ssh_image) + if use_private_address is not None: + pulumi.set(__self__, "use_private_address", use_private_address) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, _builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def preemptible(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "preemptible") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def zones(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "zones") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigGoogleLifesciencesEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigK8sPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeServiceAccount": + suggest = "compute_service_account" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headPodSpec": + suggest = "head_pod_spec" + elif key == "headServiceAccount": + suggest = "head_service_account" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "podCleanup": + suggest = "pod_cleanup" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "servicePodSpec": + suggest = "service_pod_spec" + elif key == "sslCert": + suggest = "ssl_cert" + elif key == "storageClaimName": + suggest = "storage_claim_name" + elif key == "storageMountPath": + suggest = "storage_mount_path" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigK8sPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigK8sPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigK8sPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_service_account: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigK8sPlatformEnvironment']] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_pod_spec: Optional[_builtins.str] = None, + head_service_account: Optional[_builtins.str] = None, + namespace: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + pod_cleanup: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + server: Optional[_builtins.str] = None, + service_pod_spec: Optional[_builtins.str] = None, + ssl_cert: Optional[_builtins.str] = None, + storage_claim_name: Optional[_builtins.str] = None, + storage_mount_path: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_service_account: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_pod_spec: Requires replacement if changed. + :param _builtins.str head_service_account: Not Null; Requires replacement if changed. + :param _builtins.str namespace: Not Null; Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.str pod_cleanup: must be one of ["on_success", "always", "never"]; Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str server: Not Null; Requires replacement if changed. + :param _builtins.str service_pod_spec: Requires replacement if changed. + :param _builtins.str ssl_cert: Not Null; Requires replacement if changed. + :param _builtins.str storage_claim_name: Not Null; Requires replacement if changed. + :param _builtins.str storage_mount_path: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if compute_service_account is not None: + pulumi.set(__self__, "compute_service_account", compute_service_account) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_pod_spec is not None: + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + if head_service_account is not None: + pulumi.set(__self__, "head_service_account", head_service_account) + if namespace is not None: + pulumi.set(__self__, "namespace", namespace) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if pod_cleanup is not None: + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if server is not None: + pulumi.set(__self__, "server", server) + if service_pod_spec is not None: + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + if ssl_cert is not None: + pulumi.set(__self__, "ssl_cert", ssl_cert) + if storage_claim_name is not None: + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + if storage_mount_path is not None: + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigK8sPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> Optional[_builtins.str]: + """ + must be one of ["on_success", "always", "never"]; Requires replacement if changed. + """ + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def server(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigK8sPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigLsfPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "perJobMemLimit": + suggest = "per_job_mem_limit" + elif key == "perTaskReserve": + suggest = "per_task_reserve" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "unitForLimits": + suggest = "unit_for_limits" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigLsfPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigLsfPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigLsfPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigLsfPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + per_job_mem_limit: Optional[_builtins.bool] = None, + per_task_reserve: Optional[_builtins.bool] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + unit_for_limits: Optional[_builtins.str] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.bool per_job_mem_limit: Requires replacement if changed. + :param _builtins.bool per_task_reserve: Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str unit_for_limits: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if per_job_mem_limit is not None: + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + if per_task_reserve is not None: + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if unit_for_limits is not None: + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigLsfPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "per_job_mem_limit") + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "per_task_reserve") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "unit_for_limits") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigLsfPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigMoabPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigMoabPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigMoabPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigMoabPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigMoabPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigMoabPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigMoabPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cliPath": + suggest = "cli_path" + elif key == "computeJobRole": + suggest = "compute_job_role" + elif key == "computeQueue": + suggest = "compute_queue" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "dragenQueue": + suggest = "dragen_queue" + elif key == "executionRole": + suggest = "execution_role" + elif key == "fusion2Enabled": + suggest = "fusion2_enabled" + elif key == "fusionSnapshots": + suggest = "fusion_snapshots" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "headJobRole": + suggest = "head_job_role" + elif key == "headQueue": + suggest = "head_queue" + elif key == "logGroup": + suggest = "log_group" + elif key == "lustreId": + suggest = "lustre_id" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "nvnmeStorageEnabled": + suggest = "nvnme_storage_enabled" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "storageType": + suggest = "storage_type" + elif key == "waveEnabled": + suggest = "wave_enabled" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigSeqeracomputePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigSeqeracomputePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigSeqeracomputePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cli_path: Optional[_builtins.str] = None, + compute_job_role: Optional[_builtins.str] = None, + compute_queue: Optional[_builtins.str] = None, + dragen_instance_type: Optional[_builtins.str] = None, + dragen_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironment']] = None, + execution_role: Optional[_builtins.str] = None, + forge: Optional['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatformForge'] = None, + fusion2_enabled: Optional[_builtins.bool] = None, + fusion_snapshots: Optional[_builtins.bool] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + head_job_role: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + log_group: Optional[_builtins.str] = None, + lustre_id: Optional[_builtins.str] = None, + nextflow_config: Optional[_builtins.str] = None, + nvnme_storage_enabled: Optional[_builtins.bool] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + storage_type: Optional[_builtins.str] = None, + volumes: Optional[Sequence[_builtins.str]] = None, + wave_enabled: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str cli_path: Requires replacement if changed. + :param _builtins.str compute_job_role: Requires replacement if changed. + :param _builtins.str compute_queue: Requires replacement if changed. + :param _builtins.str dragen_instance_type: Requires replacement if changed. + :param _builtins.str dragen_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str execution_role: Requires replacement if changed. + :param 'ComputeEnvComputeEnvConfigSeqeracomputePlatformForgeArgs' forge: Not Null; Requires replacement if changed. + :param _builtins.bool fusion2_enabled: Requires replacement if changed. + :param _builtins.bool fusion_snapshots: Requires replacement if changed. + :param _builtins.float head_job_cpus: Requires replacement if changed. + :param _builtins.float head_job_memory_mb: Requires replacement if changed. + :param _builtins.str head_job_role: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str log_group: Requires replacement if changed. + :param _builtins.str lustre_id: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.bool nvnme_storage_enabled: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.str region: Not Null; Requires replacement if changed. + :param _builtins.str storage_type: Requires replacement if changed. + :param Sequence[_builtins.str] volumes: Requires replacement if changed. + :param _builtins.bool wave_enabled: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Requires replacement if changed. + """ + if cli_path is not None: + pulumi.set(__self__, "cli_path", cli_path) + if compute_job_role is not None: + pulumi.set(__self__, "compute_job_role", compute_job_role) + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if dragen_queue is not None: + pulumi.set(__self__, "dragen_queue", dragen_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if execution_role is not None: + pulumi.set(__self__, "execution_role", execution_role) + if forge is not None: + pulumi.set(__self__, "forge", forge) + if fusion2_enabled is not None: + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + if fusion_snapshots is not None: + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if head_job_role is not None: + pulumi.set(__self__, "head_job_role", head_job_role) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if log_group is not None: + pulumi.set(__self__, "log_group", log_group) + if lustre_id is not None: + pulumi.set(__self__, "lustre_id", lustre_id) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if nvnme_storage_enabled is not None: + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if region is not None: + pulumi.set(__self__, "region", region) + if storage_type is not None: + pulumi.set(__self__, "storage_type", storage_type) + if volumes is not None: + pulumi.set(__self__, "volumes", volumes) + if wave_enabled is not None: + pulumi.set(__self__, "wave_enabled", wave_enabled) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> Optional['outputs.ComputeEnvComputeEnvConfigSeqeracomputePlatformForge']: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSeqeracomputePlatformForge(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allocStrategy": + suggest = "alloc_strategy" + elif key == "allowBuckets": + suggest = "allow_buckets" + elif key == "arm64Enabled": + suggest = "arm64_enabled" + elif key == "bidPercentage": + suggest = "bid_percentage" + elif key == "disposeOnDeletion": + suggest = "dispose_on_deletion" + elif key == "dragenAmiId": + suggest = "dragen_ami_id" + elif key == "dragenEnabled": + suggest = "dragen_enabled" + elif key == "dragenInstanceType": + suggest = "dragen_instance_type" + elif key == "ebsAutoScale": + suggest = "ebs_auto_scale" + elif key == "ebsBlockSize": + suggest = "ebs_block_size" + elif key == "ebsBootSize": + suggest = "ebs_boot_size" + elif key == "ec2KeyPair": + suggest = "ec2_key_pair" + elif key == "ecsConfig": + suggest = "ecs_config" + elif key == "efsCreate": + suggest = "efs_create" + elif key == "efsId": + suggest = "efs_id" + elif key == "efsMount": + suggest = "efs_mount" + elif key == "fargateHeadEnabled": + suggest = "fargate_head_enabled" + elif key == "fsxMount": + suggest = "fsx_mount" + elif key == "fsxName": + suggest = "fsx_name" + elif key == "fsxSize": + suggest = "fsx_size" + elif key == "fusionEnabled": + suggest = "fusion_enabled" + elif key == "gpuEnabled": + suggest = "gpu_enabled" + elif key == "imageId": + suggest = "image_id" + elif key == "instanceTypes": + suggest = "instance_types" + elif key == "maxCpus": + suggest = "max_cpus" + elif key == "minCpus": + suggest = "min_cpus" + elif key == "securityGroups": + suggest = "security_groups" + elif key == "vpcId": + suggest = "vpc_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigSeqeracomputePlatformForge. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigSeqeracomputePlatformForge.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigSeqeracomputePlatformForge.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alloc_strategy: Optional[_builtins.str] = None, + allow_buckets: Optional[Sequence[_builtins.str]] = None, + arm64_enabled: Optional[_builtins.bool] = None, + bid_percentage: Optional[_builtins.float] = None, + dispose_on_deletion: Optional[_builtins.bool] = None, + dragen_ami_id: Optional[_builtins.str] = None, + dragen_enabled: Optional[_builtins.bool] = None, + dragen_instance_type: Optional[_builtins.str] = None, + ebs_auto_scale: Optional[_builtins.bool] = None, + ebs_block_size: Optional[_builtins.float] = None, + ebs_boot_size: Optional[_builtins.float] = None, + ec2_key_pair: Optional[_builtins.str] = None, + ecs_config: Optional[_builtins.str] = None, + efs_create: Optional[_builtins.bool] = None, + efs_id: Optional[_builtins.str] = None, + efs_mount: Optional[_builtins.str] = None, + fargate_head_enabled: Optional[_builtins.bool] = None, + fsx_mount: Optional[_builtins.str] = None, + fsx_name: Optional[_builtins.str] = None, + fsx_size: Optional[_builtins.float] = None, + fusion_enabled: Optional[_builtins.bool] = None, + gpu_enabled: Optional[_builtins.bool] = None, + image_id: Optional[_builtins.str] = None, + instance_types: Optional[Sequence[_builtins.str]] = None, + max_cpus: Optional[_builtins.float] = None, + min_cpus: Optional[_builtins.float] = None, + security_groups: Optional[Sequence[_builtins.str]] = None, + subnets: Optional[Sequence[_builtins.str]] = None, + type: Optional[_builtins.str] = None, + vpc_id: Optional[_builtins.str] = None): + """ + :param _builtins.str alloc_strategy: must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + :param Sequence[_builtins.str] allow_buckets: Requires replacement if changed. + :param _builtins.bool arm64_enabled: Requires replacement if changed. + :param _builtins.float bid_percentage: Requires replacement if changed. + :param _builtins.bool dispose_on_deletion: Requires replacement if changed. + :param _builtins.str dragen_ami_id: Requires replacement if changed. + :param _builtins.bool dragen_enabled: Requires replacement if changed. + :param _builtins.str dragen_instance_type: Requires replacement if changed. + :param _builtins.bool ebs_auto_scale: Requires replacement if changed. + :param _builtins.float ebs_block_size: Requires replacement if changed. + :param _builtins.float ebs_boot_size: Requires replacement if changed. + :param _builtins.str ec2_key_pair: Requires replacement if changed. + :param _builtins.str ecs_config: Requires replacement if changed. + :param _builtins.bool efs_create: Requires replacement if changed. + :param _builtins.str efs_id: Requires replacement if changed. + :param _builtins.str efs_mount: Requires replacement if changed. + :param _builtins.bool fargate_head_enabled: Requires replacement if changed. + :param _builtins.str fsx_mount: Requires replacement if changed. + :param _builtins.str fsx_name: Requires replacement if changed. + :param _builtins.float fsx_size: Requires replacement if changed. + :param _builtins.bool fusion_enabled: Requires replacement if changed. + :param _builtins.bool gpu_enabled: Requires replacement if changed. + :param _builtins.str image_id: Requires replacement if changed. + :param Sequence[_builtins.str] instance_types: Requires replacement if changed. + :param _builtins.float max_cpus: Not Null; Requires replacement if changed. + :param _builtins.float min_cpus: Not Null; Requires replacement if changed. + :param Sequence[_builtins.str] security_groups: Requires replacement if changed. + :param Sequence[_builtins.str] subnets: Requires replacement if changed. + :param _builtins.str type: Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + :param _builtins.str vpc_id: Requires replacement if changed. + """ + if alloc_strategy is not None: + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + if allow_buckets is not None: + pulumi.set(__self__, "allow_buckets", allow_buckets) + if arm64_enabled is not None: + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + if bid_percentage is not None: + pulumi.set(__self__, "bid_percentage", bid_percentage) + if dispose_on_deletion is not None: + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + if dragen_ami_id is not None: + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + if dragen_enabled is not None: + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + if dragen_instance_type is not None: + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + if ebs_auto_scale is not None: + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + if ebs_block_size is not None: + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + if ebs_boot_size is not None: + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + if ec2_key_pair is not None: + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + if ecs_config is not None: + pulumi.set(__self__, "ecs_config", ecs_config) + if efs_create is not None: + pulumi.set(__self__, "efs_create", efs_create) + if efs_id is not None: + pulumi.set(__self__, "efs_id", efs_id) + if efs_mount is not None: + pulumi.set(__self__, "efs_mount", efs_mount) + if fargate_head_enabled is not None: + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + if fsx_mount is not None: + pulumi.set(__self__, "fsx_mount", fsx_mount) + if fsx_name is not None: + pulumi.set(__self__, "fsx_name", fsx_name) + if fsx_size is not None: + pulumi.set(__self__, "fsx_size", fsx_size) + if fusion_enabled is not None: + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + if gpu_enabled is not None: + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if instance_types is not None: + pulumi.set(__self__, "instance_types", instance_types) + if max_cpus is not None: + pulumi.set(__self__, "max_cpus", max_cpus) + if min_cpus is not None: + pulumi.set(__self__, "min_cpus", min_cpus) + if security_groups is not None: + pulumi.set(__self__, "security_groups", security_groups) + if subnets is not None: + pulumi.set(__self__, "subnets", subnets) + if type is not None: + pulumi.set(__self__, "type", type) + if vpc_id is not None: + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> Optional[_builtins.str]: + """ + must be one of ["BEST_FIT", "BEST_FIT_PROGRESSIVE", "SPOT_CAPACITY_OPTIMIZED", "SPOT_PRICE_CAPACITY_OPTIMIZED"]; Requires replacement if changed. + """ + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> Optional[_builtins.float]: + """ + Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + Not Null; must be one of ["SPOT", "EC2"]; Requires replacement if changed. + """ + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSlurmPlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigSlurmPlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigSlurmPlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigSlurmPlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigSlurmPlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigSlurmPlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigSlurmPlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigUgePlatform(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeQueue": + suggest = "compute_queue" + elif key == "headJobOptions": + suggest = "head_job_options" + elif key == "headQueue": + suggest = "head_queue" + elif key == "hostName": + suggest = "host_name" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "maxQueueSize": + suggest = "max_queue_size" + elif key == "nextflowConfig": + suggest = "nextflow_config" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "propagateHeadJobOptions": + suggest = "propagate_head_job_options" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvConfigUgePlatform. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvConfigUgePlatform.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvConfigUgePlatform.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_queue: Optional[_builtins.str] = None, + environments: Optional[Sequence['outputs.ComputeEnvComputeEnvConfigUgePlatformEnvironment']] = None, + head_job_options: Optional[_builtins.str] = None, + head_queue: Optional[_builtins.str] = None, + host_name: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + max_queue_size: Optional[_builtins.float] = None, + nextflow_config: Optional[_builtins.str] = None, + port: Optional[_builtins.float] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + propagate_head_job_options: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str compute_queue: Requires replacement if changed. + :param Sequence['ComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment. Requires replacement if changed. + :param _builtins.str head_job_options: Requires replacement if changed. + :param _builtins.str head_queue: Requires replacement if changed. + :param _builtins.str host_name: Requires replacement if changed. + :param _builtins.str launch_dir: Requires replacement if changed. + :param _builtins.float max_queue_size: Requires replacement if changed. + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters. Requires replacement if changed. + :param _builtins.float port: Requires replacement if changed. + :param _builtins.str post_run_script: Shell script to execute after workflow completes. Requires replacement if changed. + :param _builtins.str pre_run_script: Shell script to execute before workflow starts. Requires replacement if changed. + :param _builtins.bool propagate_head_job_options: Requires replacement if changed. + :param _builtins.str user_name: Requires replacement if changed. + :param _builtins.str work_dir: Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + if compute_queue is not None: + pulumi.set(__self__, "compute_queue", compute_queue) + if environments is not None: + pulumi.set(__self__, "environments", environments) + if head_job_options is not None: + pulumi.set(__self__, "head_job_options", head_job_options) + if head_queue is not None: + pulumi.set(__self__, "head_queue", head_queue) + if host_name is not None: + pulumi.set(__self__, "host_name", host_name) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if max_queue_size is not None: + pulumi.set(__self__, "max_queue_size", max_queue_size) + if nextflow_config is not None: + pulumi.set(__self__, "nextflow_config", nextflow_config) + if port is not None: + pulumi.set(__self__, "port", port) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if propagate_head_job_options is not None: + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Optional[Sequence['outputs.ComputeEnvComputeEnvConfigUgePlatformEnvironment']]: + """ + Array of environment variables for the compute environment. Requires replacement if changed. + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> Optional[_builtins.str]: + """ + Nextflow configuration settings and parameters. Requires replacement if changed. + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute after workflow completes. Requires replacement if changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Shell script to execute before workflow starts. Requires replacement if changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + """ + Working directory path for workflow execution. Not Null; Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class ComputeEnvComputeEnvConfigUgePlatformEnvironment(dict): + def __init__(__self__, *, + compute: Optional[_builtins.bool] = None, + head: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.bool compute: Requires replacement if changed. + :param _builtins.bool head: Requires replacement if changed. + :param _builtins.str name: Requires replacement if changed. + :param _builtins.str value: Requires replacement if changed. + """ + if compute is not None: + pulumi.set(__self__, "compute", compute) + if head is not None: + pulumi.set(__self__, "head", head) + if name is not None: + pulumi.set(__self__, "name", name) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> Optional[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class ComputeEnvComputeEnvLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ComputeEnvComputeEnvLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ComputeEnvComputeEnvLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ComputeEnvComputeEnvLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class CredentialKeys(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "azureEntra": + suggest = "azure_entra" + elif key == "containerReg": + suggest = "container_reg" + elif key == "twAgent": + suggest = "tw_agent" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeys. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeys.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeys.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + aws: Optional['outputs.CredentialKeysAws'] = None, + azure: Optional['outputs.CredentialKeysAzure'] = None, + azure_entra: Optional['outputs.CredentialKeysAzureEntra'] = None, + azurerepos: Optional['outputs.CredentialKeysAzurerepos'] = None, + bitbucket: Optional['outputs.CredentialKeysBitbucket'] = None, + codecommit: Optional['outputs.CredentialKeysCodecommit'] = None, + container_reg: Optional['outputs.CredentialKeysContainerReg'] = None, + gitea: Optional['outputs.CredentialKeysGitea'] = None, + github: Optional['outputs.CredentialKeysGithub'] = None, + gitlab: Optional['outputs.CredentialKeysGitlab'] = None, + google: Optional['outputs.CredentialKeysGoogle'] = None, + k8s: Optional['outputs.CredentialKeysK8s'] = None, + seqeracompute: Optional['outputs.CredentialKeysSeqeracompute'] = None, + ssh: Optional['outputs.CredentialKeysSsh'] = None, + tw_agent: Optional['outputs.CredentialKeysTwAgent'] = None): + if aws is not None: + pulumi.set(__self__, "aws", aws) + if azure is not None: + pulumi.set(__self__, "azure", azure) + if azure_entra is not None: + pulumi.set(__self__, "azure_entra", azure_entra) + if azurerepos is not None: + pulumi.set(__self__, "azurerepos", azurerepos) + if bitbucket is not None: + pulumi.set(__self__, "bitbucket", bitbucket) + if codecommit is not None: + pulumi.set(__self__, "codecommit", codecommit) + if container_reg is not None: + pulumi.set(__self__, "container_reg", container_reg) + if gitea is not None: + pulumi.set(__self__, "gitea", gitea) + if github is not None: + pulumi.set(__self__, "github", github) + if gitlab is not None: + pulumi.set(__self__, "gitlab", gitlab) + if google is not None: + pulumi.set(__self__, "google", google) + if k8s is not None: + pulumi.set(__self__, "k8s", k8s) + if seqeracompute is not None: + pulumi.set(__self__, "seqeracompute", seqeracompute) + if ssh is not None: + pulumi.set(__self__, "ssh", ssh) + if tw_agent is not None: + pulumi.set(__self__, "tw_agent", tw_agent) + + @_builtins.property + @pulumi.getter + def aws(self) -> Optional['outputs.CredentialKeysAws']: + return pulumi.get(self, "aws") + + @_builtins.property + @pulumi.getter + def azure(self) -> Optional['outputs.CredentialKeysAzure']: + return pulumi.get(self, "azure") + + @_builtins.property + @pulumi.getter(name="azureEntra") + def azure_entra(self) -> Optional['outputs.CredentialKeysAzureEntra']: + return pulumi.get(self, "azure_entra") + + @_builtins.property + @pulumi.getter + def azurerepos(self) -> Optional['outputs.CredentialKeysAzurerepos']: + return pulumi.get(self, "azurerepos") + + @_builtins.property + @pulumi.getter + def bitbucket(self) -> Optional['outputs.CredentialKeysBitbucket']: + return pulumi.get(self, "bitbucket") + + @_builtins.property + @pulumi.getter + def codecommit(self) -> Optional['outputs.CredentialKeysCodecommit']: + return pulumi.get(self, "codecommit") + + @_builtins.property + @pulumi.getter(name="containerReg") + def container_reg(self) -> Optional['outputs.CredentialKeysContainerReg']: + return pulumi.get(self, "container_reg") + + @_builtins.property + @pulumi.getter + def gitea(self) -> Optional['outputs.CredentialKeysGitea']: + return pulumi.get(self, "gitea") + + @_builtins.property + @pulumi.getter + def github(self) -> Optional['outputs.CredentialKeysGithub']: + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def gitlab(self) -> Optional['outputs.CredentialKeysGitlab']: + return pulumi.get(self, "gitlab") + + @_builtins.property + @pulumi.getter + def google(self) -> Optional['outputs.CredentialKeysGoogle']: + return pulumi.get(self, "google") + + @_builtins.property + @pulumi.getter + def k8s(self) -> Optional['outputs.CredentialKeysK8s']: + return pulumi.get(self, "k8s") + + @_builtins.property + @pulumi.getter + def seqeracompute(self) -> Optional['outputs.CredentialKeysSeqeracompute']: + return pulumi.get(self, "seqeracompute") + + @_builtins.property + @pulumi.getter + def ssh(self) -> Optional['outputs.CredentialKeysSsh']: + return pulumi.get(self, "ssh") + + @_builtins.property + @pulumi.getter(name="twAgent") + def tw_agent(self) -> Optional['outputs.CredentialKeysTwAgent']: + return pulumi.get(self, "tw_agent") + + +@pulumi.output_type +class CredentialKeysAws(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "accessKey": + suggest = "access_key" + elif key == "assumeRoleArn": + suggest = "assume_role_arn" + elif key == "secretKey": + suggest = "secret_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysAws. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysAws.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysAws.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + access_key: Optional[_builtins.str] = None, + assume_role_arn: Optional[_builtins.str] = None, + secret_key: Optional[_builtins.str] = None): + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if assume_role_arn is not None: + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> Optional[_builtins.str]: + return pulumi.get(self, "assume_role_arn") + + @_builtins.property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "secret_key") + + +@pulumi.output_type +class CredentialKeysAzure(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "batchKey": + suggest = "batch_key" + elif key == "batchName": + suggest = "batch_name" + elif key == "storageKey": + suggest = "storage_key" + elif key == "storageName": + suggest = "storage_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysAzure. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysAzure.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysAzure.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + batch_key: Optional[_builtins.str] = None, + batch_name: Optional[_builtins.str] = None, + storage_key: Optional[_builtins.str] = None, + storage_name: Optional[_builtins.str] = None): + if batch_key is not None: + pulumi.set(__self__, "batch_key", batch_key) + if batch_name is not None: + pulumi.set(__self__, "batch_name", batch_name) + if storage_key is not None: + pulumi.set(__self__, "storage_key", storage_key) + if storage_name is not None: + pulumi.set(__self__, "storage_name", storage_name) + + @_builtins.property + @pulumi.getter(name="batchKey") + def batch_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "batch_key") + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "batch_name") + + @_builtins.property + @pulumi.getter(name="storageKey") + def storage_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_key") + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_name") + + +@pulumi.output_type +class CredentialKeysAzureEntra(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "batchKey": + suggest = "batch_key" + elif key == "batchName": + suggest = "batch_name" + elif key == "clientId": + suggest = "client_id" + elif key == "clientSecret": + suggest = "client_secret" + elif key == "storageKey": + suggest = "storage_key" + elif key == "storageName": + suggest = "storage_name" + elif key == "tenantId": + suggest = "tenant_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysAzureEntra. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysAzureEntra.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysAzureEntra.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + batch_key: Optional[_builtins.str] = None, + batch_name: Optional[_builtins.str] = None, + client_id: Optional[_builtins.str] = None, + client_secret: Optional[_builtins.str] = None, + storage_key: Optional[_builtins.str] = None, + storage_name: Optional[_builtins.str] = None, + tenant_id: Optional[_builtins.str] = None): + if batch_key is not None: + pulumi.set(__self__, "batch_key", batch_key) + if batch_name is not None: + pulumi.set(__self__, "batch_name", batch_name) + if client_id is not None: + pulumi.set(__self__, "client_id", client_id) + if client_secret is not None: + pulumi.set(__self__, "client_secret", client_secret) + if storage_key is not None: + pulumi.set(__self__, "storage_key", storage_key) + if storage_name is not None: + pulumi.set(__self__, "storage_name", storage_name) + if tenant_id is not None: + pulumi.set(__self__, "tenant_id", tenant_id) + + @_builtins.property + @pulumi.getter(name="batchKey") + def batch_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "batch_key") + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "batch_name") + + @_builtins.property + @pulumi.getter(name="clientId") + def client_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "client_id") + + @_builtins.property + @pulumi.getter(name="clientSecret") + def client_secret(self) -> Optional[_builtins.str]: + return pulumi.get(self, "client_secret") + + @_builtins.property + @pulumi.getter(name="storageKey") + def storage_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_key") + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "storage_name") + + @_builtins.property + @pulumi.getter(name="tenantId") + def tenant_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "tenant_id") + + +@pulumi.output_type +class CredentialKeysAzurerepos(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysBitbucket(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysCodecommit(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysContainerReg(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "userName": + suggest = "user_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysContainerReg. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysContainerReg.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysContainerReg.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + registry: Optional[_builtins.str] = None, + user_name: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if registry is not None: + pulumi.set(__self__, "registry", registry) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def registry(self) -> Optional[_builtins.str]: + return pulumi.get(self, "registry") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class CredentialKeysGitea(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysGithub(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysGitlab(dict): + def __init__(__self__, *, + password: Optional[_builtins.str] = None, + token: Optional[_builtins.str] = None, + username: Optional[_builtins.str] = None): + if password is not None: + pulumi.set(__self__, "password", password) + if token is not None: + pulumi.set(__self__, "token", token) + if username is not None: + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def password(self) -> Optional[_builtins.str]: + return pulumi.get(self, "password") + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[_builtins.str]: + return pulumi.get(self, "token") + + @_builtins.property + @pulumi.getter + def username(self) -> Optional[_builtins.str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class CredentialKeysGoogle(dict): + def __init__(__self__, *, + data: Optional[_builtins.str] = None): + if data is not None: + pulumi.set(__self__, "data", data) + + @_builtins.property + @pulumi.getter + def data(self) -> Optional[_builtins.str]: + return pulumi.get(self, "data") + + +@pulumi.output_type +class CredentialKeysK8s(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "privateKey": + suggest = "private_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysK8s. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysK8s.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysK8s.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + certificate: Optional[_builtins.str] = None, + private_key: Optional[_builtins.str] = None, + token: Optional[_builtins.str] = None): + if certificate is not None: + pulumi.set(__self__, "certificate", certificate) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + if token is not None: + pulumi.set(__self__, "token", token) + + @_builtins.property + @pulumi.getter + def certificate(self) -> Optional[_builtins.str]: + return pulumi.get(self, "certificate") + + @_builtins.property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "private_key") + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[_builtins.str]: + return pulumi.get(self, "token") + + +@pulumi.output_type +class CredentialKeysSeqeracompute(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "accessKey": + suggest = "access_key" + elif key == "assumeRoleArn": + suggest = "assume_role_arn" + elif key == "secretKey": + suggest = "secret_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysSeqeracompute. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysSeqeracompute.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysSeqeracompute.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + access_key: Optional[_builtins.str] = None, + assume_role_arn: Optional[_builtins.str] = None, + secret_key: Optional[_builtins.str] = None): + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if assume_role_arn is not None: + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> Optional[_builtins.str]: + return pulumi.get(self, "assume_role_arn") + + @_builtins.property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "secret_key") + + +@pulumi.output_type +class CredentialKeysSsh(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "privateKey": + suggest = "private_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysSsh. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysSsh.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysSsh.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + passphrase: Optional[_builtins.str] = None, + private_key: Optional[_builtins.str] = None): + if passphrase is not None: + pulumi.set(__self__, "passphrase", passphrase) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + + @_builtins.property + @pulumi.getter + def passphrase(self) -> Optional[_builtins.str]: + return pulumi.get(self, "passphrase") + + @_builtins.property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[_builtins.str]: + return pulumi.get(self, "private_key") + + +@pulumi.output_type +class CredentialKeysTwAgent(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "connectionId": + suggest = "connection_id" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CredentialKeysTwAgent. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CredentialKeysTwAgent.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CredentialKeysTwAgent.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + connection_id: Optional[_builtins.str] = None, + shared: Optional[_builtins.bool] = None, + work_dir: Optional[_builtins.str] = None): + if connection_id is not None: + pulumi.set(__self__, "connection_id", connection_id) + if shared is not None: + pulumi.set(__self__, "shared", shared) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="connectionId") + def connection_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "connection_id") + + @_builtins.property + @pulumi.getter + def shared(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "shared") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class DataLinkCredential(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "providerType": + suggest = "provider_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DataLinkCredential. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DataLinkCredential.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DataLinkCredential.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + provider_type: Optional[_builtins.str] = None): + """ + :param _builtins.str provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + +@pulumi.output_type +class LabelsLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LabelsLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LabelsLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LabelsLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class PipelineComputeEnv(dict): + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + platform: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None): + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if region is not None: + pulumi.set(__self__, "region", region) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[_builtins.str]: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + +@pulumi.output_type +class PipelineLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in PipelineLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + PipelineLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + PipelineLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class PipelineLaunch(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "computeEnvId": + suggest = "compute_env_id" + elif key == "workDir": + suggest = "work_dir" + elif key == "configProfiles": + suggest = "config_profiles" + elif key == "configText": + suggest = "config_text" + elif key == "dateCreated": + suggest = "date_created" + elif key == "entryName": + suggest = "entry_name" + elif key == "headJobCpus": + suggest = "head_job_cpus" + elif key == "headJobMemoryMb": + suggest = "head_job_memory_mb" + elif key == "labelIds": + suggest = "label_ids" + elif key == "launchContainer": + suggest = "launch_container" + elif key == "mainScript": + suggest = "main_script" + elif key == "optimizationId": + suggest = "optimization_id" + elif key == "optimizationTargets": + suggest = "optimization_targets" + elif key == "paramsText": + suggest = "params_text" + elif key == "postRunScript": + suggest = "post_run_script" + elif key == "preRunScript": + suggest = "pre_run_script" + elif key == "pullLatest": + suggest = "pull_latest" + elif key == "runName": + suggest = "run_name" + elif key == "schemaName": + suggest = "schema_name" + elif key == "sessionId": + suggest = "session_id" + elif key == "stubRun": + suggest = "stub_run" + elif key == "towerConfig": + suggest = "tower_config" + elif key == "userSecrets": + suggest = "user_secrets" + elif key == "workspaceSecrets": + suggest = "workspace_secrets" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in PipelineLaunch. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + PipelineLaunch.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + PipelineLaunch.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + compute_env_id: _builtins.str, + pipeline: _builtins.str, + work_dir: _builtins.str, + config_profiles: Optional[Sequence[_builtins.str]] = None, + config_text: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + entry_name: Optional[_builtins.str] = None, + head_job_cpus: Optional[_builtins.float] = None, + head_job_memory_mb: Optional[_builtins.float] = None, + label_ids: Optional[Sequence[_builtins.float]] = None, + launch_container: Optional[_builtins.str] = None, + main_script: Optional[_builtins.str] = None, + optimization_id: Optional[_builtins.str] = None, + optimization_targets: Optional[_builtins.str] = None, + params_text: Optional[_builtins.str] = None, + post_run_script: Optional[_builtins.str] = None, + pre_run_script: Optional[_builtins.str] = None, + pull_latest: Optional[_builtins.bool] = None, + resume: Optional[_builtins.bool] = None, + revision: Optional[_builtins.str] = None, + run_name: Optional[_builtins.str] = None, + schema_name: Optional[_builtins.str] = None, + session_id: Optional[_builtins.str] = None, + stub_run: Optional[_builtins.bool] = None, + tower_config: Optional[_builtins.str] = None, + user_secrets: Optional[Sequence[_builtins.str]] = None, + workspace_secrets: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + :param _builtins.str pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def pipeline(self) -> _builtins.str: + return pulumi.get(self, "pipeline") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "config_profiles") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[_builtins.str]: + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "entry_name") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[_builtins.float]: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[Sequence[_builtins.float]]: + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_container") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[_builtins.str]: + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[_builtins.str]: + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[_builtins.str]: + return pulumi.get(self, "params_text") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[_builtins.str]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[_builtins.str]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "pull_latest") + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[_builtins.str]: + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "schema_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "stub_run") + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[_builtins.str]: + return pulumi.get(self, "tower_config") + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "user_secrets") + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "workspace_secrets") + + +@pulumi.output_type +class StudiosActiveConnection(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "lastActive": + suggest = "last_active" + elif key == "userName": + suggest = "user_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosActiveConnection. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosActiveConnection.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosActiveConnection.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + avatar: Optional[_builtins.str] = None, + email: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + last_active: Optional[_builtins.str] = None, + user_name: Optional[_builtins.str] = None): + if avatar is not None: + pulumi.set(__self__, "avatar", avatar) + if email is not None: + pulumi.set(__self__, "email", email) + if id is not None: + pulumi.set(__self__, "id", id) + if last_active is not None: + pulumi.set(__self__, "last_active", last_active) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> Optional[_builtins.str]: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter + def email(self) -> Optional[_builtins.str]: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastActive") + def last_active(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_active") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class StudiosComputeEnv(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "credentialsId": + suggest = "credentials_id" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosComputeEnv. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosComputeEnv.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosComputeEnv.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + credentials_id: Optional[_builtins.str] = None, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + platform: Optional[_builtins.str] = None, + region: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + if credentials_id is not None: + pulumi.set(__self__, "credentials_id", credentials_id) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if region is not None: + pulumi.set(__self__, "region", region) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[_builtins.str]: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class StudiosConfiguration(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "condaEnvironment": + suggest = "conda_environment" + elif key == "lifespanHours": + suggest = "lifespan_hours" + elif key == "mountDatas": + suggest = "mount_datas" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + conda_environment: Optional[_builtins.str] = None, + cpu: Optional[_builtins.float] = None, + gpu: Optional[_builtins.float] = None, + lifespan_hours: Optional[_builtins.float] = None, + memory: Optional[_builtins.float] = None, + mount_datas: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str conda_environment: Requires replacement if changed. + :param _builtins.float cpu: Requires replacement if changed. + :param _builtins.float gpu: Requires replacement if changed. + :param _builtins.float lifespan_hours: Requires replacement if changed. + :param _builtins.float memory: Requires replacement if changed. + :param Sequence[_builtins.str] mount_datas: Requires replacement if changed. + """ + if conda_environment is not None: + pulumi.set(__self__, "conda_environment", conda_environment) + if cpu is not None: + pulumi.set(__self__, "cpu", cpu) + if gpu is not None: + pulumi.set(__self__, "gpu", gpu) + if lifespan_hours is not None: + pulumi.set(__self__, "lifespan_hours", lifespan_hours) + if memory is not None: + pulumi.set(__self__, "memory", memory) + if mount_datas is not None: + pulumi.set(__self__, "mount_datas", mount_datas) + + @_builtins.property + @pulumi.getter(name="condaEnvironment") + def conda_environment(self) -> Optional[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "conda_environment") + + @_builtins.property + @pulumi.getter + def cpu(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "cpu") + + @_builtins.property + @pulumi.getter + def gpu(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "gpu") + + @_builtins.property + @pulumi.getter(name="lifespanHours") + def lifespan_hours(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "lifespan_hours") + + @_builtins.property + @pulumi.getter + def memory(self) -> Optional[_builtins.float]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "memory") + + @_builtins.property + @pulumi.getter(name="mountDatas") + def mount_datas(self) -> Optional[Sequence[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "mount_datas") + + +@pulumi.output_type +class StudiosLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class StudiosMountedDataLink(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dataLinkId": + suggest = "data_link_id" + elif key == "providerType": + suggest = "provider_type" + elif key == "publicAccessible": + suggest = "public_accessible" + elif key == "resourceRef": + suggest = "resource_ref" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosMountedDataLink. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosMountedDataLink.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosMountedDataLink.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + credentials: Optional[Sequence['outputs.StudiosMountedDataLinkCredential']] = None, + data_link_id: Optional[_builtins.str] = None, + description: Optional[_builtins.str] = None, + hidden: Optional[_builtins.bool] = None, + message: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + provider_type: Optional[_builtins.str] = None, + public_accessible: Optional[_builtins.bool] = None, + region: Optional[_builtins.str] = None, + resource_ref: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None, + type: Optional[_builtins.str] = None): + """ + :param Sequence['StudiosMountedDataLinkCredentialArgs'] credentials: Array of credentials required to access the data link + :param _builtins.str data_link_id: Unique identifier for the data link + :param _builtins.str description: Description of the data link's purpose and contents + :param _builtins.str name: Display name for the data link connection + :param _builtins.str provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + :param _builtins.str region: Geographic region where the data link is hosted + :param _builtins.str resource_ref: Reference identifier for the external resource + :param _builtins.str status: must be one of ["VALID", "INVALID"] + :param _builtins.str type: must be "bucket" + """ + if credentials is not None: + pulumi.set(__self__, "credentials", credentials) + if data_link_id is not None: + pulumi.set(__self__, "data_link_id", data_link_id) + if description is not None: + pulumi.set(__self__, "description", description) + if hidden is not None: + pulumi.set(__self__, "hidden", hidden) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + if public_accessible is not None: + pulumi.set(__self__, "public_accessible", public_accessible) + if region is not None: + pulumi.set(__self__, "region", region) + if resource_ref is not None: + pulumi.set(__self__, "resource_ref", resource_ref) + if status is not None: + pulumi.set(__self__, "status", status) + if type is not None: + pulumi.set(__self__, "type", type) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Optional[Sequence['outputs.StudiosMountedDataLinkCredential']]: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> Optional[_builtins.str]: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[_builtins.str]: + """ + Description of the data link's purpose and contents + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def hidden(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "hidden") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Display name for the data link connection + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "public_accessible") + + @_builtins.property + @pulumi.getter + def region(self) -> Optional[_builtins.str]: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> Optional[_builtins.str]: + """ + Reference identifier for the external resource + """ + return pulumi.get(self, "resource_ref") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["VALID", "INVALID"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def type(self) -> Optional[_builtins.str]: + """ + must be "bucket" + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class StudiosMountedDataLinkCredential(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "providerType": + suggest = "provider_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosMountedDataLinkCredential. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosMountedDataLinkCredential.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosMountedDataLinkCredential.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + provider_type: Optional[_builtins.str] = None): + """ + :param _builtins.str provider_type: must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if provider_type is not None: + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> Optional[_builtins.str]: + """ + must be one of ["aws", "google", "azure", "azure_entra", "seqeracompute"] + """ + return pulumi.get(self, "provider_type") + + +@pulumi.output_type +class StudiosParentCheckpoint(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "checkpointId": + suggest = "checkpoint_id" + elif key == "checkpointName": + suggest = "checkpoint_name" + elif key == "sessionId": + suggest = "session_id" + elif key == "studioName": + suggest = "studio_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosParentCheckpoint. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosParentCheckpoint.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosParentCheckpoint.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + checkpoint_id: Optional[_builtins.float] = None, + checkpoint_name: Optional[_builtins.str] = None, + session_id: Optional[_builtins.str] = None, + studio_name: Optional[_builtins.str] = None): + if checkpoint_id is not None: + pulumi.set(__self__, "checkpoint_id", checkpoint_id) + if checkpoint_name is not None: + pulumi.set(__self__, "checkpoint_name", checkpoint_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if studio_name is not None: + pulumi.set(__self__, "studio_name", studio_name) + + @_builtins.property + @pulumi.getter(name="checkpointId") + def checkpoint_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "checkpoint_id") + + @_builtins.property + @pulumi.getter(name="checkpointName") + def checkpoint_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "checkpoint_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="studioName") + def studio_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "studio_name") + + +@pulumi.output_type +class StudiosProgress(dict): + def __init__(__self__, *, + message: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None, + warnings: Optional[Sequence[_builtins.str]] = None): + """ + :param _builtins.str status: must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + if message is not None: + pulumi.set(__self__, "message", message) + if status is not None: + pulumi.set(__self__, "status", status) + if warnings is not None: + pulumi.set(__self__, "warnings", warnings) + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["pending", "in-progress", "succeeded", "errored"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def warnings(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "warnings") + + +@pulumi.output_type +class StudiosStatusInfo(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "lastUpdate": + suggest = "last_update" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosStatusInfo. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosStatusInfo.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosStatusInfo.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + last_update: Optional[_builtins.str] = None, + message: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None): + """ + :param _builtins.str status: must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ + if last_update is not None: + pulumi.set(__self__, "last_update", last_update) + if message is not None: + pulumi.set(__self__, "message", message) + if status is not None: + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="lastUpdate") + def last_update(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_update") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["starting", "running", "stopping", "stopped", "errored", "building", "buildFailed"] + """ + return pulumi.get(self, "status") + + +@pulumi.output_type +class StudiosTemplate(dict): + def __init__(__self__, *, + icon: Optional[_builtins.str] = None, + repository: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None, + tool: Optional[_builtins.str] = None): + """ + :param _builtins.str status: must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + if icon is not None: + pulumi.set(__self__, "icon", icon) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if status is not None: + pulumi.set(__self__, "status", status) + if tool is not None: + pulumi.set(__self__, "tool", tool) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[_builtins.str]: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[_builtins.str]: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["recommended", "deprecated", "experimental", "unsupported"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def tool(self) -> Optional[_builtins.str]: + return pulumi.get(self, "tool") + + +@pulumi.output_type +class StudiosUser(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "userName": + suggest = "user_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StudiosUser. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StudiosUser.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StudiosUser.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + avatar: Optional[_builtins.str] = None, + email: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + user_name: Optional[_builtins.str] = None): + if avatar is not None: + pulumi.set(__self__, "avatar", avatar) + if email is not None: + pulumi.set(__self__, "email", email) + if id is not None: + pulumi.set(__self__, "id", id) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> Optional[_builtins.str]: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter + def email(self) -> Optional[_builtins.str]: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class TokensToken(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "basicAuth": + suggest = "basic_auth" + elif key == "dateCreated": + suggest = "date_created" + elif key == "lastUsed": + suggest = "last_used" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TokensToken. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TokensToken.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TokensToken.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + basic_auth: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + last_used: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None): + """ + :param _builtins.str basic_auth: Deprecated basic authentication string + :param _builtins.str date_created: Timestamp when the token was created + :param _builtins.float id: Unique numeric identifier for the access token (nullable) + :param _builtins.str last_used: Timestamp when the token was last used for authentication + :param _builtins.str name: Display name for the token (1-50 characters) + """ + if basic_auth is not None: + pulumi.set(__self__, "basic_auth", basic_auth) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> Optional[_builtins.str]: + """ + Deprecated basic authentication string + """ + return pulumi.get(self, "basic_auth") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the token was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the access token (nullable) + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[_builtins.str]: + """ + Timestamp when the token was last used for authentication + """ + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Display name for the token (1-50 characters) + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class WorkflowsJobInfo(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "exitCode": + suggest = "exit_code" + elif key == "operationId": + suggest = "operation_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsJobInfo. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsJobInfo.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsJobInfo.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + exit_code: Optional[_builtins.float] = None, + id: Optional[_builtins.float] = None, + message: Optional[_builtins.str] = None, + operation_id: Optional[_builtins.str] = None, + status: Optional[_builtins.str] = None): + if exit_code is not None: + pulumi.set(__self__, "exit_code", exit_code) + if id is not None: + pulumi.set(__self__, "id", id) + if message is not None: + pulumi.set(__self__, "message", message) + if operation_id is not None: + pulumi.set(__self__, "operation_id", operation_id) + if status is not None: + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="exitCode") + def exit_code(self) -> Optional[_builtins.float]: + return pulumi.get(self, "exit_code") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "operation_id") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + return pulumi.get(self, "status") + + +@pulumi.output_type +class WorkflowsLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "dateCreated": + suggest = "date_created" + elif key == "isDefault": + suggest = "is_default" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + date_created: Optional[_builtins.str] = None, + id: Optional[_builtins.float] = None, + is_default: Optional[_builtins.bool] = None, + name: Optional[_builtins.str] = None, + resource: Optional[_builtins.bool] = None, + value: Optional[_builtins.str] = None): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if id is not None: + pulumi.set(__self__, "id", id) + if is_default is not None: + pulumi.set(__self__, "is_default", is_default) + if name is not None: + pulumi.set(__self__, "name", name) + if resource is not None: + pulumi.set(__self__, "resource", resource) + if value is not None: + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.float]: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> Optional[_builtins.bool]: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[_builtins.str]: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class WorkflowsPlatform(dict): + def __init__(__self__, *, + id: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None): + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + +@pulumi.output_type +class WorkflowsProgress(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "processesProgresses": + suggest = "processes_progresses" + elif key == "totalProcesses": + suggest = "total_processes" + elif key == "workflowProgress": + suggest = "workflow_progress" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsProgress. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsProgress.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsProgress.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + processes_progresses: Optional[Sequence['outputs.WorkflowsProgressProcessesProgress']] = None, + total_processes: Optional[_builtins.float] = None, + workflow_progress: Optional['outputs.WorkflowsProgressWorkflowProgress'] = None): + if processes_progresses is not None: + pulumi.set(__self__, "processes_progresses", processes_progresses) + if total_processes is not None: + pulumi.set(__self__, "total_processes", total_processes) + if workflow_progress is not None: + pulumi.set(__self__, "workflow_progress", workflow_progress) + + @_builtins.property + @pulumi.getter(name="processesProgresses") + def processes_progresses(self) -> Optional[Sequence['outputs.WorkflowsProgressProcessesProgress']]: + return pulumi.get(self, "processes_progresses") + + @_builtins.property + @pulumi.getter(name="totalProcesses") + def total_processes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "total_processes") + + @_builtins.property + @pulumi.getter(name="workflowProgress") + def workflow_progress(self) -> Optional['outputs.WorkflowsProgressWorkflowProgress']: + return pulumi.get(self, "workflow_progress") + + +@pulumi.output_type +class WorkflowsProgressProcessesProgress(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cpuEfficiency": + suggest = "cpu_efficiency" + elif key == "cpuLoad": + suggest = "cpu_load" + elif key == "cpuTime": + suggest = "cpu_time" + elif key == "dateCreated": + suggest = "date_created" + elif key == "invCtxSwitch": + suggest = "inv_ctx_switch" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "loadCpus": + suggest = "load_cpus" + elif key == "loadMemory": + suggest = "load_memory" + elif key == "loadTasks": + suggest = "load_tasks" + elif key == "memoryEfficiency": + suggest = "memory_efficiency" + elif key == "memoryReq": + suggest = "memory_req" + elif key == "memoryRss": + suggest = "memory_rss" + elif key == "peakCpus": + suggest = "peak_cpus" + elif key == "peakMemory": + suggest = "peak_memory" + elif key == "peakTasks": + suggest = "peak_tasks" + elif key == "readBytes": + suggest = "read_bytes" + elif key == "volCtxSwitch": + suggest = "vol_ctx_switch" + elif key == "writeBytes": + suggest = "write_bytes" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsProgressProcessesProgress. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsProgressProcessesProgress.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsProgressProcessesProgress.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + aborted: Optional[_builtins.float] = None, + cached: Optional[_builtins.float] = None, + cpu_efficiency: Optional[_builtins.float] = None, + cpu_load: Optional[_builtins.float] = None, + cpu_time: Optional[_builtins.float] = None, + cpus: Optional[_builtins.float] = None, + date_created: Optional[_builtins.str] = None, + failed: Optional[_builtins.float] = None, + inv_ctx_switch: Optional[_builtins.float] = None, + last_updated: Optional[_builtins.str] = None, + load_cpus: Optional[_builtins.float] = None, + load_memory: Optional[_builtins.float] = None, + load_tasks: Optional[_builtins.float] = None, + memory_efficiency: Optional[_builtins.float] = None, + memory_req: Optional[_builtins.float] = None, + memory_rss: Optional[_builtins.float] = None, + peak_cpus: Optional[_builtins.float] = None, + peak_memory: Optional[_builtins.float] = None, + peak_tasks: Optional[_builtins.float] = None, + pending: Optional[_builtins.float] = None, + process: Optional[_builtins.str] = None, + read_bytes: Optional[_builtins.float] = None, + running: Optional[_builtins.float] = None, + submitted: Optional[_builtins.float] = None, + succeeded: Optional[_builtins.float] = None, + vol_ctx_switch: Optional[_builtins.float] = None, + write_bytes: Optional[_builtins.float] = None): + if aborted is not None: + pulumi.set(__self__, "aborted", aborted) + if cached is not None: + pulumi.set(__self__, "cached", cached) + if cpu_efficiency is not None: + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + if cpu_load is not None: + pulumi.set(__self__, "cpu_load", cpu_load) + if cpu_time is not None: + pulumi.set(__self__, "cpu_time", cpu_time) + if cpus is not None: + pulumi.set(__self__, "cpus", cpus) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if failed is not None: + pulumi.set(__self__, "failed", failed) + if inv_ctx_switch is not None: + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if load_cpus is not None: + pulumi.set(__self__, "load_cpus", load_cpus) + if load_memory is not None: + pulumi.set(__self__, "load_memory", load_memory) + if load_tasks is not None: + pulumi.set(__self__, "load_tasks", load_tasks) + if memory_efficiency is not None: + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + if memory_req is not None: + pulumi.set(__self__, "memory_req", memory_req) + if memory_rss is not None: + pulumi.set(__self__, "memory_rss", memory_rss) + if peak_cpus is not None: + pulumi.set(__self__, "peak_cpus", peak_cpus) + if peak_memory is not None: + pulumi.set(__self__, "peak_memory", peak_memory) + if peak_tasks is not None: + pulumi.set(__self__, "peak_tasks", peak_tasks) + if pending is not None: + pulumi.set(__self__, "pending", pending) + if process is not None: + pulumi.set(__self__, "process", process) + if read_bytes is not None: + pulumi.set(__self__, "read_bytes", read_bytes) + if running is not None: + pulumi.set(__self__, "running", running) + if submitted is not None: + pulumi.set(__self__, "submitted", submitted) + if succeeded is not None: + pulumi.set(__self__, "succeeded", succeeded) + if vol_ctx_switch is not None: + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + if write_bytes is not None: + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> Optional[_builtins.float]: + return pulumi.get(self, "aborted") + + @_builtins.property + @pulumi.getter + def cached(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached") + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_efficiency") + + @_builtins.property + @pulumi.getter(name="cpuLoad") + @_utilities.deprecated("""Deprecated""") + def cpu_load(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_load") + + @_builtins.property + @pulumi.getter(name="cpuTime") + @_utilities.deprecated("""Deprecated""") + def cpu_time(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_time") + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpus") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def failed(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed") + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def inv_ctx_switch(self) -> Optional[_builtins.float]: + return pulumi.get(self, "inv_ctx_switch") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_cpus") + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_memory") + + @_builtins.property + @pulumi.getter(name="loadTasks") + @_utilities.deprecated("""Deprecated""") + def load_tasks(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_tasks") + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_efficiency") + + @_builtins.property + @pulumi.getter(name="memoryReq") + @_utilities.deprecated("""Deprecated""") + def memory_req(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_req") + + @_builtins.property + @pulumi.getter(name="memoryRss") + @_utilities.deprecated("""Deprecated""") + def memory_rss(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_rss") + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_cpus") + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_memory") + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_tasks") + + @_builtins.property + @pulumi.getter + def pending(self) -> Optional[_builtins.float]: + return pulumi.get(self, "pending") + + @_builtins.property + @pulumi.getter + def process(self) -> Optional[_builtins.str]: + return pulumi.get(self, "process") + + @_builtins.property + @pulumi.getter(name="readBytes") + @_utilities.deprecated("""Deprecated""") + def read_bytes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "read_bytes") + + @_builtins.property + @pulumi.getter + def running(self) -> Optional[_builtins.float]: + return pulumi.get(self, "running") + + @_builtins.property + @pulumi.getter + def submitted(self) -> Optional[_builtins.float]: + return pulumi.get(self, "submitted") + + @_builtins.property + @pulumi.getter + def succeeded(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeeded") + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def vol_ctx_switch(self) -> Optional[_builtins.float]: + return pulumi.get(self, "vol_ctx_switch") + + @_builtins.property + @pulumi.getter(name="writeBytes") + @_utilities.deprecated("""Deprecated""") + def write_bytes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "write_bytes") + + +@pulumi.output_type +class WorkflowsProgressWorkflowProgress(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cpuEfficiency": + suggest = "cpu_efficiency" + elif key == "cpuLoad": + suggest = "cpu_load" + elif key == "cpuTime": + suggest = "cpu_time" + elif key == "dateCreated": + suggest = "date_created" + elif key == "invCtxSwitch": + suggest = "inv_ctx_switch" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "loadCpus": + suggest = "load_cpus" + elif key == "loadMemory": + suggest = "load_memory" + elif key == "loadTasks": + suggest = "load_tasks" + elif key == "memoryEfficiency": + suggest = "memory_efficiency" + elif key == "memoryReq": + suggest = "memory_req" + elif key == "memoryRss": + suggest = "memory_rss" + elif key == "peakCpus": + suggest = "peak_cpus" + elif key == "peakMemory": + suggest = "peak_memory" + elif key == "peakTasks": + suggest = "peak_tasks" + elif key == "readBytes": + suggest = "read_bytes" + elif key == "volCtxSwitch": + suggest = "vol_ctx_switch" + elif key == "writeBytes": + suggest = "write_bytes" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsProgressWorkflowProgress. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsProgressWorkflowProgress.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsProgressWorkflowProgress.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + aborted: Optional[_builtins.float] = None, + cached: Optional[_builtins.float] = None, + cost: Optional[_builtins.float] = None, + cpu_efficiency: Optional[_builtins.float] = None, + cpu_load: Optional[_builtins.float] = None, + cpu_time: Optional[_builtins.float] = None, + cpus: Optional[_builtins.float] = None, + date_created: Optional[_builtins.str] = None, + executors: Optional[Sequence[_builtins.str]] = None, + failed: Optional[_builtins.float] = None, + inv_ctx_switch: Optional[_builtins.float] = None, + last_updated: Optional[_builtins.str] = None, + load_cpus: Optional[_builtins.float] = None, + load_memory: Optional[_builtins.float] = None, + load_tasks: Optional[_builtins.float] = None, + memory_efficiency: Optional[_builtins.float] = None, + memory_req: Optional[_builtins.float] = None, + memory_rss: Optional[_builtins.float] = None, + peak_cpus: Optional[_builtins.float] = None, + peak_memory: Optional[_builtins.float] = None, + peak_tasks: Optional[_builtins.float] = None, + pending: Optional[_builtins.float] = None, + read_bytes: Optional[_builtins.float] = None, + running: Optional[_builtins.float] = None, + submitted: Optional[_builtins.float] = None, + succeeded: Optional[_builtins.float] = None, + vol_ctx_switch: Optional[_builtins.float] = None, + write_bytes: Optional[_builtins.float] = None): + if aborted is not None: + pulumi.set(__self__, "aborted", aborted) + if cached is not None: + pulumi.set(__self__, "cached", cached) + if cost is not None: + pulumi.set(__self__, "cost", cost) + if cpu_efficiency is not None: + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + if cpu_load is not None: + pulumi.set(__self__, "cpu_load", cpu_load) + if cpu_time is not None: + pulumi.set(__self__, "cpu_time", cpu_time) + if cpus is not None: + pulumi.set(__self__, "cpus", cpus) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if executors is not None: + pulumi.set(__self__, "executors", executors) + if failed is not None: + pulumi.set(__self__, "failed", failed) + if inv_ctx_switch is not None: + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if load_cpus is not None: + pulumi.set(__self__, "load_cpus", load_cpus) + if load_memory is not None: + pulumi.set(__self__, "load_memory", load_memory) + if load_tasks is not None: + pulumi.set(__self__, "load_tasks", load_tasks) + if memory_efficiency is not None: + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + if memory_req is not None: + pulumi.set(__self__, "memory_req", memory_req) + if memory_rss is not None: + pulumi.set(__self__, "memory_rss", memory_rss) + if peak_cpus is not None: + pulumi.set(__self__, "peak_cpus", peak_cpus) + if peak_memory is not None: + pulumi.set(__self__, "peak_memory", peak_memory) + if peak_tasks is not None: + pulumi.set(__self__, "peak_tasks", peak_tasks) + if pending is not None: + pulumi.set(__self__, "pending", pending) + if read_bytes is not None: + pulumi.set(__self__, "read_bytes", read_bytes) + if running is not None: + pulumi.set(__self__, "running", running) + if submitted is not None: + pulumi.set(__self__, "submitted", submitted) + if succeeded is not None: + pulumi.set(__self__, "succeeded", succeeded) + if vol_ctx_switch is not None: + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + if write_bytes is not None: + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> Optional[_builtins.float]: + return pulumi.get(self, "aborted") + + @_builtins.property + @pulumi.getter + def cached(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached") + + @_builtins.property + @pulumi.getter + def cost(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cost") + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_efficiency") + + @_builtins.property + @pulumi.getter(name="cpuLoad") + def cpu_load(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_load") + + @_builtins.property + @pulumi.getter(name="cpuTime") + def cpu_time(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpu_time") + + @_builtins.property + @pulumi.getter + def cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cpus") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def executors(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "executors") + + @_builtins.property + @pulumi.getter + def failed(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed") + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + def inv_ctx_switch(self) -> Optional[_builtins.float]: + return pulumi.get(self, "inv_ctx_switch") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_cpus") + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_memory") + + @_builtins.property + @pulumi.getter(name="loadTasks") + def load_tasks(self) -> Optional[_builtins.float]: + return pulumi.get(self, "load_tasks") + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_efficiency") + + @_builtins.property + @pulumi.getter(name="memoryReq") + def memory_req(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_req") + + @_builtins.property + @pulumi.getter(name="memoryRss") + def memory_rss(self) -> Optional[_builtins.float]: + return pulumi.get(self, "memory_rss") + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_cpus") + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_memory") + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> Optional[_builtins.float]: + return pulumi.get(self, "peak_tasks") + + @_builtins.property + @pulumi.getter + def pending(self) -> Optional[_builtins.float]: + return pulumi.get(self, "pending") + + @_builtins.property + @pulumi.getter(name="readBytes") + def read_bytes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "read_bytes") + + @_builtins.property + @pulumi.getter + def running(self) -> Optional[_builtins.float]: + return pulumi.get(self, "running") + + @_builtins.property + @pulumi.getter + def submitted(self) -> Optional[_builtins.float]: + return pulumi.get(self, "submitted") + + @_builtins.property + @pulumi.getter + def succeeded(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeeded") + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + def vol_ctx_switch(self) -> Optional[_builtins.float]: + return pulumi.get(self, "vol_ctx_switch") + + @_builtins.property + @pulumi.getter(name="writeBytes") + def write_bytes(self) -> Optional[_builtins.float]: + return pulumi.get(self, "write_bytes") + + +@pulumi.output_type +class WorkflowsWorkflow(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "commandLine": + suggest = "command_line" + elif key == "commitId": + suggest = "commit_id" + elif key == "configFiles": + suggest = "config_files" + elif key == "configText": + suggest = "config_text" + elif key == "containerEngine": + suggest = "container_engine" + elif key == "dateCreated": + suggest = "date_created" + elif key == "errorMessage": + suggest = "error_message" + elif key == "errorReport": + suggest = "error_report" + elif key == "exitStatus": + suggest = "exit_status" + elif key == "homeDir": + suggest = "home_dir" + elif key == "lastUpdated": + suggest = "last_updated" + elif key == "launchDir": + suggest = "launch_dir" + elif key == "launchId": + suggest = "launch_id" + elif key == "logFile": + suggest = "log_file" + elif key == "operationId": + suggest = "operation_id" + elif key == "outFile": + suggest = "out_file" + elif key == "ownerId": + suggest = "owner_id" + elif key == "projectDir": + suggest = "project_dir" + elif key == "projectName": + suggest = "project_name" + elif key == "requiresAttention": + suggest = "requires_attention" + elif key == "runName": + suggest = "run_name" + elif key == "scriptFile": + suggest = "script_file" + elif key == "scriptId": + suggest = "script_id" + elif key == "scriptName": + suggest = "script_name" + elif key == "sessionId": + suggest = "session_id" + elif key == "userName": + suggest = "user_name" + elif key == "workDir": + suggest = "work_dir" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsWorkflow. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsWorkflow.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsWorkflow.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + command_line: Optional[_builtins.str] = None, + commit_id: Optional[_builtins.str] = None, + complete: Optional[_builtins.str] = None, + config_files: Optional[Sequence[_builtins.str]] = None, + config_text: Optional[_builtins.str] = None, + container: Optional[_builtins.str] = None, + container_engine: Optional[_builtins.str] = None, + date_created: Optional[_builtins.str] = None, + deleted: Optional[_builtins.bool] = None, + duration: Optional[_builtins.float] = None, + error_message: Optional[_builtins.str] = None, + error_report: Optional[_builtins.str] = None, + exit_status: Optional[_builtins.float] = None, + home_dir: Optional[_builtins.str] = None, + id: Optional[_builtins.str] = None, + last_updated: Optional[_builtins.str] = None, + launch_dir: Optional[_builtins.str] = None, + launch_id: Optional[_builtins.str] = None, + log_file: Optional[_builtins.str] = None, + manifest: Optional['outputs.WorkflowsWorkflowManifest'] = None, + nextflow: Optional['outputs.WorkflowsWorkflowNextflow'] = None, + operation_id: Optional[_builtins.str] = None, + out_file: Optional[_builtins.str] = None, + owner_id: Optional[_builtins.float] = None, + params: Optional[Mapping[str, _builtins.str]] = None, + profile: Optional[_builtins.str] = None, + project_dir: Optional[_builtins.str] = None, + project_name: Optional[_builtins.str] = None, + repository: Optional[_builtins.str] = None, + requires_attention: Optional[_builtins.bool] = None, + resume: Optional[_builtins.bool] = None, + revision: Optional[_builtins.str] = None, + run_name: Optional[_builtins.str] = None, + script_file: Optional[_builtins.str] = None, + script_id: Optional[_builtins.str] = None, + script_name: Optional[_builtins.str] = None, + session_id: Optional[_builtins.str] = None, + start: Optional[_builtins.str] = None, + stats: Optional['outputs.WorkflowsWorkflowStats'] = None, + status: Optional[_builtins.str] = None, + submit: Optional[_builtins.str] = None, + success: Optional[_builtins.bool] = None, + user_name: Optional[_builtins.str] = None, + work_dir: Optional[_builtins.str] = None): + """ + :param _builtins.str status: must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + if command_line is not None: + pulumi.set(__self__, "command_line", command_line) + if commit_id is not None: + pulumi.set(__self__, "commit_id", commit_id) + if complete is not None: + pulumi.set(__self__, "complete", complete) + if config_files is not None: + pulumi.set(__self__, "config_files", config_files) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if container is not None: + pulumi.set(__self__, "container", container) + if container_engine is not None: + pulumi.set(__self__, "container_engine", container_engine) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error_message is not None: + pulumi.set(__self__, "error_message", error_message) + if error_report is not None: + pulumi.set(__self__, "error_report", error_report) + if exit_status is not None: + pulumi.set(__self__, "exit_status", exit_status) + if home_dir is not None: + pulumi.set(__self__, "home_dir", home_dir) + if id is not None: + pulumi.set(__self__, "id", id) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch_dir is not None: + pulumi.set(__self__, "launch_dir", launch_dir) + if launch_id is not None: + pulumi.set(__self__, "launch_id", launch_id) + if log_file is not None: + pulumi.set(__self__, "log_file", log_file) + if manifest is not None: + pulumi.set(__self__, "manifest", manifest) + if nextflow is not None: + pulumi.set(__self__, "nextflow", nextflow) + if operation_id is not None: + pulumi.set(__self__, "operation_id", operation_id) + if out_file is not None: + pulumi.set(__self__, "out_file", out_file) + if owner_id is not None: + pulumi.set(__self__, "owner_id", owner_id) + if params is not None: + pulumi.set(__self__, "params", params) + if profile is not None: + pulumi.set(__self__, "profile", profile) + if project_dir is not None: + pulumi.set(__self__, "project_dir", project_dir) + if project_name is not None: + pulumi.set(__self__, "project_name", project_name) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if requires_attention is not None: + pulumi.set(__self__, "requires_attention", requires_attention) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if script_file is not None: + pulumi.set(__self__, "script_file", script_file) + if script_id is not None: + pulumi.set(__self__, "script_id", script_id) + if script_name is not None: + pulumi.set(__self__, "script_name", script_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if start is not None: + pulumi.set(__self__, "start", start) + if stats is not None: + pulumi.set(__self__, "stats", stats) + if status is not None: + pulumi.set(__self__, "status", status) + if submit is not None: + pulumi.set(__self__, "submit", submit) + if success is not None: + pulumi.set(__self__, "success", success) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="commandLine") + def command_line(self) -> Optional[_builtins.str]: + return pulumi.get(self, "command_line") + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "commit_id") + + @_builtins.property + @pulumi.getter + def complete(self) -> Optional[_builtins.str]: + return pulumi.get(self, "complete") + + @_builtins.property + @pulumi.getter(name="configFiles") + def config_files(self) -> Optional[Sequence[_builtins.str]]: + return pulumi.get(self, "config_files") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[_builtins.str]: + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter + def container(self) -> Optional[_builtins.str]: + return pulumi.get(self, "container") + + @_builtins.property + @pulumi.getter(name="containerEngine") + def container_engine(self) -> Optional[_builtins.str]: + return pulumi.get(self, "container_engine") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def duration(self) -> Optional[_builtins.float]: + return pulumi.get(self, "duration") + + @_builtins.property + @pulumi.getter(name="errorMessage") + def error_message(self) -> Optional[_builtins.str]: + return pulumi.get(self, "error_message") + + @_builtins.property + @pulumi.getter(name="errorReport") + def error_report(self) -> Optional[_builtins.str]: + return pulumi.get(self, "error_report") + + @_builtins.property + @pulumi.getter(name="exitStatus") + def exit_status(self) -> Optional[_builtins.float]: + return pulumi.get(self, "exit_status") + + @_builtins.property + @pulumi.getter(name="homeDir") + def home_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "home_dir") + + @_builtins.property + @pulumi.getter + def id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="launchId") + def launch_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "launch_id") + + @_builtins.property + @pulumi.getter(name="logFile") + def log_file(self) -> Optional[_builtins.str]: + return pulumi.get(self, "log_file") + + @_builtins.property + @pulumi.getter + def manifest(self) -> Optional['outputs.WorkflowsWorkflowManifest']: + return pulumi.get(self, "manifest") + + @_builtins.property + @pulumi.getter + def nextflow(self) -> Optional['outputs.WorkflowsWorkflowNextflow']: + return pulumi.get(self, "nextflow") + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "operation_id") + + @_builtins.property + @pulumi.getter(name="outFile") + def out_file(self) -> Optional[_builtins.str]: + return pulumi.get(self, "out_file") + + @_builtins.property + @pulumi.getter(name="ownerId") + def owner_id(self) -> Optional[_builtins.float]: + return pulumi.get(self, "owner_id") + + @_builtins.property + @pulumi.getter + def params(self) -> Optional[Mapping[str, _builtins.str]]: + return pulumi.get(self, "params") + + @_builtins.property + @pulumi.getter + def profile(self) -> Optional[_builtins.str]: + return pulumi.get(self, "profile") + + @_builtins.property + @pulumi.getter(name="projectDir") + def project_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "project_dir") + + @_builtins.property + @pulumi.getter(name="projectName") + def project_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "project_name") + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[_builtins.str]: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter(name="requiresAttention") + def requires_attention(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "requires_attention") + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[_builtins.str]: + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="scriptFile") + def script_file(self) -> Optional[_builtins.str]: + return pulumi.get(self, "script_file") + + @_builtins.property + @pulumi.getter(name="scriptId") + def script_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "script_id") + + @_builtins.property + @pulumi.getter(name="scriptName") + def script_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "script_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[_builtins.str]: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter + def start(self) -> Optional[_builtins.str]: + return pulumi.get(self, "start") + + @_builtins.property + @pulumi.getter + def stats(self) -> Optional['outputs.WorkflowsWorkflowStats']: + return pulumi.get(self, "stats") + + @_builtins.property + @pulumi.getter + def status(self) -> Optional[_builtins.str]: + """ + must be one of ["SUBMITTED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "UNKNOWN"] + """ + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def submit(self) -> Optional[_builtins.str]: + return pulumi.get(self, "submit") + + @_builtins.property + @pulumi.getter + def success(self) -> Optional[_builtins.bool]: + return pulumi.get(self, "success") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[_builtins.str]: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class WorkflowsWorkflowManifest(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "defaultBranch": + suggest = "default_branch" + elif key == "homePage": + suggest = "home_page" + elif key == "mainScript": + suggest = "main_script" + elif key == "nextflowVersion": + suggest = "nextflow_version" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsWorkflowManifest. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsWorkflowManifest.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsWorkflowManifest.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + author: Optional[_builtins.str] = None, + default_branch: Optional[_builtins.str] = None, + description: Optional[_builtins.str] = None, + gitmodules: Optional[_builtins.str] = None, + home_page: Optional[_builtins.str] = None, + icon: Optional[_builtins.str] = None, + main_script: Optional[_builtins.str] = None, + name: Optional[_builtins.str] = None, + nextflow_version: Optional[_builtins.str] = None, + version: Optional[_builtins.str] = None): + if author is not None: + pulumi.set(__self__, "author", author) + if default_branch is not None: + pulumi.set(__self__, "default_branch", default_branch) + if description is not None: + pulumi.set(__self__, "description", description) + if gitmodules is not None: + pulumi.set(__self__, "gitmodules", gitmodules) + if home_page is not None: + pulumi.set(__self__, "home_page", home_page) + if icon is not None: + pulumi.set(__self__, "icon", icon) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if name is not None: + pulumi.set(__self__, "name", name) + if nextflow_version is not None: + pulumi.set(__self__, "nextflow_version", nextflow_version) + if version is not None: + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def author(self) -> Optional[_builtins.str]: + return pulumi.get(self, "author") + + @_builtins.property + @pulumi.getter(name="defaultBranch") + def default_branch(self) -> Optional[_builtins.str]: + return pulumi.get(self, "default_branch") + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def gitmodules(self) -> Optional[_builtins.str]: + return pulumi.get(self, "gitmodules") + + @_builtins.property + @pulumi.getter(name="homePage") + def home_page(self) -> Optional[_builtins.str]: + return pulumi.get(self, "home_page") + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[_builtins.str]: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[_builtins.str]: + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="nextflowVersion") + def nextflow_version(self) -> Optional[_builtins.str]: + return pulumi.get(self, "nextflow_version") + + @_builtins.property + @pulumi.getter + def version(self) -> Optional[_builtins.str]: + return pulumi.get(self, "version") + + +@pulumi.output_type +class WorkflowsWorkflowNextflow(dict): + def __init__(__self__, *, + build: Optional[_builtins.str] = None, + timestamp: Optional[_builtins.str] = None, + version: Optional[_builtins.str] = None): + if build is not None: + pulumi.set(__self__, "build", build) + if timestamp is not None: + pulumi.set(__self__, "timestamp", timestamp) + if version is not None: + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def build(self) -> Optional[_builtins.str]: + return pulumi.get(self, "build") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> Optional[_builtins.str]: + return pulumi.get(self, "timestamp") + + @_builtins.property + @pulumi.getter + def version(self) -> Optional[_builtins.str]: + return pulumi.get(self, "version") + + +@pulumi.output_type +class WorkflowsWorkflowStats(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "cachedCount": + suggest = "cached_count" + elif key == "cachedCountFmt": + suggest = "cached_count_fmt" + elif key == "cachedDuration": + suggest = "cached_duration" + elif key == "cachedPct": + suggest = "cached_pct" + elif key == "computeTimeFmt": + suggest = "compute_time_fmt" + elif key == "failedCount": + suggest = "failed_count" + elif key == "failedCountFmt": + suggest = "failed_count_fmt" + elif key == "failedDuration": + suggest = "failed_duration" + elif key == "failedPct": + suggest = "failed_pct" + elif key == "ignoredCount": + suggest = "ignored_count" + elif key == "ignoredCountFmt": + suggest = "ignored_count_fmt" + elif key == "ignoredPct": + suggest = "ignored_pct" + elif key == "succeedCount": + suggest = "succeed_count" + elif key == "succeedCountFmt": + suggest = "succeed_count_fmt" + elif key == "succeedDuration": + suggest = "succeed_duration" + elif key == "succeedPct": + suggest = "succeed_pct" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in WorkflowsWorkflowStats. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + WorkflowsWorkflowStats.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + WorkflowsWorkflowStats.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + cached_count: Optional[_builtins.float] = None, + cached_count_fmt: Optional[_builtins.str] = None, + cached_duration: Optional[_builtins.float] = None, + cached_pct: Optional[_builtins.float] = None, + compute_time_fmt: Optional[_builtins.str] = None, + failed_count: Optional[_builtins.float] = None, + failed_count_fmt: Optional[_builtins.str] = None, + failed_duration: Optional[_builtins.float] = None, + failed_pct: Optional[_builtins.float] = None, + ignored_count: Optional[_builtins.float] = None, + ignored_count_fmt: Optional[_builtins.str] = None, + ignored_pct: Optional[_builtins.float] = None, + succeed_count: Optional[_builtins.float] = None, + succeed_count_fmt: Optional[_builtins.str] = None, + succeed_duration: Optional[_builtins.float] = None, + succeed_pct: Optional[_builtins.float] = None): + if cached_count is not None: + pulumi.set(__self__, "cached_count", cached_count) + if cached_count_fmt is not None: + pulumi.set(__self__, "cached_count_fmt", cached_count_fmt) + if cached_duration is not None: + pulumi.set(__self__, "cached_duration", cached_duration) + if cached_pct is not None: + pulumi.set(__self__, "cached_pct", cached_pct) + if compute_time_fmt is not None: + pulumi.set(__self__, "compute_time_fmt", compute_time_fmt) + if failed_count is not None: + pulumi.set(__self__, "failed_count", failed_count) + if failed_count_fmt is not None: + pulumi.set(__self__, "failed_count_fmt", failed_count_fmt) + if failed_duration is not None: + pulumi.set(__self__, "failed_duration", failed_duration) + if failed_pct is not None: + pulumi.set(__self__, "failed_pct", failed_pct) + if ignored_count is not None: + pulumi.set(__self__, "ignored_count", ignored_count) + if ignored_count_fmt is not None: + pulumi.set(__self__, "ignored_count_fmt", ignored_count_fmt) + if ignored_pct is not None: + pulumi.set(__self__, "ignored_pct", ignored_pct) + if succeed_count is not None: + pulumi.set(__self__, "succeed_count", succeed_count) + if succeed_count_fmt is not None: + pulumi.set(__self__, "succeed_count_fmt", succeed_count_fmt) + if succeed_duration is not None: + pulumi.set(__self__, "succeed_duration", succeed_duration) + if succeed_pct is not None: + pulumi.set(__self__, "succeed_pct", succeed_pct) + + @_builtins.property + @pulumi.getter(name="cachedCount") + def cached_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached_count") + + @_builtins.property + @pulumi.getter(name="cachedCountFmt") + def cached_count_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "cached_count_fmt") + + @_builtins.property + @pulumi.getter(name="cachedDuration") + def cached_duration(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached_duration") + + @_builtins.property + @pulumi.getter(name="cachedPct") + def cached_pct(self) -> Optional[_builtins.float]: + return pulumi.get(self, "cached_pct") + + @_builtins.property + @pulumi.getter(name="computeTimeFmt") + def compute_time_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "compute_time_fmt") + + @_builtins.property + @pulumi.getter(name="failedCount") + def failed_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed_count") + + @_builtins.property + @pulumi.getter(name="failedCountFmt") + def failed_count_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "failed_count_fmt") + + @_builtins.property + @pulumi.getter(name="failedDuration") + def failed_duration(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed_duration") + + @_builtins.property + @pulumi.getter(name="failedPct") + def failed_pct(self) -> Optional[_builtins.float]: + return pulumi.get(self, "failed_pct") + + @_builtins.property + @pulumi.getter(name="ignoredCount") + def ignored_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ignored_count") + + @_builtins.property + @pulumi.getter(name="ignoredCountFmt") + def ignored_count_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "ignored_count_fmt") + + @_builtins.property + @pulumi.getter(name="ignoredPct") + def ignored_pct(self) -> Optional[_builtins.float]: + return pulumi.get(self, "ignored_pct") + + @_builtins.property + @pulumi.getter(name="succeedCount") + def succeed_count(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeed_count") + + @_builtins.property + @pulumi.getter(name="succeedCountFmt") + def succeed_count_fmt(self) -> Optional[_builtins.str]: + return pulumi.get(self, "succeed_count_fmt") + + @_builtins.property + @pulumi.getter(name="succeedDuration") + def succeed_duration(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeed_duration") + + @_builtins.property + @pulumi.getter(name="succeedPct") + def succeed_pct(self) -> Optional[_builtins.float]: + return pulumi.get(self, "succeed_pct") + + +@pulumi.output_type +class GetActionConfigResult(dict): + def __init__(__self__, *, + github: 'outputs.GetActionConfigGithubResult', + tower: 'outputs.GetActionConfigTowerResult'): + pulumi.set(__self__, "github", github) + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> 'outputs.GetActionConfigGithubResult': + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def tower(self) -> 'outputs.GetActionConfigTowerResult': + return pulumi.get(self, "tower") + + +@pulumi.output_type +class GetActionConfigGithubResult(dict): + def __init__(__self__, *, + discriminator: _builtins.str, + events: Sequence[_builtins.str]): + pulumi.set(__self__, "discriminator", discriminator) + pulumi.set(__self__, "events", events) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> _builtins.str: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter + def events(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "events") + + +@pulumi.output_type +class GetActionConfigTowerResult(dict): + def __init__(__self__, *, + discriminator: _builtins.str): + pulumi.set(__self__, "discriminator", discriminator) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> _builtins.str: + return pulumi.get(self, "discriminator") + + +@pulumi.output_type +class GetActionEventResult(dict): + def __init__(__self__, *, + github: 'outputs.GetActionEventGithubResult', + tower: 'outputs.GetActionEventTowerResult'): + pulumi.set(__self__, "github", github) + pulumi.set(__self__, "tower", tower) + + @_builtins.property + @pulumi.getter + def github(self) -> 'outputs.GetActionEventGithubResult': + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def tower(self) -> 'outputs.GetActionEventTowerResult': + return pulumi.get(self, "tower") + + +@pulumi.output_type +class GetActionEventGithubResult(dict): + def __init__(__self__, *, + commit_id: _builtins.str, + commit_message: _builtins.str, + discriminator: _builtins.str, + pusher_email: _builtins.str, + pusher_name: _builtins.str, + ref: _builtins.str, + timestamp: _builtins.str): + pulumi.set(__self__, "commit_id", commit_id) + pulumi.set(__self__, "commit_message", commit_message) + pulumi.set(__self__, "discriminator", discriminator) + pulumi.set(__self__, "pusher_email", pusher_email) + pulumi.set(__self__, "pusher_name", pusher_name) + pulumi.set(__self__, "ref", ref) + pulumi.set(__self__, "timestamp", timestamp) + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> _builtins.str: + return pulumi.get(self, "commit_id") + + @_builtins.property + @pulumi.getter(name="commitMessage") + def commit_message(self) -> _builtins.str: + return pulumi.get(self, "commit_message") + + @_builtins.property + @pulumi.getter + def discriminator(self) -> _builtins.str: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter(name="pusherEmail") + def pusher_email(self) -> _builtins.str: + return pulumi.get(self, "pusher_email") + + @_builtins.property + @pulumi.getter(name="pusherName") + def pusher_name(self) -> _builtins.str: + return pulumi.get(self, "pusher_name") + + @_builtins.property + @pulumi.getter + def ref(self) -> _builtins.str: + return pulumi.get(self, "ref") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> _builtins.str: + return pulumi.get(self, "timestamp") + + +@pulumi.output_type +class GetActionEventTowerResult(dict): + def __init__(__self__, *, + discriminator: _builtins.str, + timestamp: _builtins.str, + workflow_id: _builtins.str): + pulumi.set(__self__, "discriminator", discriminator) + pulumi.set(__self__, "timestamp", timestamp) + pulumi.set(__self__, "workflow_id", workflow_id) + + @_builtins.property + @pulumi.getter + def discriminator(self) -> _builtins.str: + return pulumi.get(self, "discriminator") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> _builtins.str: + return pulumi.get(self, "timestamp") + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> _builtins.str: + return pulumi.get(self, "workflow_id") + + +@pulumi.output_type +class GetActionLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchResult(dict): + def __init__(__self__, *, + compute_env: 'outputs.GetActionLaunchComputeEnvResult', + config_profiles: Sequence[_builtins.str], + config_text: _builtins.str, + date_created: _builtins.str, + entry_name: _builtins.str, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + id: _builtins.str, + last_updated: _builtins.str, + launch_container: _builtins.str, + main_script: _builtins.str, + optimization_id: _builtins.str, + optimization_targets: _builtins.str, + params_text: _builtins.str, + pipeline: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + pull_latest: _builtins.bool, + resume: _builtins.bool, + resume_launch_id: _builtins.str, + revision: _builtins.str, + run_name: _builtins.str, + schema_name: _builtins.str, + session_id: _builtins.str, + stub_run: _builtins.bool, + tower_config: _builtins.str, + user_secrets: Sequence[_builtins.str], + work_dir: _builtins.str, + workspace_secrets: Sequence[_builtins.str]): + """ + :param _builtins.str post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + :param _builtins.str pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + pulumi.set(__self__, "compute_env", compute_env) + pulumi.set(__self__, "config_profiles", config_profiles) + pulumi.set(__self__, "config_text", config_text) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "entry_name", entry_name) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "launch_container", launch_container) + pulumi.set(__self__, "main_script", main_script) + pulumi.set(__self__, "optimization_id", optimization_id) + pulumi.set(__self__, "optimization_targets", optimization_targets) + pulumi.set(__self__, "params_text", params_text) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "pull_latest", pull_latest) + pulumi.set(__self__, "resume", resume) + pulumi.set(__self__, "resume_launch_id", resume_launch_id) + pulumi.set(__self__, "revision", revision) + pulumi.set(__self__, "run_name", run_name) + pulumi.set(__self__, "schema_name", schema_name) + pulumi.set(__self__, "session_id", session_id) + pulumi.set(__self__, "stub_run", stub_run) + pulumi.set(__self__, "tower_config", tower_config) + pulumi.set(__self__, "user_secrets", user_secrets) + pulumi.set(__self__, "work_dir", work_dir) + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> 'outputs.GetActionLaunchComputeEnvResult': + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "config_profiles") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> _builtins.str: + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> _builtins.str: + return pulumi.get(self, "entry_name") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> _builtins.str: + return pulumi.get(self, "launch_container") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> _builtins.str: + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> _builtins.str: + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> _builtins.str: + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> _builtins.str: + return pulumi.get(self, "params_text") + + @_builtins.property + @pulumi.getter + def pipeline(self) -> _builtins.str: + return pulumi.get(self, "pipeline") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> _builtins.bool: + return pulumi.get(self, "pull_latest") + + @_builtins.property + @pulumi.getter + def resume(self) -> _builtins.bool: + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter(name="resumeLaunchId") + def resume_launch_id(self) -> _builtins.str: + return pulumi.get(self, "resume_launch_id") + + @_builtins.property + @pulumi.getter + def revision(self) -> _builtins.str: + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> _builtins.str: + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> _builtins.str: + return pulumi.get(self, "schema_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> _builtins.str: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> _builtins.bool: + return pulumi.get(self, "stub_run") + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> _builtins.str: + return pulumi.get(self, "tower_config") + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "user_secrets") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "workspace_secrets") + + +@pulumi.output_type +class GetActionLaunchComputeEnvResult(dict): + def __init__(__self__, *, + compute_env_id: _builtins.str, + config: 'outputs.GetActionLaunchComputeEnvConfigResult', + credentials_id: _builtins.str, + date_created: _builtins.str, + deleted: _builtins.bool, + description: _builtins.str, + last_updated: _builtins.str, + last_used: _builtins.str, + message: _builtins.str, + name: _builtins.str, + org_id: _builtins.float, + platform: _builtins.str, + primary: _builtins.bool, + status: _builtins.str, + workspace_id: _builtins.float): + """ + :param 'GetActionLaunchComputeEnvConfigArgs' config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "deleted", deleted) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "last_used", last_used) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "org_id", org_id) + pulumi.set(__self__, "platform", platform) + pulumi.set(__self__, "primary", primary) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def config(self) -> 'outputs.GetActionLaunchComputeEnvConfigResult': + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def primary(self) -> _builtins.bool: + return pulumi.get(self, "primary") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigResult(dict): + def __init__(__self__, *, + altair_platform: 'outputs.GetActionLaunchComputeEnvConfigAltairPlatformResult', + aws_batch: 'outputs.GetActionLaunchComputeEnvConfigAwsBatchResult', + aws_cloud: 'outputs.GetActionLaunchComputeEnvConfigAwsCloudResult', + azure_batch: 'outputs.GetActionLaunchComputeEnvConfigAzureBatchResult', + eks_platform: 'outputs.GetActionLaunchComputeEnvConfigEksPlatformResult', + gke_platform: 'outputs.GetActionLaunchComputeEnvConfigGkePlatformResult', + google_batch: 'outputs.GetActionLaunchComputeEnvConfigGoogleBatchResult', + google_lifesciences: 'outputs.GetActionLaunchComputeEnvConfigGoogleLifesciencesResult', + k8s_platform: 'outputs.GetActionLaunchComputeEnvConfigK8sPlatformResult', + lsf_platform: 'outputs.GetActionLaunchComputeEnvConfigLsfPlatformResult', + moab_platform: 'outputs.GetActionLaunchComputeEnvConfigMoabPlatformResult', + seqeracompute_platform: 'outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformResult', + slurm_platform: 'outputs.GetActionLaunchComputeEnvConfigSlurmPlatformResult', + uge_platform: 'outputs.GetActionLaunchComputeEnvConfigUgePlatformResult'): + pulumi.set(__self__, "altair_platform", altair_platform) + pulumi.set(__self__, "aws_batch", aws_batch) + pulumi.set(__self__, "aws_cloud", aws_cloud) + pulumi.set(__self__, "azure_batch", azure_batch) + pulumi.set(__self__, "eks_platform", eks_platform) + pulumi.set(__self__, "gke_platform", gke_platform) + pulumi.set(__self__, "google_batch", google_batch) + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + pulumi.set(__self__, "k8s_platform", k8s_platform) + pulumi.set(__self__, "lsf_platform", lsf_platform) + pulumi.set(__self__, "moab_platform", moab_platform) + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + pulumi.set(__self__, "slurm_platform", slurm_platform) + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigAltairPlatformResult': + return pulumi.get(self, "altair_platform") + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> 'outputs.GetActionLaunchComputeEnvConfigAwsBatchResult': + return pulumi.get(self, "aws_batch") + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> 'outputs.GetActionLaunchComputeEnvConfigAwsCloudResult': + return pulumi.get(self, "aws_cloud") + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> 'outputs.GetActionLaunchComputeEnvConfigAzureBatchResult': + return pulumi.get(self, "azure_batch") + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigEksPlatformResult': + return pulumi.get(self, "eks_platform") + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigGkePlatformResult': + return pulumi.get(self, "gke_platform") + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> 'outputs.GetActionLaunchComputeEnvConfigGoogleBatchResult': + return pulumi.get(self, "google_batch") + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> 'outputs.GetActionLaunchComputeEnvConfigGoogleLifesciencesResult': + return pulumi.get(self, "google_lifesciences") + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigK8sPlatformResult': + return pulumi.get(self, "k8s_platform") + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigLsfPlatformResult': + return pulumi.get(self, "lsf_platform") + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigMoabPlatformResult': + return pulumi.get(self, "moab_platform") + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformResult': + return pulumi.get(self, "seqeracompute_platform") + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigSlurmPlatformResult': + return pulumi.get(self, "slurm_platform") + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> 'outputs.GetActionLaunchComputeEnvConfigUgePlatformResult': + return pulumi.get(self, "uge_platform") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAltairPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAltairPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsBatchResult(dict): + def __init__(__self__, *, + cli_path: _builtins.str, + compute_job_role: _builtins.str, + compute_queue: _builtins.str, + dragen_instance_type: _builtins.str, + dragen_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigAwsBatchEnvironmentResult'], + execution_role: _builtins.str, + forge: 'outputs.GetActionLaunchComputeEnvConfigAwsBatchForgeResult', + fusion2_enabled: _builtins.bool, + fusion_snapshots: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_job_role: _builtins.str, + head_queue: _builtins.str, + log_group: _builtins.str, + lustre_id: _builtins.str, + nextflow_config: _builtins.str, + nvnme_storage_enabled: _builtins.bool, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + storage_type: _builtins.str, + volumes: Sequence[_builtins.str], + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigAwsBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cli_path", cli_path) + pulumi.set(__self__, "compute_job_role", compute_job_role) + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "dragen_queue", dragen_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "execution_role", execution_role) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_job_role", head_job_role) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "lustre_id", lustre_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "storage_type", storage_type) + pulumi.set(__self__, "volumes", volumes) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> _builtins.str: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> _builtins.str: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> _builtins.str: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigAwsBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> _builtins.str: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetActionLaunchComputeEnvConfigAwsBatchForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> _builtins.bool: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> _builtins.str: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> _builtins.str: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> _builtins.bool: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> _builtins.str: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsBatchForgeResult(dict): + def __init__(__self__, *, + alloc_strategy: _builtins.str, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + bid_percentage: _builtins.float, + dispose_on_deletion: _builtins.bool, + dragen_ami_id: _builtins.str, + dragen_enabled: _builtins.bool, + dragen_instance_type: _builtins.str, + ebs_auto_scale: _builtins.bool, + ebs_block_size: _builtins.float, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + ecs_config: _builtins.str, + efs_create: _builtins.bool, + efs_id: _builtins.str, + efs_mount: _builtins.str, + fargate_head_enabled: _builtins.bool, + fsx_mount: _builtins.str, + fsx_name: _builtins.str, + fsx_size: _builtins.float, + fusion_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_types: Sequence[_builtins.str], + max_cpus: _builtins.float, + min_cpus: _builtins.float, + security_groups: Sequence[_builtins.str], + subnets: Sequence[_builtins.str], + type: _builtins.str, + vpc_id: _builtins.str): + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "bid_percentage", bid_percentage) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "ecs_config", ecs_config) + pulumi.set(__self__, "efs_create", efs_create) + pulumi.set(__self__, "efs_id", efs_id) + pulumi.set(__self__, "efs_mount", efs_mount) + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + pulumi.set(__self__, "fsx_mount", fsx_mount) + pulumi.set(__self__, "fsx_name", fsx_name) + pulumi.set(__self__, "fsx_size", fsx_size) + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_types", instance_types) + pulumi.set(__self__, "max_cpus", max_cpus) + pulumi.set(__self__, "min_cpus", min_cpus) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnets", subnets) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> _builtins.str: + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> _builtins.float: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> _builtins.str: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> _builtins.bool: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> _builtins.str: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> _builtins.bool: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> _builtins.str: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> _builtins.str: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> _builtins.str: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> _builtins.str: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> _builtins.float: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> _builtins.float: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> _builtins.float: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> _builtins.str: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsCloudResult(dict): + def __init__(__self__, *, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigAwsCloudEnvironmentResult'], + fusion2_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_profile_arn: _builtins.str, + instance_type: _builtins.str, + log_group: _builtins.str, + nextflow_config: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + security_groups: Sequence[_builtins.str], + subnet_id: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigAwsCloudEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + pulumi.set(__self__, "instance_type", instance_type) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnet_id", subnet_id) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigAwsCloudEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> _builtins.str: + return pulumi.get(self, "instance_profile_arn") + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> _builtins.str: + return pulumi.get(self, "instance_type") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> _builtins.str: + return pulumi.get(self, "subnet_id") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAwsCloudEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAzureBatchResult(dict): + def __init__(__self__, *, + auto_pool_mode: _builtins.bool, + delete_jobs_on_completion: _builtins.str, + delete_pools_on_completion: _builtins.bool, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigAzureBatchEnvironmentResult'], + forge: 'outputs.GetActionLaunchComputeEnvConfigAzureBatchForgeResult', + fusion2_enabled: _builtins.bool, + head_pool: _builtins.str, + managed_identity_client_id: _builtins.str, + nextflow_config: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + token_duration: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigAzureBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_pool", head_pool) + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "token_duration", token_duration) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> _builtins.bool: + return pulumi.get(self, "auto_pool_mode") + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> _builtins.str: + return pulumi.get(self, "delete_jobs_on_completion") + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> _builtins.bool: + return pulumi.get(self, "delete_pools_on_completion") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigAzureBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetActionLaunchComputeEnvConfigAzureBatchForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> _builtins.str: + return pulumi.get(self, "head_pool") + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> _builtins.str: + return pulumi.get(self, "managed_identity_client_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> _builtins.str: + return pulumi.get(self, "token_duration") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAzureBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigAzureBatchForgeResult(dict): + def __init__(__self__, *, + auto_scale: _builtins.bool, + container_reg_ids: Sequence[_builtins.str], + dispose_on_deletion: _builtins.bool, + vm_count: _builtins.float, + vm_type: _builtins.str): + pulumi.set(__self__, "auto_scale", auto_scale) + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "vm_count", vm_count) + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "auto_scale") + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "container_reg_ids") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> _builtins.float: + return pulumi.get(self, "vm_count") + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> _builtins.str: + return pulumi.get(self, "vm_type") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigEksPlatformResult(dict): + def __init__(__self__, *, + cluster_name: _builtins.str, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigEksPlatformEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param _builtins.str cluster_name: The AWS EKS cluster name + :param Sequence['GetActionLaunchComputeEnvConfigEksPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: AWS region + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> _builtins.str: + """ + The AWS EKS cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigEksPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + AWS region + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigEksPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGkePlatformResult(dict): + def __init__(__self__, *, + cluster_name: _builtins.str, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigGkePlatformEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param _builtins.str cluster_name: The GKE cluster name + :param Sequence['GetActionLaunchComputeEnvConfigGkePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: The GKE cluster region - or - zone + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> _builtins.str: + """ + The GKE cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigGkePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + The GKE cluster region - or - zone + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGkePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGoogleBatchResult(dict): + def __init__(__self__, *, + boot_disk_size_gb: _builtins.float, + compute_jobs_instance_template: _builtins.str, + copy_image: _builtins.str, + cpu_platform: _builtins.str, + debug_mode: _builtins.float, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_instance_template: _builtins.str, + head_job_memory_mb: _builtins.float, + labels: Mapping[str, _builtins.str], + location: _builtins.str, + machine_type: _builtins.str, + network: _builtins.str, + nextflow_config: _builtins.str, + nfs_mount: _builtins.str, + nfs_target: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + project_id: _builtins.str, + service_account: _builtins.str, + spot: _builtins.bool, + ssh_daemon: _builtins.bool, + ssh_image: _builtins.str, + subnetwork: _builtins.str, + use_private_address: _builtins.bool, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + pulumi.set(__self__, "copy_image", copy_image) + pulumi.set(__self__, "cpu_platform", cpu_platform) + pulumi.set(__self__, "debug_mode", debug_mode) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "location", location) + pulumi.set(__self__, "machine_type", machine_type) + pulumi.set(__self__, "network", network) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nfs_mount", nfs_mount) + pulumi.set(__self__, "nfs_target", nfs_target) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "service_account", service_account) + pulumi.set(__self__, "spot", spot) + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + pulumi.set(__self__, "ssh_image", ssh_image) + pulumi.set(__self__, "subnetwork", subnetwork) + pulumi.set(__self__, "use_private_address", use_private_address) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> _builtins.float: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> _builtins.str: + return pulumi.get(self, "compute_jobs_instance_template") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> _builtins.str: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> _builtins.str: + return pulumi.get(self, "cpu_platform") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> _builtins.float: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> _builtins.str: + return pulumi.get(self, "head_job_instance_template") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> _builtins.str: + return pulumi.get(self, "machine_type") + + @_builtins.property + @pulumi.getter + def network(self) -> _builtins.str: + return pulumi.get(self, "network") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> _builtins.str: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> _builtins.str: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> _builtins.str: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> _builtins.str: + return pulumi.get(self, "service_account") + + @_builtins.property + @pulumi.getter + def spot(self) -> _builtins.bool: + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> _builtins.bool: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> _builtins.str: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> _builtins.str: + return pulumi.get(self, "subnetwork") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> _builtins.bool: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGoogleBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGoogleLifesciencesResult(dict): + def __init__(__self__, *, + boot_disk_size_gb: _builtins.float, + copy_image: _builtins.str, + debug_mode: _builtins.float, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentResult'], + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + labels: Mapping[str, _builtins.str], + location: _builtins.str, + nextflow_config: _builtins.str, + nfs_mount: _builtins.str, + nfs_target: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + preemptible: _builtins.bool, + project_id: _builtins.str, + region: _builtins.str, + ssh_daemon: _builtins.bool, + ssh_image: _builtins.str, + use_private_address: _builtins.bool, + work_dir: _builtins.str, + zones: Sequence[_builtins.str]): + """ + :param Sequence['GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + pulumi.set(__self__, "copy_image", copy_image) + pulumi.set(__self__, "debug_mode", debug_mode) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "location", location) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nfs_mount", nfs_mount) + pulumi.set(__self__, "nfs_target", nfs_target) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "preemptible", preemptible) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + pulumi.set(__self__, "ssh_image", ssh_image) + pulumi.set(__self__, "use_private_address", use_private_address) + pulumi.set(__self__, "work_dir", work_dir) + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> _builtins.float: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> _builtins.str: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> _builtins.float: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> _builtins.str: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> _builtins.str: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def preemptible(self) -> _builtins.bool: + return pulumi.get(self, "preemptible") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> _builtins.str: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> _builtins.bool: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> _builtins.str: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> _builtins.bool: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def zones(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "zones") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigGoogleLifesciencesEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigK8sPlatformResult(dict): + def __init__(__self__, *, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentResult'], + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigK8sPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigLsfPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + per_job_mem_limit: _builtins.bool, + per_task_reserve: _builtins.bool, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + unit_for_limits: _builtins.str, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> _builtins.bool: + return pulumi.get(self, "per_job_mem_limit") + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> _builtins.bool: + return pulumi.get(self, "per_task_reserve") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> _builtins.str: + return pulumi.get(self, "unit_for_limits") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigLsfPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigMoabPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigMoabPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSeqeracomputePlatformResult(dict): + def __init__(__self__, *, + cli_path: _builtins.str, + compute_job_role: _builtins.str, + compute_queue: _builtins.str, + dragen_instance_type: _builtins.str, + dragen_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentResult'], + execution_role: _builtins.str, + forge: 'outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformForgeResult', + fusion2_enabled: _builtins.bool, + fusion_snapshots: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_job_role: _builtins.str, + head_queue: _builtins.str, + log_group: _builtins.str, + lustre_id: _builtins.str, + nextflow_config: _builtins.str, + nvnme_storage_enabled: _builtins.bool, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + storage_type: _builtins.str, + volumes: Sequence[_builtins.str], + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cli_path", cli_path) + pulumi.set(__self__, "compute_job_role", compute_job_role) + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "dragen_queue", dragen_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "execution_role", execution_role) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_job_role", head_job_role) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "lustre_id", lustre_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "storage_type", storage_type) + pulumi.set(__self__, "volumes", volumes) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> _builtins.str: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> _builtins.str: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> _builtins.str: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> _builtins.str: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetActionLaunchComputeEnvConfigSeqeracomputePlatformForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> _builtins.bool: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> _builtins.str: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> _builtins.str: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> _builtins.bool: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> _builtins.str: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSeqeracomputePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSeqeracomputePlatformForgeResult(dict): + def __init__(__self__, *, + alloc_strategy: _builtins.str, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + bid_percentage: _builtins.float, + dispose_on_deletion: _builtins.bool, + dragen_ami_id: _builtins.str, + dragen_enabled: _builtins.bool, + dragen_instance_type: _builtins.str, + ebs_auto_scale: _builtins.bool, + ebs_block_size: _builtins.float, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + ecs_config: _builtins.str, + efs_create: _builtins.bool, + efs_id: _builtins.str, + efs_mount: _builtins.str, + fargate_head_enabled: _builtins.bool, + fsx_mount: _builtins.str, + fsx_name: _builtins.str, + fsx_size: _builtins.float, + fusion_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_types: Sequence[_builtins.str], + max_cpus: _builtins.float, + min_cpus: _builtins.float, + security_groups: Sequence[_builtins.str], + subnets: Sequence[_builtins.str], + type: _builtins.str, + vpc_id: _builtins.str): + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "bid_percentage", bid_percentage) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "ecs_config", ecs_config) + pulumi.set(__self__, "efs_create", efs_create) + pulumi.set(__self__, "efs_id", efs_id) + pulumi.set(__self__, "efs_mount", efs_mount) + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + pulumi.set(__self__, "fsx_mount", fsx_mount) + pulumi.set(__self__, "fsx_name", fsx_name) + pulumi.set(__self__, "fsx_size", fsx_size) + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_types", instance_types) + pulumi.set(__self__, "max_cpus", max_cpus) + pulumi.set(__self__, "min_cpus", min_cpus) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnets", subnets) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> _builtins.str: + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> _builtins.float: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> _builtins.str: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> _builtins.bool: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> _builtins.str: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> _builtins.bool: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> _builtins.str: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> _builtins.str: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> _builtins.str: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> _builtins.str: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> _builtins.float: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> _builtins.float: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> _builtins.float: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> _builtins.str: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSlurmPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigSlurmPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigUgePlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetActionLaunchComputeEnvConfigUgePlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetActionLaunchComputeEnvConfigUgePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetActionLaunchComputeEnvConfigUgePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetActionLaunchComputeEnvConfigUgePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvResult(dict): + def __init__(__self__, *, + compute_env_id: _builtins.str, + config: 'outputs.GetComputeEnvComputeEnvConfigResult', + credentials_id: _builtins.str, + date_created: _builtins.str, + deleted: _builtins.bool, + description: _builtins.str, + labels: Sequence['outputs.GetComputeEnvComputeEnvLabelResult'], + last_updated: _builtins.str, + last_used: _builtins.str, + managed_identity_id: _builtins.str, + message: _builtins.str, + name: _builtins.str, + org_id: _builtins.float, + platform: _builtins.str, + primary: _builtins.bool, + status: _builtins.str, + workspace_id: _builtins.float): + """ + :param 'GetComputeEnvComputeEnvConfigArgs' config: Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "deleted", deleted) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "last_used", last_used) + pulumi.set(__self__, "managed_identity_id", managed_identity_id) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "org_id", org_id) + pulumi.set(__self__, "platform", platform) + pulumi.set(__self__, "primary", primary) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> _builtins.str: + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def config(self) -> 'outputs.GetComputeEnvComputeEnvConfigResult': + """ + Configuration settings for compute environments including work directories, + pre/post run scripts, and environment-specific parameters. + """ + return pulumi.get(self, "config") + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def labels(self) -> Sequence['outputs.GetComputeEnvComputeEnvLabelResult']: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> _builtins.str: + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter(name="managedIdentityId") + def managed_identity_id(self) -> _builtins.str: + return pulumi.get(self, "managed_identity_id") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def primary(self) -> _builtins.bool: + return pulumi.get(self, "primary") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigResult(dict): + def __init__(__self__, *, + altair_platform: 'outputs.GetComputeEnvComputeEnvConfigAltairPlatformResult', + aws_batch: 'outputs.GetComputeEnvComputeEnvConfigAwsBatchResult', + aws_cloud: 'outputs.GetComputeEnvComputeEnvConfigAwsCloudResult', + azure_batch: 'outputs.GetComputeEnvComputeEnvConfigAzureBatchResult', + eks_platform: 'outputs.GetComputeEnvComputeEnvConfigEksPlatformResult', + gke_platform: 'outputs.GetComputeEnvComputeEnvConfigGkePlatformResult', + google_batch: 'outputs.GetComputeEnvComputeEnvConfigGoogleBatchResult', + google_lifesciences: 'outputs.GetComputeEnvComputeEnvConfigGoogleLifesciencesResult', + k8s_platform: 'outputs.GetComputeEnvComputeEnvConfigK8sPlatformResult', + lsf_platform: 'outputs.GetComputeEnvComputeEnvConfigLsfPlatformResult', + moab_platform: 'outputs.GetComputeEnvComputeEnvConfigMoabPlatformResult', + seqeracompute_platform: 'outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformResult', + slurm_platform: 'outputs.GetComputeEnvComputeEnvConfigSlurmPlatformResult', + uge_platform: 'outputs.GetComputeEnvComputeEnvConfigUgePlatformResult'): + pulumi.set(__self__, "altair_platform", altair_platform) + pulumi.set(__self__, "aws_batch", aws_batch) + pulumi.set(__self__, "aws_cloud", aws_cloud) + pulumi.set(__self__, "azure_batch", azure_batch) + pulumi.set(__self__, "eks_platform", eks_platform) + pulumi.set(__self__, "gke_platform", gke_platform) + pulumi.set(__self__, "google_batch", google_batch) + pulumi.set(__self__, "google_lifesciences", google_lifesciences) + pulumi.set(__self__, "k8s_platform", k8s_platform) + pulumi.set(__self__, "lsf_platform", lsf_platform) + pulumi.set(__self__, "moab_platform", moab_platform) + pulumi.set(__self__, "seqeracompute_platform", seqeracompute_platform) + pulumi.set(__self__, "slurm_platform", slurm_platform) + pulumi.set(__self__, "uge_platform", uge_platform) + + @_builtins.property + @pulumi.getter(name="altairPlatform") + def altair_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigAltairPlatformResult': + return pulumi.get(self, "altair_platform") + + @_builtins.property + @pulumi.getter(name="awsBatch") + def aws_batch(self) -> 'outputs.GetComputeEnvComputeEnvConfigAwsBatchResult': + return pulumi.get(self, "aws_batch") + + @_builtins.property + @pulumi.getter(name="awsCloud") + def aws_cloud(self) -> 'outputs.GetComputeEnvComputeEnvConfigAwsCloudResult': + return pulumi.get(self, "aws_cloud") + + @_builtins.property + @pulumi.getter(name="azureBatch") + def azure_batch(self) -> 'outputs.GetComputeEnvComputeEnvConfigAzureBatchResult': + return pulumi.get(self, "azure_batch") + + @_builtins.property + @pulumi.getter(name="eksPlatform") + def eks_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigEksPlatformResult': + return pulumi.get(self, "eks_platform") + + @_builtins.property + @pulumi.getter(name="gkePlatform") + def gke_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigGkePlatformResult': + return pulumi.get(self, "gke_platform") + + @_builtins.property + @pulumi.getter(name="googleBatch") + def google_batch(self) -> 'outputs.GetComputeEnvComputeEnvConfigGoogleBatchResult': + return pulumi.get(self, "google_batch") + + @_builtins.property + @pulumi.getter(name="googleLifesciences") + def google_lifesciences(self) -> 'outputs.GetComputeEnvComputeEnvConfigGoogleLifesciencesResult': + return pulumi.get(self, "google_lifesciences") + + @_builtins.property + @pulumi.getter(name="k8sPlatform") + def k8s_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigK8sPlatformResult': + return pulumi.get(self, "k8s_platform") + + @_builtins.property + @pulumi.getter(name="lsfPlatform") + def lsf_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigLsfPlatformResult': + return pulumi.get(self, "lsf_platform") + + @_builtins.property + @pulumi.getter(name="moabPlatform") + def moab_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigMoabPlatformResult': + return pulumi.get(self, "moab_platform") + + @_builtins.property + @pulumi.getter(name="seqeracomputePlatform") + def seqeracompute_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformResult': + return pulumi.get(self, "seqeracompute_platform") + + @_builtins.property + @pulumi.getter(name="slurmPlatform") + def slurm_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigSlurmPlatformResult': + return pulumi.get(self, "slurm_platform") + + @_builtins.property + @pulumi.getter(name="ugePlatform") + def uge_platform(self) -> 'outputs.GetComputeEnvComputeEnvConfigUgePlatformResult': + return pulumi.get(self, "uge_platform") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAltairPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAltairPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsBatchResult(dict): + def __init__(__self__, *, + cli_path: _builtins.str, + compute_job_role: _builtins.str, + compute_queue: _builtins.str, + dragen_instance_type: _builtins.str, + dragen_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigAwsBatchEnvironmentResult'], + execution_role: _builtins.str, + forge: 'outputs.GetComputeEnvComputeEnvConfigAwsBatchForgeResult', + fusion2_enabled: _builtins.bool, + fusion_snapshots: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_job_role: _builtins.str, + head_queue: _builtins.str, + log_group: _builtins.str, + lustre_id: _builtins.str, + nextflow_config: _builtins.str, + nvnme_storage_enabled: _builtins.bool, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + storage_type: _builtins.str, + volumes: Sequence[_builtins.str], + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigAwsBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cli_path", cli_path) + pulumi.set(__self__, "compute_job_role", compute_job_role) + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "dragen_queue", dragen_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "execution_role", execution_role) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_job_role", head_job_role) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "lustre_id", lustre_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "storage_type", storage_type) + pulumi.set(__self__, "volumes", volumes) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> _builtins.str: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> _builtins.str: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> _builtins.str: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigAwsBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> _builtins.str: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetComputeEnvComputeEnvConfigAwsBatchForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> _builtins.bool: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> _builtins.str: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> _builtins.str: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> _builtins.bool: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> _builtins.str: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsBatchForgeResult(dict): + def __init__(__self__, *, + alloc_strategy: _builtins.str, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + bid_percentage: _builtins.float, + dispose_on_deletion: _builtins.bool, + dragen_ami_id: _builtins.str, + dragen_enabled: _builtins.bool, + dragen_instance_type: _builtins.str, + ebs_auto_scale: _builtins.bool, + ebs_block_size: _builtins.float, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + ecs_config: _builtins.str, + efs_create: _builtins.bool, + efs_id: _builtins.str, + efs_mount: _builtins.str, + fargate_head_enabled: _builtins.bool, + fsx_mount: _builtins.str, + fsx_name: _builtins.str, + fsx_size: _builtins.float, + fusion_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_types: Sequence[_builtins.str], + max_cpus: _builtins.float, + min_cpus: _builtins.float, + security_groups: Sequence[_builtins.str], + subnets: Sequence[_builtins.str], + type: _builtins.str, + vpc_id: _builtins.str): + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "bid_percentage", bid_percentage) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "ecs_config", ecs_config) + pulumi.set(__self__, "efs_create", efs_create) + pulumi.set(__self__, "efs_id", efs_id) + pulumi.set(__self__, "efs_mount", efs_mount) + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + pulumi.set(__self__, "fsx_mount", fsx_mount) + pulumi.set(__self__, "fsx_name", fsx_name) + pulumi.set(__self__, "fsx_size", fsx_size) + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_types", instance_types) + pulumi.set(__self__, "max_cpus", max_cpus) + pulumi.set(__self__, "min_cpus", min_cpus) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnets", subnets) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> _builtins.str: + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> _builtins.float: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> _builtins.str: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> _builtins.bool: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> _builtins.str: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> _builtins.bool: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> _builtins.str: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> _builtins.str: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> _builtins.str: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> _builtins.str: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> _builtins.float: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> _builtins.float: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> _builtins.float: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> _builtins.str: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsCloudResult(dict): + def __init__(__self__, *, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigAwsCloudEnvironmentResult'], + fusion2_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_profile_arn: _builtins.str, + instance_type: _builtins.str, + log_group: _builtins.str, + nextflow_config: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + security_groups: Sequence[_builtins.str], + subnet_id: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigAwsCloudEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_profile_arn", instance_profile_arn) + pulumi.set(__self__, "instance_type", instance_type) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnet_id", subnet_id) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigAwsCloudEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceProfileArn") + def instance_profile_arn(self) -> _builtins.str: + return pulumi.get(self, "instance_profile_arn") + + @_builtins.property + @pulumi.getter(name="instanceType") + def instance_type(self) -> _builtins.str: + return pulumi.get(self, "instance_type") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter(name="subnetId") + def subnet_id(self) -> _builtins.str: + return pulumi.get(self, "subnet_id") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAwsCloudEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAzureBatchResult(dict): + def __init__(__self__, *, + auto_pool_mode: _builtins.bool, + delete_jobs_on_completion: _builtins.str, + delete_pools_on_completion: _builtins.bool, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigAzureBatchEnvironmentResult'], + forge: 'outputs.GetComputeEnvComputeEnvConfigAzureBatchForgeResult', + fusion2_enabled: _builtins.bool, + head_pool: _builtins.str, + managed_identity_client_id: _builtins.str, + nextflow_config: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + token_duration: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigAzureBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "auto_pool_mode", auto_pool_mode) + pulumi.set(__self__, "delete_jobs_on_completion", delete_jobs_on_completion) + pulumi.set(__self__, "delete_pools_on_completion", delete_pools_on_completion) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_pool", head_pool) + pulumi.set(__self__, "managed_identity_client_id", managed_identity_client_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "token_duration", token_duration) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="autoPoolMode") + @_utilities.deprecated("""Deprecated""") + def auto_pool_mode(self) -> _builtins.bool: + return pulumi.get(self, "auto_pool_mode") + + @_builtins.property + @pulumi.getter(name="deleteJobsOnCompletion") + def delete_jobs_on_completion(self) -> _builtins.str: + return pulumi.get(self, "delete_jobs_on_completion") + + @_builtins.property + @pulumi.getter(name="deletePoolsOnCompletion") + def delete_pools_on_completion(self) -> _builtins.bool: + return pulumi.get(self, "delete_pools_on_completion") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigAzureBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetComputeEnvComputeEnvConfigAzureBatchForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headPool") + def head_pool(self) -> _builtins.str: + return pulumi.get(self, "head_pool") + + @_builtins.property + @pulumi.getter(name="managedIdentityClientId") + def managed_identity_client_id(self) -> _builtins.str: + return pulumi.get(self, "managed_identity_client_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="tokenDuration") + def token_duration(self) -> _builtins.str: + return pulumi.get(self, "token_duration") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAzureBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigAzureBatchForgeResult(dict): + def __init__(__self__, *, + auto_scale: _builtins.bool, + container_reg_ids: Sequence[_builtins.str], + dispose_on_deletion: _builtins.bool, + vm_count: _builtins.float, + vm_type: _builtins.str): + pulumi.set(__self__, "auto_scale", auto_scale) + pulumi.set(__self__, "container_reg_ids", container_reg_ids) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "vm_count", vm_count) + pulumi.set(__self__, "vm_type", vm_type) + + @_builtins.property + @pulumi.getter(name="autoScale") + def auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "auto_scale") + + @_builtins.property + @pulumi.getter(name="containerRegIds") + def container_reg_ids(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "container_reg_ids") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="vmCount") + def vm_count(self) -> _builtins.float: + return pulumi.get(self, "vm_count") + + @_builtins.property + @pulumi.getter(name="vmType") + def vm_type(self) -> _builtins.str: + return pulumi.get(self, "vm_type") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigEksPlatformResult(dict): + def __init__(__self__, *, + cluster_name: _builtins.str, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigEksPlatformEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param _builtins.str cluster_name: The AWS EKS cluster name + :param Sequence['GetComputeEnvComputeEnvConfigEksPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: AWS region + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> _builtins.str: + """ + The AWS EKS cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigEksPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + AWS region + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigEksPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGkePlatformResult(dict): + def __init__(__self__, *, + cluster_name: _builtins.str, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigGkePlatformEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param _builtins.str cluster_name: The GKE cluster name + :param Sequence['GetComputeEnvComputeEnvConfigGkePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str region: The GKE cluster region - or - zone + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> _builtins.str: + """ + The GKE cluster name + """ + return pulumi.get(self, "cluster_name") + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigGkePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + The GKE cluster region - or - zone + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGkePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGoogleBatchResult(dict): + def __init__(__self__, *, + boot_disk_size_gb: _builtins.float, + compute_jobs_instance_template: _builtins.str, + copy_image: _builtins.str, + cpu_platform: _builtins.str, + debug_mode: _builtins.float, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentResult'], + fusion2_enabled: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_instance_template: _builtins.str, + head_job_memory_mb: _builtins.float, + labels: Mapping[str, _builtins.str], + location: _builtins.str, + machine_type: _builtins.str, + network: _builtins.str, + nextflow_config: _builtins.str, + nfs_mount: _builtins.str, + nfs_target: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + project_id: _builtins.str, + service_account: _builtins.str, + spot: _builtins.bool, + ssh_daemon: _builtins.bool, + ssh_image: _builtins.str, + subnetwork: _builtins.str, + use_private_address: _builtins.bool, + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + pulumi.set(__self__, "compute_jobs_instance_template", compute_jobs_instance_template) + pulumi.set(__self__, "copy_image", copy_image) + pulumi.set(__self__, "cpu_platform", cpu_platform) + pulumi.set(__self__, "debug_mode", debug_mode) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_instance_template", head_job_instance_template) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "location", location) + pulumi.set(__self__, "machine_type", machine_type) + pulumi.set(__self__, "network", network) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nfs_mount", nfs_mount) + pulumi.set(__self__, "nfs_target", nfs_target) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "service_account", service_account) + pulumi.set(__self__, "spot", spot) + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + pulumi.set(__self__, "ssh_image", ssh_image) + pulumi.set(__self__, "subnetwork", subnetwork) + pulumi.set(__self__, "use_private_address", use_private_address) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> _builtins.float: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="computeJobsInstanceTemplate") + def compute_jobs_instance_template(self) -> _builtins.str: + return pulumi.get(self, "compute_jobs_instance_template") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> _builtins.str: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="cpuPlatform") + def cpu_platform(self) -> _builtins.str: + return pulumi.get(self, "cpu_platform") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> _builtins.float: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobInstanceTemplate") + def head_job_instance_template(self) -> _builtins.str: + return pulumi.get(self, "head_job_instance_template") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="machineType") + def machine_type(self) -> _builtins.str: + return pulumi.get(self, "machine_type") + + @_builtins.property + @pulumi.getter + def network(self) -> _builtins.str: + return pulumi.get(self, "network") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> _builtins.str: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> _builtins.str: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> _builtins.str: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> _builtins.str: + return pulumi.get(self, "service_account") + + @_builtins.property + @pulumi.getter + def spot(self) -> _builtins.bool: + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> _builtins.bool: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> _builtins.str: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter + def subnetwork(self) -> _builtins.str: + return pulumi.get(self, "subnetwork") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> _builtins.bool: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGoogleBatchEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGoogleLifesciencesResult(dict): + def __init__(__self__, *, + boot_disk_size_gb: _builtins.float, + copy_image: _builtins.str, + debug_mode: _builtins.float, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentResult'], + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + labels: Mapping[str, _builtins.str], + location: _builtins.str, + nextflow_config: _builtins.str, + nfs_mount: _builtins.str, + nfs_target: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + preemptible: _builtins.bool, + project_id: _builtins.str, + region: _builtins.str, + ssh_daemon: _builtins.bool, + ssh_image: _builtins.str, + use_private_address: _builtins.bool, + work_dir: _builtins.str, + zones: Sequence[_builtins.str]): + """ + :param Sequence['GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb) + pulumi.set(__self__, "copy_image", copy_image) + pulumi.set(__self__, "debug_mode", debug_mode) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "location", location) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nfs_mount", nfs_mount) + pulumi.set(__self__, "nfs_target", nfs_target) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "preemptible", preemptible) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "ssh_daemon", ssh_daemon) + pulumi.set(__self__, "ssh_image", ssh_image) + pulumi.set(__self__, "use_private_address", use_private_address) + pulumi.set(__self__, "work_dir", work_dir) + pulumi.set(__self__, "zones", zones) + + @_builtins.property + @pulumi.getter(name="bootDiskSizeGb") + def boot_disk_size_gb(self) -> _builtins.float: + return pulumi.get(self, "boot_disk_size_gb") + + @_builtins.property + @pulumi.getter(name="copyImage") + def copy_image(self) -> _builtins.str: + return pulumi.get(self, "copy_image") + + @_builtins.property + @pulumi.getter(name="debugMode") + def debug_mode(self) -> _builtins.float: + return pulumi.get(self, "debug_mode") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter + def labels(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter + def location(self) -> _builtins.str: + return pulumi.get(self, "location") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nfsMount") + def nfs_mount(self) -> _builtins.str: + return pulumi.get(self, "nfs_mount") + + @_builtins.property + @pulumi.getter(name="nfsTarget") + def nfs_target(self) -> _builtins.str: + return pulumi.get(self, "nfs_target") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def preemptible(self) -> _builtins.bool: + return pulumi.get(self, "preemptible") + + @_builtins.property + @pulumi.getter(name="projectId") + def project_id(self) -> _builtins.str: + return pulumi.get(self, "project_id") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="sshDaemon") + def ssh_daemon(self) -> _builtins.bool: + return pulumi.get(self, "ssh_daemon") + + @_builtins.property + @pulumi.getter(name="sshImage") + def ssh_image(self) -> _builtins.str: + return pulumi.get(self, "ssh_image") + + @_builtins.property + @pulumi.getter(name="usePrivateAddress") + def use_private_address(self) -> _builtins.bool: + return pulumi.get(self, "use_private_address") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def zones(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "zones") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigGoogleLifesciencesEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigK8sPlatformResult(dict): + def __init__(__self__, *, + compute_service_account: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentResult'], + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_pod_spec: _builtins.str, + head_service_account: _builtins.str, + namespace: _builtins.str, + nextflow_config: _builtins.str, + pod_cleanup: _builtins.str, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + server: _builtins.str, + service_pod_spec: _builtins.str, + ssl_cert: _builtins.str, + storage_claim_name: _builtins.str, + storage_mount_path: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_service_account", compute_service_account) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_pod_spec", head_pod_spec) + pulumi.set(__self__, "head_service_account", head_service_account) + pulumi.set(__self__, "namespace", namespace) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "pod_cleanup", pod_cleanup) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "server", server) + pulumi.set(__self__, "service_pod_spec", service_pod_spec) + pulumi.set(__self__, "ssl_cert", ssl_cert) + pulumi.set(__self__, "storage_claim_name", storage_claim_name) + pulumi.set(__self__, "storage_mount_path", storage_mount_path) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeServiceAccount") + def compute_service_account(self) -> _builtins.str: + return pulumi.get(self, "compute_service_account") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headPodSpec") + def head_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "head_pod_spec") + + @_builtins.property + @pulumi.getter(name="headServiceAccount") + def head_service_account(self) -> _builtins.str: + return pulumi.get(self, "head_service_account") + + @_builtins.property + @pulumi.getter + def namespace(self) -> _builtins.str: + return pulumi.get(self, "namespace") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="podCleanup") + def pod_cleanup(self) -> _builtins.str: + return pulumi.get(self, "pod_cleanup") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def server(self) -> _builtins.str: + return pulumi.get(self, "server") + + @_builtins.property + @pulumi.getter(name="servicePodSpec") + def service_pod_spec(self) -> _builtins.str: + return pulumi.get(self, "service_pod_spec") + + @_builtins.property + @pulumi.getter(name="sslCert") + def ssl_cert(self) -> _builtins.str: + return pulumi.get(self, "ssl_cert") + + @_builtins.property + @pulumi.getter(name="storageClaimName") + def storage_claim_name(self) -> _builtins.str: + return pulumi.get(self, "storage_claim_name") + + @_builtins.property + @pulumi.getter(name="storageMountPath") + def storage_mount_path(self) -> _builtins.str: + return pulumi.get(self, "storage_mount_path") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigK8sPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigLsfPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + per_job_mem_limit: _builtins.bool, + per_task_reserve: _builtins.bool, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + unit_for_limits: _builtins.str, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "per_job_mem_limit", per_job_mem_limit) + pulumi.set(__self__, "per_task_reserve", per_task_reserve) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "unit_for_limits", unit_for_limits) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="perJobMemLimit") + def per_job_mem_limit(self) -> _builtins.bool: + return pulumi.get(self, "per_job_mem_limit") + + @_builtins.property + @pulumi.getter(name="perTaskReserve") + def per_task_reserve(self) -> _builtins.bool: + return pulumi.get(self, "per_task_reserve") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="unitForLimits") + def unit_for_limits(self) -> _builtins.str: + return pulumi.get(self, "unit_for_limits") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigLsfPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigMoabPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigMoabPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSeqeracomputePlatformResult(dict): + def __init__(__self__, *, + cli_path: _builtins.str, + compute_job_role: _builtins.str, + compute_queue: _builtins.str, + dragen_instance_type: _builtins.str, + dragen_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentResult'], + execution_role: _builtins.str, + forge: 'outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformForgeResult', + fusion2_enabled: _builtins.bool, + fusion_snapshots: _builtins.bool, + head_job_cpus: _builtins.float, + head_job_memory_mb: _builtins.float, + head_job_role: _builtins.str, + head_queue: _builtins.str, + log_group: _builtins.str, + lustre_id: _builtins.str, + nextflow_config: _builtins.str, + nvnme_storage_enabled: _builtins.bool, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + region: _builtins.str, + storage_type: _builtins.str, + volumes: Sequence[_builtins.str], + wave_enabled: _builtins.bool, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "cli_path", cli_path) + pulumi.set(__self__, "compute_job_role", compute_job_role) + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "dragen_queue", dragen_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "execution_role", execution_role) + pulumi.set(__self__, "forge", forge) + pulumi.set(__self__, "fusion2_enabled", fusion2_enabled) + pulumi.set(__self__, "fusion_snapshots", fusion_snapshots) + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + pulumi.set(__self__, "head_job_role", head_job_role) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "log_group", log_group) + pulumi.set(__self__, "lustre_id", lustre_id) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "nvnme_storage_enabled", nvnme_storage_enabled) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "storage_type", storage_type) + pulumi.set(__self__, "volumes", volumes) + pulumi.set(__self__, "wave_enabled", wave_enabled) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="cliPath") + def cli_path(self) -> _builtins.str: + return pulumi.get(self, "cli_path") + + @_builtins.property + @pulumi.getter(name="computeJobRole") + def compute_job_role(self) -> _builtins.str: + return pulumi.get(self, "compute_job_role") + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="dragenQueue") + def dragen_queue(self) -> _builtins.str: + return pulumi.get(self, "dragen_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="executionRole") + def execution_role(self) -> _builtins.str: + return pulumi.get(self, "execution_role") + + @_builtins.property + @pulumi.getter + def forge(self) -> 'outputs.GetComputeEnvComputeEnvConfigSeqeracomputePlatformForgeResult': + return pulumi.get(self, "forge") + + @_builtins.property + @pulumi.getter(name="fusion2Enabled") + def fusion2_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion2_enabled") + + @_builtins.property + @pulumi.getter(name="fusionSnapshots") + def fusion_snapshots(self) -> _builtins.bool: + return pulumi.get(self, "fusion_snapshots") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> _builtins.float: + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> _builtins.float: + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="headJobRole") + def head_job_role(self) -> _builtins.str: + return pulumi.get(self, "head_job_role") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="logGroup") + def log_group(self) -> _builtins.str: + return pulumi.get(self, "log_group") + + @_builtins.property + @pulumi.getter(name="lustreId") + @_utilities.deprecated("""Deprecated""") + def lustre_id(self) -> _builtins.str: + return pulumi.get(self, "lustre_id") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter(name="nvnmeStorageEnabled") + def nvnme_storage_enabled(self) -> _builtins.bool: + return pulumi.get(self, "nvnme_storage_enabled") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="storageType") + @_utilities.deprecated("""Deprecated""") + def storage_type(self) -> _builtins.str: + return pulumi.get(self, "storage_type") + + @_builtins.property + @pulumi.getter + def volumes(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "volumes") + + @_builtins.property + @pulumi.getter(name="waveEnabled") + def wave_enabled(self) -> _builtins.bool: + return pulumi.get(self, "wave_enabled") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSeqeracomputePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSeqeracomputePlatformForgeResult(dict): + def __init__(__self__, *, + alloc_strategy: _builtins.str, + allow_buckets: Sequence[_builtins.str], + arm64_enabled: _builtins.bool, + bid_percentage: _builtins.float, + dispose_on_deletion: _builtins.bool, + dragen_ami_id: _builtins.str, + dragen_enabled: _builtins.bool, + dragen_instance_type: _builtins.str, + ebs_auto_scale: _builtins.bool, + ebs_block_size: _builtins.float, + ebs_boot_size: _builtins.float, + ec2_key_pair: _builtins.str, + ecs_config: _builtins.str, + efs_create: _builtins.bool, + efs_id: _builtins.str, + efs_mount: _builtins.str, + fargate_head_enabled: _builtins.bool, + fsx_mount: _builtins.str, + fsx_name: _builtins.str, + fsx_size: _builtins.float, + fusion_enabled: _builtins.bool, + gpu_enabled: _builtins.bool, + image_id: _builtins.str, + instance_types: Sequence[_builtins.str], + max_cpus: _builtins.float, + min_cpus: _builtins.float, + security_groups: Sequence[_builtins.str], + subnets: Sequence[_builtins.str], + type: _builtins.str, + vpc_id: _builtins.str): + pulumi.set(__self__, "alloc_strategy", alloc_strategy) + pulumi.set(__self__, "allow_buckets", allow_buckets) + pulumi.set(__self__, "arm64_enabled", arm64_enabled) + pulumi.set(__self__, "bid_percentage", bid_percentage) + pulumi.set(__self__, "dispose_on_deletion", dispose_on_deletion) + pulumi.set(__self__, "dragen_ami_id", dragen_ami_id) + pulumi.set(__self__, "dragen_enabled", dragen_enabled) + pulumi.set(__self__, "dragen_instance_type", dragen_instance_type) + pulumi.set(__self__, "ebs_auto_scale", ebs_auto_scale) + pulumi.set(__self__, "ebs_block_size", ebs_block_size) + pulumi.set(__self__, "ebs_boot_size", ebs_boot_size) + pulumi.set(__self__, "ec2_key_pair", ec2_key_pair) + pulumi.set(__self__, "ecs_config", ecs_config) + pulumi.set(__self__, "efs_create", efs_create) + pulumi.set(__self__, "efs_id", efs_id) + pulumi.set(__self__, "efs_mount", efs_mount) + pulumi.set(__self__, "fargate_head_enabled", fargate_head_enabled) + pulumi.set(__self__, "fsx_mount", fsx_mount) + pulumi.set(__self__, "fsx_name", fsx_name) + pulumi.set(__self__, "fsx_size", fsx_size) + pulumi.set(__self__, "fusion_enabled", fusion_enabled) + pulumi.set(__self__, "gpu_enabled", gpu_enabled) + pulumi.set(__self__, "image_id", image_id) + pulumi.set(__self__, "instance_types", instance_types) + pulumi.set(__self__, "max_cpus", max_cpus) + pulumi.set(__self__, "min_cpus", min_cpus) + pulumi.set(__self__, "security_groups", security_groups) + pulumi.set(__self__, "subnets", subnets) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "vpc_id", vpc_id) + + @_builtins.property + @pulumi.getter(name="allocStrategy") + def alloc_strategy(self) -> _builtins.str: + return pulumi.get(self, "alloc_strategy") + + @_builtins.property + @pulumi.getter(name="allowBuckets") + def allow_buckets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "allow_buckets") + + @_builtins.property + @pulumi.getter(name="arm64Enabled") + def arm64_enabled(self) -> _builtins.bool: + return pulumi.get(self, "arm64_enabled") + + @_builtins.property + @pulumi.getter(name="bidPercentage") + def bid_percentage(self) -> _builtins.float: + return pulumi.get(self, "bid_percentage") + + @_builtins.property + @pulumi.getter(name="disposeOnDeletion") + def dispose_on_deletion(self) -> _builtins.bool: + return pulumi.get(self, "dispose_on_deletion") + + @_builtins.property + @pulumi.getter(name="dragenAmiId") + def dragen_ami_id(self) -> _builtins.str: + return pulumi.get(self, "dragen_ami_id") + + @_builtins.property + @pulumi.getter(name="dragenEnabled") + def dragen_enabled(self) -> _builtins.bool: + return pulumi.get(self, "dragen_enabled") + + @_builtins.property + @pulumi.getter(name="dragenInstanceType") + def dragen_instance_type(self) -> _builtins.str: + return pulumi.get(self, "dragen_instance_type") + + @_builtins.property + @pulumi.getter(name="ebsAutoScale") + def ebs_auto_scale(self) -> _builtins.bool: + return pulumi.get(self, "ebs_auto_scale") + + @_builtins.property + @pulumi.getter(name="ebsBlockSize") + def ebs_block_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_block_size") + + @_builtins.property + @pulumi.getter(name="ebsBootSize") + def ebs_boot_size(self) -> _builtins.float: + return pulumi.get(self, "ebs_boot_size") + + @_builtins.property + @pulumi.getter(name="ec2KeyPair") + def ec2_key_pair(self) -> _builtins.str: + return pulumi.get(self, "ec2_key_pair") + + @_builtins.property + @pulumi.getter(name="ecsConfig") + def ecs_config(self) -> _builtins.str: + return pulumi.get(self, "ecs_config") + + @_builtins.property + @pulumi.getter(name="efsCreate") + def efs_create(self) -> _builtins.bool: + return pulumi.get(self, "efs_create") + + @_builtins.property + @pulumi.getter(name="efsId") + def efs_id(self) -> _builtins.str: + return pulumi.get(self, "efs_id") + + @_builtins.property + @pulumi.getter(name="efsMount") + def efs_mount(self) -> _builtins.str: + return pulumi.get(self, "efs_mount") + + @_builtins.property + @pulumi.getter(name="fargateHeadEnabled") + def fargate_head_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fargate_head_enabled") + + @_builtins.property + @pulumi.getter(name="fsxMount") + def fsx_mount(self) -> _builtins.str: + return pulumi.get(self, "fsx_mount") + + @_builtins.property + @pulumi.getter(name="fsxName") + def fsx_name(self) -> _builtins.str: + return pulumi.get(self, "fsx_name") + + @_builtins.property + @pulumi.getter(name="fsxSize") + def fsx_size(self) -> _builtins.float: + return pulumi.get(self, "fsx_size") + + @_builtins.property + @pulumi.getter(name="fusionEnabled") + def fusion_enabled(self) -> _builtins.bool: + return pulumi.get(self, "fusion_enabled") + + @_builtins.property + @pulumi.getter(name="gpuEnabled") + def gpu_enabled(self) -> _builtins.bool: + return pulumi.get(self, "gpu_enabled") + + @_builtins.property + @pulumi.getter(name="imageId") + def image_id(self) -> _builtins.str: + return pulumi.get(self, "image_id") + + @_builtins.property + @pulumi.getter(name="instanceTypes") + def instance_types(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "instance_types") + + @_builtins.property + @pulumi.getter(name="maxCpus") + def max_cpus(self) -> _builtins.float: + return pulumi.get(self, "max_cpus") + + @_builtins.property + @pulumi.getter(name="minCpus") + def min_cpus(self) -> _builtins.float: + return pulumi.get(self, "min_cpus") + + @_builtins.property + @pulumi.getter(name="securityGroups") + def security_groups(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "security_groups") + + @_builtins.property + @pulumi.getter + def subnets(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "subnets") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + @_builtins.property + @pulumi.getter(name="vpcId") + def vpc_id(self) -> _builtins.str: + return pulumi.get(self, "vpc_id") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSlurmPlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigSlurmPlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigUgePlatformResult(dict): + def __init__(__self__, *, + compute_queue: _builtins.str, + environments: Sequence['outputs.GetComputeEnvComputeEnvConfigUgePlatformEnvironmentResult'], + head_job_options: _builtins.str, + head_queue: _builtins.str, + host_name: _builtins.str, + launch_dir: _builtins.str, + max_queue_size: _builtins.float, + nextflow_config: _builtins.str, + port: _builtins.float, + post_run_script: _builtins.str, + pre_run_script: _builtins.str, + propagate_head_job_options: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + """ + :param Sequence['GetComputeEnvComputeEnvConfigUgePlatformEnvironmentArgs'] environments: Array of environment variables for the compute environment + :param _builtins.str nextflow_config: Nextflow configuration settings and parameters + :param _builtins.str post_run_script: Shell script to execute after workflow completes + :param _builtins.str pre_run_script: Shell script to execute before workflow starts + :param _builtins.str work_dir: Working directory path for workflow execution + """ + pulumi.set(__self__, "compute_queue", compute_queue) + pulumi.set(__self__, "environments", environments) + pulumi.set(__self__, "head_job_options", head_job_options) + pulumi.set(__self__, "head_queue", head_queue) + pulumi.set(__self__, "host_name", host_name) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "max_queue_size", max_queue_size) + pulumi.set(__self__, "nextflow_config", nextflow_config) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "post_run_script", post_run_script) + pulumi.set(__self__, "pre_run_script", pre_run_script) + pulumi.set(__self__, "propagate_head_job_options", propagate_head_job_options) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="computeQueue") + def compute_queue(self) -> _builtins.str: + return pulumi.get(self, "compute_queue") + + @_builtins.property + @pulumi.getter + def environments(self) -> Sequence['outputs.GetComputeEnvComputeEnvConfigUgePlatformEnvironmentResult']: + """ + Array of environment variables for the compute environment + """ + return pulumi.get(self, "environments") + + @_builtins.property + @pulumi.getter(name="headJobOptions") + def head_job_options(self) -> _builtins.str: + return pulumi.get(self, "head_job_options") + + @_builtins.property + @pulumi.getter(name="headQueue") + def head_queue(self) -> _builtins.str: + return pulumi.get(self, "head_queue") + + @_builtins.property + @pulumi.getter(name="hostName") + def host_name(self) -> _builtins.str: + return pulumi.get(self, "host_name") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="maxQueueSize") + def max_queue_size(self) -> _builtins.float: + return pulumi.get(self, "max_queue_size") + + @_builtins.property + @pulumi.getter(name="nextflowConfig") + def nextflow_config(self) -> _builtins.str: + """ + Nextflow configuration settings and parameters + """ + return pulumi.get(self, "nextflow_config") + + @_builtins.property + @pulumi.getter + def port(self) -> _builtins.float: + return pulumi.get(self, "port") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> _builtins.str: + """ + Shell script to execute after workflow completes + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> _builtins.str: + """ + Shell script to execute before workflow starts + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter(name="propagateHeadJobOptions") + def propagate_head_job_options(self) -> _builtins.bool: + return pulumi.get(self, "propagate_head_job_options") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + """ + Working directory path for workflow execution + """ + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetComputeEnvComputeEnvConfigUgePlatformEnvironmentResult(dict): + def __init__(__self__, *, + compute: _builtins.bool, + head: _builtins.bool, + name: _builtins.str, + value: _builtins.str): + pulumi.set(__self__, "compute", compute) + pulumi.set(__self__, "head", head) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter + def compute(self) -> _builtins.bool: + return pulumi.get(self, "compute") + + @_builtins.property + @pulumi.getter + def head(self) -> _builtins.bool: + return pulumi.get(self, "head") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetComputeEnvComputeEnvLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetCredentialKeysResult(dict): + def __init__(__self__, *, + aws: 'outputs.GetCredentialKeysAwsResult', + azure: 'outputs.GetCredentialKeysAzureResult', + azure_entra: 'outputs.GetCredentialKeysAzureEntraResult', + azurerepos: 'outputs.GetCredentialKeysAzurereposResult', + bitbucket: 'outputs.GetCredentialKeysBitbucketResult', + codecommit: 'outputs.GetCredentialKeysCodecommitResult', + container_reg: 'outputs.GetCredentialKeysContainerRegResult', + gitea: 'outputs.GetCredentialKeysGiteaResult', + github: 'outputs.GetCredentialKeysGithubResult', + gitlab: 'outputs.GetCredentialKeysGitlabResult', + google: 'outputs.GetCredentialKeysGoogleResult', + k8s: 'outputs.GetCredentialKeysK8sResult', + seqeracompute: 'outputs.GetCredentialKeysSeqeracomputeResult', + ssh: 'outputs.GetCredentialKeysSshResult', + tw_agent: 'outputs.GetCredentialKeysTwAgentResult'): + pulumi.set(__self__, "aws", aws) + pulumi.set(__self__, "azure", azure) + pulumi.set(__self__, "azure_entra", azure_entra) + pulumi.set(__self__, "azurerepos", azurerepos) + pulumi.set(__self__, "bitbucket", bitbucket) + pulumi.set(__self__, "codecommit", codecommit) + pulumi.set(__self__, "container_reg", container_reg) + pulumi.set(__self__, "gitea", gitea) + pulumi.set(__self__, "github", github) + pulumi.set(__self__, "gitlab", gitlab) + pulumi.set(__self__, "google", google) + pulumi.set(__self__, "k8s", k8s) + pulumi.set(__self__, "seqeracompute", seqeracompute) + pulumi.set(__self__, "ssh", ssh) + pulumi.set(__self__, "tw_agent", tw_agent) + + @_builtins.property + @pulumi.getter + def aws(self) -> 'outputs.GetCredentialKeysAwsResult': + return pulumi.get(self, "aws") + + @_builtins.property + @pulumi.getter + def azure(self) -> 'outputs.GetCredentialKeysAzureResult': + return pulumi.get(self, "azure") + + @_builtins.property + @pulumi.getter(name="azureEntra") + def azure_entra(self) -> 'outputs.GetCredentialKeysAzureEntraResult': + return pulumi.get(self, "azure_entra") + + @_builtins.property + @pulumi.getter + def azurerepos(self) -> 'outputs.GetCredentialKeysAzurereposResult': + return pulumi.get(self, "azurerepos") + + @_builtins.property + @pulumi.getter + def bitbucket(self) -> 'outputs.GetCredentialKeysBitbucketResult': + return pulumi.get(self, "bitbucket") + + @_builtins.property + @pulumi.getter + def codecommit(self) -> 'outputs.GetCredentialKeysCodecommitResult': + return pulumi.get(self, "codecommit") + + @_builtins.property + @pulumi.getter(name="containerReg") + def container_reg(self) -> 'outputs.GetCredentialKeysContainerRegResult': + return pulumi.get(self, "container_reg") + + @_builtins.property + @pulumi.getter + def gitea(self) -> 'outputs.GetCredentialKeysGiteaResult': + return pulumi.get(self, "gitea") + + @_builtins.property + @pulumi.getter + def github(self) -> 'outputs.GetCredentialKeysGithubResult': + return pulumi.get(self, "github") + + @_builtins.property + @pulumi.getter + def gitlab(self) -> 'outputs.GetCredentialKeysGitlabResult': + return pulumi.get(self, "gitlab") + + @_builtins.property + @pulumi.getter + def google(self) -> 'outputs.GetCredentialKeysGoogleResult': + return pulumi.get(self, "google") + + @_builtins.property + @pulumi.getter + def k8s(self) -> 'outputs.GetCredentialKeysK8sResult': + return pulumi.get(self, "k8s") + + @_builtins.property + @pulumi.getter + def seqeracompute(self) -> 'outputs.GetCredentialKeysSeqeracomputeResult': + return pulumi.get(self, "seqeracompute") + + @_builtins.property + @pulumi.getter + def ssh(self) -> 'outputs.GetCredentialKeysSshResult': + return pulumi.get(self, "ssh") + + @_builtins.property + @pulumi.getter(name="twAgent") + def tw_agent(self) -> 'outputs.GetCredentialKeysTwAgentResult': + return pulumi.get(self, "tw_agent") + + +@pulumi.output_type +class GetCredentialKeysAwsResult(dict): + def __init__(__self__, *, + access_key: _builtins.str, + assume_role_arn: _builtins.str): + pulumi.set(__self__, "access_key", access_key) + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> _builtins.str: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> _builtins.str: + return pulumi.get(self, "assume_role_arn") + + +@pulumi.output_type +class GetCredentialKeysAzureResult(dict): + def __init__(__self__, *, + batch_name: _builtins.str, + storage_name: _builtins.str): + pulumi.set(__self__, "batch_name", batch_name) + pulumi.set(__self__, "storage_name", storage_name) + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> _builtins.str: + return pulumi.get(self, "batch_name") + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> _builtins.str: + return pulumi.get(self, "storage_name") + + +@pulumi.output_type +class GetCredentialKeysAzureEntraResult(dict): + def __init__(__self__, *, + batch_name: _builtins.str, + client_id: _builtins.str, + storage_name: _builtins.str, + tenant_id: _builtins.str): + pulumi.set(__self__, "batch_name", batch_name) + pulumi.set(__self__, "client_id", client_id) + pulumi.set(__self__, "storage_name", storage_name) + pulumi.set(__self__, "tenant_id", tenant_id) + + @_builtins.property + @pulumi.getter(name="batchName") + def batch_name(self) -> _builtins.str: + return pulumi.get(self, "batch_name") + + @_builtins.property + @pulumi.getter(name="clientId") + def client_id(self) -> _builtins.str: + return pulumi.get(self, "client_id") + + @_builtins.property + @pulumi.getter(name="storageName") + def storage_name(self) -> _builtins.str: + return pulumi.get(self, "storage_name") + + @_builtins.property + @pulumi.getter(name="tenantId") + def tenant_id(self) -> _builtins.str: + return pulumi.get(self, "tenant_id") + + +@pulumi.output_type +class GetCredentialKeysAzurereposResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysBitbucketResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysCodecommitResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysContainerRegResult(dict): + def __init__(__self__, *, + registry: _builtins.str, + user_name: _builtins.str): + pulumi.set(__self__, "registry", registry) + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def registry(self) -> _builtins.str: + return pulumi.get(self, "registry") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class GetCredentialKeysGiteaResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysGithubResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysGitlabResult(dict): + def __init__(__self__, *, + username: _builtins.str): + pulumi.set(__self__, "username", username) + + @_builtins.property + @pulumi.getter + def username(self) -> _builtins.str: + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetCredentialKeysGoogleResult(dict): + def __init__(__self__): + pass + + +@pulumi.output_type +class GetCredentialKeysK8sResult(dict): + def __init__(__self__, *, + certificate: _builtins.str): + pulumi.set(__self__, "certificate", certificate) + + @_builtins.property + @pulumi.getter + def certificate(self) -> _builtins.str: + return pulumi.get(self, "certificate") + + +@pulumi.output_type +class GetCredentialKeysSeqeracomputeResult(dict): + def __init__(__self__, *, + access_key: _builtins.str, + assume_role_arn: _builtins.str): + pulumi.set(__self__, "access_key", access_key) + pulumi.set(__self__, "assume_role_arn", assume_role_arn) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> _builtins.str: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="assumeRoleArn") + def assume_role_arn(self) -> _builtins.str: + return pulumi.get(self, "assume_role_arn") + + +@pulumi.output_type +class GetCredentialKeysSshResult(dict): + def __init__(__self__): + pass + + +@pulumi.output_type +class GetCredentialKeysTwAgentResult(dict): + def __init__(__self__, *, + connection_id: _builtins.str, + shared: _builtins.bool, + work_dir: _builtins.str): + pulumi.set(__self__, "connection_id", connection_id) + pulumi.set(__self__, "shared", shared) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="connectionId") + def connection_id(self) -> _builtins.str: + return pulumi.get(self, "connection_id") + + @_builtins.property + @pulumi.getter + def shared(self) -> _builtins.bool: + return pulumi.get(self, "shared") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetDataLinkCredentialResult(dict): + def __init__(__self__, *, + id: _builtins.str, + name: _builtins.str, + provider_type: _builtins.str): + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + +@pulumi.output_type +class GetDatasetDatasetResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + deleted: _builtins.bool, + description: _builtins.str, + id: _builtins.str, + last_updated: _builtins.str, + media_type: _builtins.str, + name: _builtins.str): + """ + :param _builtins.bool deleted: Read-only flag indicating if the dataset has been deleted + :param _builtins.str description: Detailed description of the dataset contents and purpose (max 1000 characters) + :param _builtins.str id: Unique identifier for the dataset (max 22 characters) + :param _builtins.str media_type: MIME type or media type of the dataset content (max 80 characters) + :param _builtins.str name: Dataset name following naming conventions (1-100 characters) + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "deleted", deleted) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "media_type", media_type) + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + """ + Read-only flag indicating if the dataset has been deleted + """ + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + """ + Detailed description of the dataset contents and purpose (max 1000 characters) + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + """ + Unique identifier for the dataset (max 22 characters) + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="mediaType") + def media_type(self) -> _builtins.str: + """ + MIME type or media type of the dataset content (max 80 characters) + """ + return pulumi.get(self, "media_type") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Dataset name following naming conventions (1-100 characters) + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class GetLabelsLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetPipelineComputeEnvResult(dict): + def __init__(__self__, *, + id: _builtins.str, + name: _builtins.str, + platform: _builtins.str, + region: _builtins.str): + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "platform", platform) + pulumi.set(__self__, "region", region) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + +@pulumi.output_type +class GetPipelineLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetStudiosActiveConnectionResult(dict): + def __init__(__self__, *, + avatar: _builtins.str, + email: _builtins.str, + id: _builtins.float, + last_active: _builtins.str, + user_name: _builtins.str): + pulumi.set(__self__, "avatar", avatar) + pulumi.set(__self__, "email", email) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "last_active", last_active) + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> _builtins.str: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter + def email(self) -> _builtins.str: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastActive") + def last_active(self) -> _builtins.str: + return pulumi.get(self, "last_active") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class GetStudiosComputeEnvResult(dict): + def __init__(__self__, *, + credentials_id: _builtins.str, + id: _builtins.str, + name: _builtins.str, + platform: _builtins.str, + region: _builtins.str, + work_dir: _builtins.str): + pulumi.set(__self__, "credentials_id", credentials_id) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "platform", platform) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="credentialsId") + def credentials_id(self) -> _builtins.str: + return pulumi.get(self, "credentials_id") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def platform(self) -> _builtins.str: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetStudiosConfigurationResult(dict): + def __init__(__self__, *, + conda_environment: _builtins.str, + cpu: _builtins.float, + gpu: _builtins.float, + lifespan_hours: _builtins.float, + memory: _builtins.float, + mount_datas: Sequence[_builtins.str]): + pulumi.set(__self__, "conda_environment", conda_environment) + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "gpu", gpu) + pulumi.set(__self__, "lifespan_hours", lifespan_hours) + pulumi.set(__self__, "memory", memory) + pulumi.set(__self__, "mount_datas", mount_datas) + + @_builtins.property + @pulumi.getter(name="condaEnvironment") + def conda_environment(self) -> _builtins.str: + return pulumi.get(self, "conda_environment") + + @_builtins.property + @pulumi.getter + def cpu(self) -> _builtins.float: + return pulumi.get(self, "cpu") + + @_builtins.property + @pulumi.getter + def gpu(self) -> _builtins.float: + return pulumi.get(self, "gpu") + + @_builtins.property + @pulumi.getter(name="lifespanHours") + def lifespan_hours(self) -> _builtins.float: + return pulumi.get(self, "lifespan_hours") + + @_builtins.property + @pulumi.getter + def memory(self) -> _builtins.float: + return pulumi.get(self, "memory") + + @_builtins.property + @pulumi.getter(name="mountDatas") + def mount_datas(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "mount_datas") + + +@pulumi.output_type +class GetStudiosLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetStudiosMountedDataLinkResult(dict): + def __init__(__self__, *, + credentials: Sequence['outputs.GetStudiosMountedDataLinkCredentialResult'], + data_link_id: _builtins.str, + description: _builtins.str, + hidden: _builtins.bool, + message: _builtins.str, + name: _builtins.str, + provider_type: _builtins.str, + public_accessible: _builtins.bool, + region: _builtins.str, + resource_ref: _builtins.str, + status: _builtins.str, + type: _builtins.str): + """ + :param Sequence['GetStudiosMountedDataLinkCredentialArgs'] credentials: Array of credentials required to access the data link + :param _builtins.str data_link_id: Unique identifier for the data link + :param _builtins.str description: Description of the data link's purpose and contents + :param _builtins.str name: Display name for the data link connection + :param _builtins.str region: Geographic region where the data link is hosted + :param _builtins.str resource_ref: Reference identifier for the external resource + """ + pulumi.set(__self__, "credentials", credentials) + pulumi.set(__self__, "data_link_id", data_link_id) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "hidden", hidden) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "provider_type", provider_type) + pulumi.set(__self__, "public_accessible", public_accessible) + pulumi.set(__self__, "region", region) + pulumi.set(__self__, "resource_ref", resource_ref) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "type", type) + + @_builtins.property + @pulumi.getter + def credentials(self) -> Sequence['outputs.GetStudiosMountedDataLinkCredentialResult']: + """ + Array of credentials required to access the data link + """ + return pulumi.get(self, "credentials") + + @_builtins.property + @pulumi.getter(name="dataLinkId") + def data_link_id(self) -> _builtins.str: + """ + Unique identifier for the data link + """ + return pulumi.get(self, "data_link_id") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + """ + Description of the data link's purpose and contents + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def hidden(self) -> _builtins.bool: + return pulumi.get(self, "hidden") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Display name for the data link connection + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + @_builtins.property + @pulumi.getter(name="publicAccessible") + def public_accessible(self) -> _builtins.bool: + return pulumi.get(self, "public_accessible") + + @_builtins.property + @pulumi.getter + def region(self) -> _builtins.str: + """ + Geographic region where the data link is hosted + """ + return pulumi.get(self, "region") + + @_builtins.property + @pulumi.getter(name="resourceRef") + def resource_ref(self) -> _builtins.str: + """ + Reference identifier for the external resource + """ + return pulumi.get(self, "resource_ref") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def type(self) -> _builtins.str: + return pulumi.get(self, "type") + + +@pulumi.output_type +class GetStudiosMountedDataLinkCredentialResult(dict): + def __init__(__self__, *, + id: _builtins.str, + name: _builtins.str, + provider_type: _builtins.str): + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "provider_type", provider_type) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="providerType") + def provider_type(self) -> _builtins.str: + return pulumi.get(self, "provider_type") + + +@pulumi.output_type +class GetStudiosParentCheckpointResult(dict): + def __init__(__self__, *, + checkpoint_id: _builtins.float, + checkpoint_name: _builtins.str, + session_id: _builtins.str, + studio_name: _builtins.str): + pulumi.set(__self__, "checkpoint_id", checkpoint_id) + pulumi.set(__self__, "checkpoint_name", checkpoint_name) + pulumi.set(__self__, "session_id", session_id) + pulumi.set(__self__, "studio_name", studio_name) + + @_builtins.property + @pulumi.getter(name="checkpointId") + def checkpoint_id(self) -> _builtins.float: + return pulumi.get(self, "checkpoint_id") + + @_builtins.property + @pulumi.getter(name="checkpointName") + def checkpoint_name(self) -> _builtins.str: + return pulumi.get(self, "checkpoint_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> _builtins.str: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="studioName") + def studio_name(self) -> _builtins.str: + return pulumi.get(self, "studio_name") + + +@pulumi.output_type +class GetStudiosProgressResult(dict): + def __init__(__self__, *, + message: _builtins.str, + status: _builtins.str, + warnings: Sequence[_builtins.str]): + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "warnings", warnings) + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def warnings(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "warnings") + + +@pulumi.output_type +class GetStudiosStatusInfoResult(dict): + def __init__(__self__, *, + last_update: _builtins.str, + message: _builtins.str, + status: _builtins.str): + pulumi.set(__self__, "last_update", last_update) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="lastUpdate") + def last_update(self) -> _builtins.str: + return pulumi.get(self, "last_update") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + +@pulumi.output_type +class GetStudiosTemplateResult(dict): + def __init__(__self__, *, + icon: _builtins.str, + repository: _builtins.str, + status: _builtins.str, + tool: _builtins.str): + pulumi.set(__self__, "icon", icon) + pulumi.set(__self__, "repository", repository) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "tool", tool) + + @_builtins.property + @pulumi.getter + def icon(self) -> _builtins.str: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter + def repository(self) -> _builtins.str: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def tool(self) -> _builtins.str: + return pulumi.get(self, "tool") + + +@pulumi.output_type +class GetStudiosUserResult(dict): + def __init__(__self__, *, + avatar: _builtins.str, + email: _builtins.str, + id: _builtins.float, + user_name: _builtins.str): + pulumi.set(__self__, "avatar", avatar) + pulumi.set(__self__, "email", email) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "user_name", user_name) + + @_builtins.property + @pulumi.getter + def avatar(self) -> _builtins.str: + return pulumi.get(self, "avatar") + + @_builtins.property + @pulumi.getter + def email(self) -> _builtins.str: + return pulumi.get(self, "email") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + +@pulumi.output_type +class GetUserWorkspacesOrgsAndWorkspaceResult(dict): + def __init__(__self__, *, + org_id: _builtins.float, + org_logo_url: _builtins.str, + org_name: _builtins.str, + org_type: _builtins.str, + roles: Sequence[_builtins.str], + visibility: _builtins.str, + workspace_full_name: _builtins.str, + workspace_id: _builtins.float, + workspace_name: _builtins.str): + pulumi.set(__self__, "org_id", org_id) + pulumi.set(__self__, "org_logo_url", org_logo_url) + pulumi.set(__self__, "org_name", org_name) + pulumi.set(__self__, "org_type", org_type) + pulumi.set(__self__, "roles", roles) + pulumi.set(__self__, "visibility", visibility) + pulumi.set(__self__, "workspace_full_name", workspace_full_name) + pulumi.set(__self__, "workspace_id", workspace_id) + pulumi.set(__self__, "workspace_name", workspace_name) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> _builtins.float: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgLogoUrl") + def org_logo_url(self) -> _builtins.str: + return pulumi.get(self, "org_logo_url") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> _builtins.str: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter(name="orgType") + def org_type(self) -> _builtins.str: + return pulumi.get(self, "org_type") + + @_builtins.property + @pulumi.getter + def roles(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "roles") + + @_builtins.property + @pulumi.getter + def visibility(self) -> _builtins.str: + return pulumi.get(self, "visibility") + + @_builtins.property + @pulumi.getter(name="workspaceFullName") + def workspace_full_name(self) -> _builtins.str: + return pulumi.get(self, "workspace_full_name") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> _builtins.float: + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> _builtins.str: + return pulumi.get(self, "workspace_name") + + +@pulumi.output_type +class GetWorkflowsJobInfoResult(dict): + def __init__(__self__, *, + exit_code: _builtins.float, + id: _builtins.float, + message: _builtins.str, + operation_id: _builtins.str, + status: _builtins.str): + pulumi.set(__self__, "exit_code", exit_code) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "message", message) + pulumi.set(__self__, "operation_id", operation_id) + pulumi.set(__self__, "status", status) + + @_builtins.property + @pulumi.getter(name="exitCode") + def exit_code(self) -> _builtins.float: + return pulumi.get(self, "exit_code") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def message(self) -> _builtins.str: + return pulumi.get(self, "message") + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> _builtins.str: + return pulumi.get(self, "operation_id") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + +@pulumi.output_type +class GetWorkflowsLabelResult(dict): + def __init__(__self__, *, + date_created: _builtins.str, + id: _builtins.float, + is_default: _builtins.bool, + name: _builtins.str, + resource: _builtins.bool, + value: _builtins.str): + """ + :param _builtins.str date_created: Timestamp when the label was created + :param _builtins.float id: Unique numeric identifier for the label + :param _builtins.bool is_default: Flag indicating if this is a default system label + :param _builtins.str name: Name or key of the label + :param _builtins.bool resource: Flag indicating if this is a resource-level label + :param _builtins.str value: Value associated with the label + """ + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "is_default", is_default) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "resource", resource) + pulumi.set(__self__, "value", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + """ + Timestamp when the label was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the label + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="isDefault") + def is_default(self) -> _builtins.bool: + """ + Flag indicating if this is a default system label + """ + return pulumi.get(self, "is_default") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Name or key of the label + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def resource(self) -> _builtins.bool: + """ + Flag indicating if this is a resource-level label + """ + return pulumi.get(self, "resource") + + @_builtins.property + @pulumi.getter + def value(self) -> _builtins.str: + """ + Value associated with the label + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetWorkflowsPlatformResult(dict): + def __init__(__self__, *, + id: _builtins.str, + name: _builtins.str): + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + +@pulumi.output_type +class GetWorkflowsProgressResult(dict): + def __init__(__self__, *, + processes_progresses: Sequence['outputs.GetWorkflowsProgressProcessesProgressResult'], + total_processes: _builtins.float, + workflow_progress: 'outputs.GetWorkflowsProgressWorkflowProgressResult'): + pulumi.set(__self__, "processes_progresses", processes_progresses) + pulumi.set(__self__, "total_processes", total_processes) + pulumi.set(__self__, "workflow_progress", workflow_progress) + + @_builtins.property + @pulumi.getter(name="processesProgresses") + def processes_progresses(self) -> Sequence['outputs.GetWorkflowsProgressProcessesProgressResult']: + return pulumi.get(self, "processes_progresses") + + @_builtins.property + @pulumi.getter(name="totalProcesses") + def total_processes(self) -> _builtins.float: + return pulumi.get(self, "total_processes") + + @_builtins.property + @pulumi.getter(name="workflowProgress") + def workflow_progress(self) -> 'outputs.GetWorkflowsProgressWorkflowProgressResult': + return pulumi.get(self, "workflow_progress") + + +@pulumi.output_type +class GetWorkflowsProgressProcessesProgressResult(dict): + def __init__(__self__, *, + aborted: _builtins.float, + cached: _builtins.float, + cpu_efficiency: _builtins.float, + cpu_load: _builtins.float, + cpu_time: _builtins.float, + cpus: _builtins.float, + date_created: _builtins.str, + failed: _builtins.float, + inv_ctx_switch: _builtins.float, + last_updated: _builtins.str, + load_cpus: _builtins.float, + load_memory: _builtins.float, + load_tasks: _builtins.float, + memory_efficiency: _builtins.float, + memory_req: _builtins.float, + memory_rss: _builtins.float, + peak_cpus: _builtins.float, + peak_memory: _builtins.float, + peak_tasks: _builtins.float, + pending: _builtins.float, + process: _builtins.str, + read_bytes: _builtins.float, + running: _builtins.float, + submitted: _builtins.float, + succeeded: _builtins.float, + vol_ctx_switch: _builtins.float, + write_bytes: _builtins.float): + pulumi.set(__self__, "aborted", aborted) + pulumi.set(__self__, "cached", cached) + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + pulumi.set(__self__, "cpu_load", cpu_load) + pulumi.set(__self__, "cpu_time", cpu_time) + pulumi.set(__self__, "cpus", cpus) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "failed", failed) + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "load_cpus", load_cpus) + pulumi.set(__self__, "load_memory", load_memory) + pulumi.set(__self__, "load_tasks", load_tasks) + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + pulumi.set(__self__, "memory_req", memory_req) + pulumi.set(__self__, "memory_rss", memory_rss) + pulumi.set(__self__, "peak_cpus", peak_cpus) + pulumi.set(__self__, "peak_memory", peak_memory) + pulumi.set(__self__, "peak_tasks", peak_tasks) + pulumi.set(__self__, "pending", pending) + pulumi.set(__self__, "process", process) + pulumi.set(__self__, "read_bytes", read_bytes) + pulumi.set(__self__, "running", running) + pulumi.set(__self__, "submitted", submitted) + pulumi.set(__self__, "succeeded", succeeded) + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> _builtins.float: + return pulumi.get(self, "aborted") + + @_builtins.property + @pulumi.getter + def cached(self) -> _builtins.float: + return pulumi.get(self, "cached") + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> _builtins.float: + return pulumi.get(self, "cpu_efficiency") + + @_builtins.property + @pulumi.getter(name="cpuLoad") + @_utilities.deprecated("""Deprecated""") + def cpu_load(self) -> _builtins.float: + return pulumi.get(self, "cpu_load") + + @_builtins.property + @pulumi.getter(name="cpuTime") + @_utilities.deprecated("""Deprecated""") + def cpu_time(self) -> _builtins.float: + return pulumi.get(self, "cpu_time") + + @_builtins.property + @pulumi.getter + @_utilities.deprecated("""Deprecated""") + def cpus(self) -> _builtins.float: + return pulumi.get(self, "cpus") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def failed(self) -> _builtins.float: + return pulumi.get(self, "failed") + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def inv_ctx_switch(self) -> _builtins.float: + return pulumi.get(self, "inv_ctx_switch") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> _builtins.float: + return pulumi.get(self, "load_cpus") + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> _builtins.float: + return pulumi.get(self, "load_memory") + + @_builtins.property + @pulumi.getter(name="loadTasks") + @_utilities.deprecated("""Deprecated""") + def load_tasks(self) -> _builtins.float: + return pulumi.get(self, "load_tasks") + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> _builtins.float: + return pulumi.get(self, "memory_efficiency") + + @_builtins.property + @pulumi.getter(name="memoryReq") + @_utilities.deprecated("""Deprecated""") + def memory_req(self) -> _builtins.float: + return pulumi.get(self, "memory_req") + + @_builtins.property + @pulumi.getter(name="memoryRss") + @_utilities.deprecated("""Deprecated""") + def memory_rss(self) -> _builtins.float: + return pulumi.get(self, "memory_rss") + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> _builtins.float: + return pulumi.get(self, "peak_cpus") + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> _builtins.float: + return pulumi.get(self, "peak_memory") + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> _builtins.float: + return pulumi.get(self, "peak_tasks") + + @_builtins.property + @pulumi.getter + def pending(self) -> _builtins.float: + return pulumi.get(self, "pending") + + @_builtins.property + @pulumi.getter + def process(self) -> _builtins.str: + return pulumi.get(self, "process") + + @_builtins.property + @pulumi.getter(name="readBytes") + @_utilities.deprecated("""Deprecated""") + def read_bytes(self) -> _builtins.float: + return pulumi.get(self, "read_bytes") + + @_builtins.property + @pulumi.getter + def running(self) -> _builtins.float: + return pulumi.get(self, "running") + + @_builtins.property + @pulumi.getter + def submitted(self) -> _builtins.float: + return pulumi.get(self, "submitted") + + @_builtins.property + @pulumi.getter + def succeeded(self) -> _builtins.float: + return pulumi.get(self, "succeeded") + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + @_utilities.deprecated("""Deprecated""") + def vol_ctx_switch(self) -> _builtins.float: + return pulumi.get(self, "vol_ctx_switch") + + @_builtins.property + @pulumi.getter(name="writeBytes") + @_utilities.deprecated("""Deprecated""") + def write_bytes(self) -> _builtins.float: + return pulumi.get(self, "write_bytes") + + +@pulumi.output_type +class GetWorkflowsProgressWorkflowProgressResult(dict): + def __init__(__self__, *, + aborted: _builtins.float, + cached: _builtins.float, + cost: _builtins.float, + cpu_efficiency: _builtins.float, + cpu_load: _builtins.float, + cpu_time: _builtins.float, + cpus: _builtins.float, + date_created: _builtins.str, + executors: Sequence[_builtins.str], + failed: _builtins.float, + inv_ctx_switch: _builtins.float, + last_updated: _builtins.str, + load_cpus: _builtins.float, + load_memory: _builtins.float, + load_tasks: _builtins.float, + memory_efficiency: _builtins.float, + memory_req: _builtins.float, + memory_rss: _builtins.float, + peak_cpus: _builtins.float, + peak_memory: _builtins.float, + peak_tasks: _builtins.float, + pending: _builtins.float, + read_bytes: _builtins.float, + running: _builtins.float, + submitted: _builtins.float, + succeeded: _builtins.float, + vol_ctx_switch: _builtins.float, + write_bytes: _builtins.float): + pulumi.set(__self__, "aborted", aborted) + pulumi.set(__self__, "cached", cached) + pulumi.set(__self__, "cost", cost) + pulumi.set(__self__, "cpu_efficiency", cpu_efficiency) + pulumi.set(__self__, "cpu_load", cpu_load) + pulumi.set(__self__, "cpu_time", cpu_time) + pulumi.set(__self__, "cpus", cpus) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "executors", executors) + pulumi.set(__self__, "failed", failed) + pulumi.set(__self__, "inv_ctx_switch", inv_ctx_switch) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "load_cpus", load_cpus) + pulumi.set(__self__, "load_memory", load_memory) + pulumi.set(__self__, "load_tasks", load_tasks) + pulumi.set(__self__, "memory_efficiency", memory_efficiency) + pulumi.set(__self__, "memory_req", memory_req) + pulumi.set(__self__, "memory_rss", memory_rss) + pulumi.set(__self__, "peak_cpus", peak_cpus) + pulumi.set(__self__, "peak_memory", peak_memory) + pulumi.set(__self__, "peak_tasks", peak_tasks) + pulumi.set(__self__, "pending", pending) + pulumi.set(__self__, "read_bytes", read_bytes) + pulumi.set(__self__, "running", running) + pulumi.set(__self__, "submitted", submitted) + pulumi.set(__self__, "succeeded", succeeded) + pulumi.set(__self__, "vol_ctx_switch", vol_ctx_switch) + pulumi.set(__self__, "write_bytes", write_bytes) + + @_builtins.property + @pulumi.getter + def aborted(self) -> _builtins.float: + return pulumi.get(self, "aborted") + + @_builtins.property + @pulumi.getter + def cached(self) -> _builtins.float: + return pulumi.get(self, "cached") + + @_builtins.property + @pulumi.getter + def cost(self) -> _builtins.float: + return pulumi.get(self, "cost") + + @_builtins.property + @pulumi.getter(name="cpuEfficiency") + def cpu_efficiency(self) -> _builtins.float: + return pulumi.get(self, "cpu_efficiency") + + @_builtins.property + @pulumi.getter(name="cpuLoad") + def cpu_load(self) -> _builtins.float: + return pulumi.get(self, "cpu_load") + + @_builtins.property + @pulumi.getter(name="cpuTime") + def cpu_time(self) -> _builtins.float: + return pulumi.get(self, "cpu_time") + + @_builtins.property + @pulumi.getter + def cpus(self) -> _builtins.float: + return pulumi.get(self, "cpus") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def executors(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "executors") + + @_builtins.property + @pulumi.getter + def failed(self) -> _builtins.float: + return pulumi.get(self, "failed") + + @_builtins.property + @pulumi.getter(name="invCtxSwitch") + def inv_ctx_switch(self) -> _builtins.float: + return pulumi.get(self, "inv_ctx_switch") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="loadCpus") + def load_cpus(self) -> _builtins.float: + return pulumi.get(self, "load_cpus") + + @_builtins.property + @pulumi.getter(name="loadMemory") + def load_memory(self) -> _builtins.float: + return pulumi.get(self, "load_memory") + + @_builtins.property + @pulumi.getter(name="loadTasks") + def load_tasks(self) -> _builtins.float: + return pulumi.get(self, "load_tasks") + + @_builtins.property + @pulumi.getter(name="memoryEfficiency") + def memory_efficiency(self) -> _builtins.float: + return pulumi.get(self, "memory_efficiency") + + @_builtins.property + @pulumi.getter(name="memoryReq") + def memory_req(self) -> _builtins.float: + return pulumi.get(self, "memory_req") + + @_builtins.property + @pulumi.getter(name="memoryRss") + def memory_rss(self) -> _builtins.float: + return pulumi.get(self, "memory_rss") + + @_builtins.property + @pulumi.getter(name="peakCpus") + def peak_cpus(self) -> _builtins.float: + return pulumi.get(self, "peak_cpus") + + @_builtins.property + @pulumi.getter(name="peakMemory") + def peak_memory(self) -> _builtins.float: + return pulumi.get(self, "peak_memory") + + @_builtins.property + @pulumi.getter(name="peakTasks") + def peak_tasks(self) -> _builtins.float: + return pulumi.get(self, "peak_tasks") + + @_builtins.property + @pulumi.getter + def pending(self) -> _builtins.float: + return pulumi.get(self, "pending") + + @_builtins.property + @pulumi.getter(name="readBytes") + def read_bytes(self) -> _builtins.float: + return pulumi.get(self, "read_bytes") + + @_builtins.property + @pulumi.getter + def running(self) -> _builtins.float: + return pulumi.get(self, "running") + + @_builtins.property + @pulumi.getter + def submitted(self) -> _builtins.float: + return pulumi.get(self, "submitted") + + @_builtins.property + @pulumi.getter + def succeeded(self) -> _builtins.float: + return pulumi.get(self, "succeeded") + + @_builtins.property + @pulumi.getter(name="volCtxSwitch") + def vol_ctx_switch(self) -> _builtins.float: + return pulumi.get(self, "vol_ctx_switch") + + @_builtins.property + @pulumi.getter(name="writeBytes") + def write_bytes(self) -> _builtins.float: + return pulumi.get(self, "write_bytes") + + +@pulumi.output_type +class GetWorkflowsWorkflowResult(dict): + def __init__(__self__, *, + command_line: _builtins.str, + commit_id: _builtins.str, + complete: _builtins.str, + config_files: Sequence[_builtins.str], + config_text: _builtins.str, + container: _builtins.str, + container_engine: _builtins.str, + date_created: _builtins.str, + deleted: _builtins.bool, + duration: _builtins.float, + error_message: _builtins.str, + error_report: _builtins.str, + exit_status: _builtins.float, + home_dir: _builtins.str, + id: _builtins.str, + last_updated: _builtins.str, + launch_dir: _builtins.str, + launch_id: _builtins.str, + log_file: _builtins.str, + manifest: 'outputs.GetWorkflowsWorkflowManifestResult', + nextflow: 'outputs.GetWorkflowsWorkflowNextflowResult', + operation_id: _builtins.str, + out_file: _builtins.str, + owner_id: _builtins.float, + params: Mapping[str, _builtins.str], + profile: _builtins.str, + project_dir: _builtins.str, + project_name: _builtins.str, + repository: _builtins.str, + requires_attention: _builtins.bool, + resume: _builtins.bool, + revision: _builtins.str, + run_name: _builtins.str, + script_file: _builtins.str, + script_id: _builtins.str, + script_name: _builtins.str, + session_id: _builtins.str, + start: _builtins.str, + stats: 'outputs.GetWorkflowsWorkflowStatsResult', + status: _builtins.str, + submit: _builtins.str, + success: _builtins.bool, + user_name: _builtins.str, + work_dir: _builtins.str): + pulumi.set(__self__, "command_line", command_line) + pulumi.set(__self__, "commit_id", commit_id) + pulumi.set(__self__, "complete", complete) + pulumi.set(__self__, "config_files", config_files) + pulumi.set(__self__, "config_text", config_text) + pulumi.set(__self__, "container", container) + pulumi.set(__self__, "container_engine", container_engine) + pulumi.set(__self__, "date_created", date_created) + pulumi.set(__self__, "deleted", deleted) + pulumi.set(__self__, "duration", duration) + pulumi.set(__self__, "error_message", error_message) + pulumi.set(__self__, "error_report", error_report) + pulumi.set(__self__, "exit_status", exit_status) + pulumi.set(__self__, "home_dir", home_dir) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "last_updated", last_updated) + pulumi.set(__self__, "launch_dir", launch_dir) + pulumi.set(__self__, "launch_id", launch_id) + pulumi.set(__self__, "log_file", log_file) + pulumi.set(__self__, "manifest", manifest) + pulumi.set(__self__, "nextflow", nextflow) + pulumi.set(__self__, "operation_id", operation_id) + pulumi.set(__self__, "out_file", out_file) + pulumi.set(__self__, "owner_id", owner_id) + pulumi.set(__self__, "params", params) + pulumi.set(__self__, "profile", profile) + pulumi.set(__self__, "project_dir", project_dir) + pulumi.set(__self__, "project_name", project_name) + pulumi.set(__self__, "repository", repository) + pulumi.set(__self__, "requires_attention", requires_attention) + pulumi.set(__self__, "resume", resume) + pulumi.set(__self__, "revision", revision) + pulumi.set(__self__, "run_name", run_name) + pulumi.set(__self__, "script_file", script_file) + pulumi.set(__self__, "script_id", script_id) + pulumi.set(__self__, "script_name", script_name) + pulumi.set(__self__, "session_id", session_id) + pulumi.set(__self__, "start", start) + pulumi.set(__self__, "stats", stats) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "submit", submit) + pulumi.set(__self__, "success", success) + pulumi.set(__self__, "user_name", user_name) + pulumi.set(__self__, "work_dir", work_dir) + + @_builtins.property + @pulumi.getter(name="commandLine") + def command_line(self) -> _builtins.str: + return pulumi.get(self, "command_line") + + @_builtins.property + @pulumi.getter(name="commitId") + def commit_id(self) -> _builtins.str: + return pulumi.get(self, "commit_id") + + @_builtins.property + @pulumi.getter + def complete(self) -> _builtins.str: + return pulumi.get(self, "complete") + + @_builtins.property + @pulumi.getter(name="configFiles") + def config_files(self) -> Sequence[_builtins.str]: + return pulumi.get(self, "config_files") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> _builtins.str: + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter + def container(self) -> _builtins.str: + return pulumi.get(self, "container") + + @_builtins.property + @pulumi.getter(name="containerEngine") + def container_engine(self) -> _builtins.str: + return pulumi.get(self, "container_engine") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> _builtins.str: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def deleted(self) -> _builtins.bool: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def duration(self) -> _builtins.float: + return pulumi.get(self, "duration") + + @_builtins.property + @pulumi.getter(name="errorMessage") + def error_message(self) -> _builtins.str: + return pulumi.get(self, "error_message") + + @_builtins.property + @pulumi.getter(name="errorReport") + def error_report(self) -> _builtins.str: + return pulumi.get(self, "error_report") + + @_builtins.property + @pulumi.getter(name="exitStatus") + def exit_status(self) -> _builtins.float: + return pulumi.get(self, "exit_status") + + @_builtins.property + @pulumi.getter(name="homeDir") + def home_dir(self) -> _builtins.str: + return pulumi.get(self, "home_dir") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.str: + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> _builtins.str: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="launchDir") + def launch_dir(self) -> _builtins.str: + return pulumi.get(self, "launch_dir") + + @_builtins.property + @pulumi.getter(name="launchId") + def launch_id(self) -> _builtins.str: + return pulumi.get(self, "launch_id") + + @_builtins.property + @pulumi.getter(name="logFile") + def log_file(self) -> _builtins.str: + return pulumi.get(self, "log_file") + + @_builtins.property + @pulumi.getter + def manifest(self) -> 'outputs.GetWorkflowsWorkflowManifestResult': + return pulumi.get(self, "manifest") + + @_builtins.property + @pulumi.getter + def nextflow(self) -> 'outputs.GetWorkflowsWorkflowNextflowResult': + return pulumi.get(self, "nextflow") + + @_builtins.property + @pulumi.getter(name="operationId") + def operation_id(self) -> _builtins.str: + return pulumi.get(self, "operation_id") + + @_builtins.property + @pulumi.getter(name="outFile") + def out_file(self) -> _builtins.str: + return pulumi.get(self, "out_file") + + @_builtins.property + @pulumi.getter(name="ownerId") + def owner_id(self) -> _builtins.float: + return pulumi.get(self, "owner_id") + + @_builtins.property + @pulumi.getter + def params(self) -> Mapping[str, _builtins.str]: + return pulumi.get(self, "params") + + @_builtins.property + @pulumi.getter + def profile(self) -> _builtins.str: + return pulumi.get(self, "profile") + + @_builtins.property + @pulumi.getter(name="projectDir") + def project_dir(self) -> _builtins.str: + return pulumi.get(self, "project_dir") + + @_builtins.property + @pulumi.getter(name="projectName") + def project_name(self) -> _builtins.str: + return pulumi.get(self, "project_name") + + @_builtins.property + @pulumi.getter + def repository(self) -> _builtins.str: + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter(name="requiresAttention") + def requires_attention(self) -> _builtins.bool: + return pulumi.get(self, "requires_attention") + + @_builtins.property + @pulumi.getter + def resume(self) -> _builtins.bool: + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter + def revision(self) -> _builtins.str: + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> _builtins.str: + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="scriptFile") + def script_file(self) -> _builtins.str: + return pulumi.get(self, "script_file") + + @_builtins.property + @pulumi.getter(name="scriptId") + def script_id(self) -> _builtins.str: + return pulumi.get(self, "script_id") + + @_builtins.property + @pulumi.getter(name="scriptName") + def script_name(self) -> _builtins.str: + return pulumi.get(self, "script_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> _builtins.str: + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter + def start(self) -> _builtins.str: + return pulumi.get(self, "start") + + @_builtins.property + @pulumi.getter + def stats(self) -> 'outputs.GetWorkflowsWorkflowStatsResult': + return pulumi.get(self, "stats") + + @_builtins.property + @pulumi.getter + def status(self) -> _builtins.str: + return pulumi.get(self, "status") + + @_builtins.property + @pulumi.getter + def submit(self) -> _builtins.str: + return pulumi.get(self, "submit") + + @_builtins.property + @pulumi.getter + def success(self) -> _builtins.bool: + return pulumi.get(self, "success") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> _builtins.str: + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> _builtins.str: + return pulumi.get(self, "work_dir") + + +@pulumi.output_type +class GetWorkflowsWorkflowManifestResult(dict): + def __init__(__self__, *, + author: _builtins.str, + default_branch: _builtins.str, + description: _builtins.str, + gitmodules: _builtins.str, + home_page: _builtins.str, + icon: _builtins.str, + main_script: _builtins.str, + name: _builtins.str, + nextflow_version: _builtins.str, + version: _builtins.str): + pulumi.set(__self__, "author", author) + pulumi.set(__self__, "default_branch", default_branch) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "gitmodules", gitmodules) + pulumi.set(__self__, "home_page", home_page) + pulumi.set(__self__, "icon", icon) + pulumi.set(__self__, "main_script", main_script) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "nextflow_version", nextflow_version) + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def author(self) -> _builtins.str: + return pulumi.get(self, "author") + + @_builtins.property + @pulumi.getter(name="defaultBranch") + def default_branch(self) -> _builtins.str: + return pulumi.get(self, "default_branch") + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def gitmodules(self) -> _builtins.str: + return pulumi.get(self, "gitmodules") + + @_builtins.property + @pulumi.getter(name="homePage") + def home_page(self) -> _builtins.str: + return pulumi.get(self, "home_page") + + @_builtins.property + @pulumi.getter + def icon(self) -> _builtins.str: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> _builtins.str: + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="nextflowVersion") + def nextflow_version(self) -> _builtins.str: + return pulumi.get(self, "nextflow_version") + + @_builtins.property + @pulumi.getter + def version(self) -> _builtins.str: + return pulumi.get(self, "version") + + +@pulumi.output_type +class GetWorkflowsWorkflowNextflowResult(dict): + def __init__(__self__, *, + build: _builtins.str, + timestamp: _builtins.str, + version: _builtins.str): + pulumi.set(__self__, "build", build) + pulumi.set(__self__, "timestamp", timestamp) + pulumi.set(__self__, "version", version) + + @_builtins.property + @pulumi.getter + def build(self) -> _builtins.str: + return pulumi.get(self, "build") + + @_builtins.property + @pulumi.getter + def timestamp(self) -> _builtins.str: + return pulumi.get(self, "timestamp") + + @_builtins.property + @pulumi.getter + def version(self) -> _builtins.str: + return pulumi.get(self, "version") + + +@pulumi.output_type +class GetWorkflowsWorkflowStatsResult(dict): + def __init__(__self__, *, + cached_count: _builtins.float, + cached_count_fmt: _builtins.str, + cached_duration: _builtins.float, + cached_pct: _builtins.float, + compute_time_fmt: _builtins.str, + failed_count: _builtins.float, + failed_count_fmt: _builtins.str, + failed_duration: _builtins.float, + failed_pct: _builtins.float, + ignored_count: _builtins.float, + ignored_count_fmt: _builtins.str, + ignored_pct: _builtins.float, + succeed_count: _builtins.float, + succeed_count_fmt: _builtins.str, + succeed_duration: _builtins.float, + succeed_pct: _builtins.float): + pulumi.set(__self__, "cached_count", cached_count) + pulumi.set(__self__, "cached_count_fmt", cached_count_fmt) + pulumi.set(__self__, "cached_duration", cached_duration) + pulumi.set(__self__, "cached_pct", cached_pct) + pulumi.set(__self__, "compute_time_fmt", compute_time_fmt) + pulumi.set(__self__, "failed_count", failed_count) + pulumi.set(__self__, "failed_count_fmt", failed_count_fmt) + pulumi.set(__self__, "failed_duration", failed_duration) + pulumi.set(__self__, "failed_pct", failed_pct) + pulumi.set(__self__, "ignored_count", ignored_count) + pulumi.set(__self__, "ignored_count_fmt", ignored_count_fmt) + pulumi.set(__self__, "ignored_pct", ignored_pct) + pulumi.set(__self__, "succeed_count", succeed_count) + pulumi.set(__self__, "succeed_count_fmt", succeed_count_fmt) + pulumi.set(__self__, "succeed_duration", succeed_duration) + pulumi.set(__self__, "succeed_pct", succeed_pct) + + @_builtins.property + @pulumi.getter(name="cachedCount") + def cached_count(self) -> _builtins.float: + return pulumi.get(self, "cached_count") + + @_builtins.property + @pulumi.getter(name="cachedCountFmt") + def cached_count_fmt(self) -> _builtins.str: + return pulumi.get(self, "cached_count_fmt") + + @_builtins.property + @pulumi.getter(name="cachedDuration") + def cached_duration(self) -> _builtins.float: + return pulumi.get(self, "cached_duration") + + @_builtins.property + @pulumi.getter(name="cachedPct") + def cached_pct(self) -> _builtins.float: + return pulumi.get(self, "cached_pct") + + @_builtins.property + @pulumi.getter(name="computeTimeFmt") + def compute_time_fmt(self) -> _builtins.str: + return pulumi.get(self, "compute_time_fmt") + + @_builtins.property + @pulumi.getter(name="failedCount") + def failed_count(self) -> _builtins.float: + return pulumi.get(self, "failed_count") + + @_builtins.property + @pulumi.getter(name="failedCountFmt") + def failed_count_fmt(self) -> _builtins.str: + return pulumi.get(self, "failed_count_fmt") + + @_builtins.property + @pulumi.getter(name="failedDuration") + def failed_duration(self) -> _builtins.float: + return pulumi.get(self, "failed_duration") + + @_builtins.property + @pulumi.getter(name="failedPct") + def failed_pct(self) -> _builtins.float: + return pulumi.get(self, "failed_pct") + + @_builtins.property + @pulumi.getter(name="ignoredCount") + def ignored_count(self) -> _builtins.float: + return pulumi.get(self, "ignored_count") + + @_builtins.property + @pulumi.getter(name="ignoredCountFmt") + def ignored_count_fmt(self) -> _builtins.str: + return pulumi.get(self, "ignored_count_fmt") + + @_builtins.property + @pulumi.getter(name="ignoredPct") + def ignored_pct(self) -> _builtins.float: + return pulumi.get(self, "ignored_pct") + + @_builtins.property + @pulumi.getter(name="succeedCount") + def succeed_count(self) -> _builtins.float: + return pulumi.get(self, "succeed_count") + + @_builtins.property + @pulumi.getter(name="succeedCountFmt") + def succeed_count_fmt(self) -> _builtins.str: + return pulumi.get(self, "succeed_count_fmt") + + @_builtins.property + @pulumi.getter(name="succeedDuration") + def succeed_duration(self) -> _builtins.float: + return pulumi.get(self, "succeed_duration") + + @_builtins.property + @pulumi.getter(name="succeedPct") + def succeed_pct(self) -> _builtins.float: + return pulumi.get(self, "succeed_pct") + + +@pulumi.output_type +class GetWorkspacesWorkspaceResult(dict): + def __init__(__self__, *, + description: _builtins.str, + full_name: _builtins.str, + id: _builtins.float, + name: _builtins.str, + visibility: _builtins.str): + """ + :param _builtins.str description: Detailed description of the workspace's purpose + :param _builtins.str full_name: Complete display name for the workspace + :param _builtins.float id: Unique numeric identifier for the workspace + :param _builtins.str name: Short name or handle for the workspace + """ + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "full_name", full_name) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "visibility", visibility) + + @_builtins.property + @pulumi.getter + def description(self) -> _builtins.str: + """ + Detailed description of the workspace's purpose + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> _builtins.str: + """ + Complete display name for the workspace + """ + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter + def id(self) -> _builtins.float: + """ + Unique numeric identifier for the workspace + """ + return pulumi.get(self, "id") + + @_builtins.property + @pulumi.getter + def name(self) -> _builtins.str: + """ + Short name or handle for the workspace + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def visibility(self) -> _builtins.str: + return pulumi.get(self, "visibility") + + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pipeline.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pipeline.py new file mode 100644 index 00000000..45b9d6dc --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pipeline.py @@ -0,0 +1,711 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['PipelineArgs', 'Pipeline'] + +@pulumi.input_type +class PipelineArgs: + def __init__(__self__, *, + launch: pulumi.Input['PipelineLaunchArgs'], + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Pipeline resource. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + pulumi.set(__self__, "launch", launch) + if description is not None: + pulumi.set(__self__, "description", description) + if icon is not None: + pulumi.set(__self__, "icon", icon) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if name is not None: + pulumi.set(__self__, "name", name) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def launch(self) -> pulumi.Input['PipelineLaunchArgs']: + return pulumi.get(self, "launch") + + @launch.setter + def launch(self, value: pulumi.Input['PipelineLaunchArgs']): + pulumi.set(self, "launch", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "icon") + + @icon.setter + def icon(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "icon", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _PipelineState: + def __init__(__self__, *, + compute_env: Optional[pulumi.Input['PipelineComputeEnvArgs']] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineLabelArgs']]]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch: Optional[pulumi.Input['PipelineLaunchArgs']] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_status: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + org_name: Optional[pulumi.Input[_builtins.str]] = None, + pipeline_id: Optional[pulumi.Input[_builtins.float]] = None, + repository: Optional[pulumi.Input[_builtins.str]] = None, + user_first_name: Optional[pulumi.Input[_builtins.str]] = None, + user_id: Optional[pulumi.Input[_builtins.float]] = None, + user_last_name: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_name: Optional[pulumi.Input[_builtins.str]] = None): + """ + Input properties used for looking up and filtering Pipeline resources. + :param pulumi.Input[_builtins.str] optimization_status: must be one of ["OPTIMIZED", "OPTIMIZABLE", "UNAVAILABLE"] + :param pulumi.Input[_builtins.float] pipeline_id: Unique numeric identifier for the pipeline + :param pulumi.Input[_builtins.str] repository: Git repository URL containing the pipeline source code + :param pulumi.Input[_builtins.str] user_first_name: First name of the user who created the pipeline + :param pulumi.Input[_builtins.float] user_id: Numeric identifier of the user who created the pipeline + :param pulumi.Input[_builtins.str] user_name: Username of the pipeline creator + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if deleted is not None: + pulumi.set(__self__, "deleted", deleted) + if description is not None: + pulumi.set(__self__, "description", description) + if icon is not None: + pulumi.set(__self__, "icon", icon) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if launch is not None: + pulumi.set(__self__, "launch", launch) + if name is not None: + pulumi.set(__self__, "name", name) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_status is not None: + pulumi.set(__self__, "optimization_status", optimization_status) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if org_name is not None: + pulumi.set(__self__, "org_name", org_name) + if pipeline_id is not None: + pulumi.set(__self__, "pipeline_id", pipeline_id) + if repository is not None: + pulumi.set(__self__, "repository", repository) + if user_first_name is not None: + pulumi.set(__self__, "user_first_name", user_first_name) + if user_id is not None: + pulumi.set(__self__, "user_id", user_id) + if user_last_name is not None: + pulumi.set(__self__, "user_last_name", user_last_name) + if user_name is not None: + pulumi.set(__self__, "user_name", user_name) + if visibility is not None: + pulumi.set(__self__, "visibility", visibility) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + if workspace_name is not None: + pulumi.set(__self__, "workspace_name", workspace_name) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional[pulumi.Input['PipelineComputeEnvArgs']]: + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: Optional[pulumi.Input['PipelineComputeEnvArgs']]): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter + def deleted(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "deleted") + + @deleted.setter + def deleted(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "deleted", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def icon(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "icon") + + @icon.setter + def icon(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "icon", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PipelineLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PipelineLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter + def launch(self) -> Optional[pulumi.Input['PipelineLaunchArgs']]: + return pulumi.get(self, "launch") + + @launch.setter + def launch(self, value: Optional[pulumi.Input['PipelineLaunchArgs']]): + pulumi.set(self, "launch", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationStatus") + def optimization_status(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["OPTIMIZED", "OPTIMIZABLE", "UNAVAILABLE"] + """ + return pulumi.get(self, "optimization_status") + + @optimization_status.setter + def optimization_status(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_status", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "org_name") + + @org_name.setter + def org_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "org_name", value) + + @_builtins.property + @pulumi.getter(name="pipelineId") + def pipeline_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the pipeline + """ + return pulumi.get(self, "pipeline_id") + + @pipeline_id.setter + def pipeline_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "pipeline_id", value) + + @_builtins.property + @pulumi.getter + def repository(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Git repository URL containing the pipeline source code + """ + return pulumi.get(self, "repository") + + @repository.setter + def repository(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "repository", value) + + @_builtins.property + @pulumi.getter(name="userFirstName") + def user_first_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + First name of the user who created the pipeline + """ + return pulumi.get(self, "user_first_name") + + @user_first_name.setter + def user_first_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_first_name", value) + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Numeric identifier of the user who created the pipeline + """ + return pulumi.get(self, "user_id") + + @user_id.setter + def user_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "user_id", value) + + @_builtins.property + @pulumi.getter(name="userLastName") + def user_last_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "user_last_name") + + @user_last_name.setter + def user_last_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_last_name", value) + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Username of the pipeline creator + """ + return pulumi.get(self, "user_name") + + @user_name.setter + def user_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "user_name", value) + + @_builtins.property + @pulumi.getter + def visibility(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "visibility") + + @visibility.setter + def visibility(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "visibility", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "workspace_name") + + @workspace_name.setter + def workspace_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "workspace_name", value) + + +@pulumi.type_token("seqera:index/pipeline:Pipeline") +class Pipeline(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch: Optional[pulumi.Input[Union['PipelineLaunchArgs', 'PipelineLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Pipeline resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PipelineArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Pipeline resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param PipelineArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(PipelineArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch: Optional[pulumi.Input[Union['PipelineLaunchArgs', 'PipelineLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = PipelineArgs.__new__(PipelineArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["icon"] = icon + __props__.__dict__["label_ids"] = label_ids + if launch is None and not opts.urn: + raise TypeError("Missing required property 'launch'") + __props__.__dict__["launch"] = launch + __props__.__dict__["name"] = name + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["compute_env"] = None + __props__.__dict__["deleted"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["optimization_id"] = None + __props__.__dict__["optimization_status"] = None + __props__.__dict__["optimization_targets"] = None + __props__.__dict__["org_id"] = None + __props__.__dict__["org_name"] = None + __props__.__dict__["pipeline_id"] = None + __props__.__dict__["repository"] = None + __props__.__dict__["user_first_name"] = None + __props__.__dict__["user_id"] = None + __props__.__dict__["user_last_name"] = None + __props__.__dict__["user_name"] = None + __props__.__dict__["visibility"] = None + __props__.__dict__["workspace_name"] = None + super(Pipeline, __self__).__init__( + 'seqera:index/pipeline:Pipeline', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + compute_env: Optional[pulumi.Input[Union['PipelineComputeEnvArgs', 'PipelineComputeEnvArgsDict']]] = None, + deleted: Optional[pulumi.Input[_builtins.bool]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + icon: Optional[pulumi.Input[_builtins.str]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['PipelineLabelArgs', 'PipelineLabelArgsDict']]]]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + launch: Optional[pulumi.Input[Union['PipelineLaunchArgs', 'PipelineLaunchArgsDict']]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_status: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + org_name: Optional[pulumi.Input[_builtins.str]] = None, + pipeline_id: Optional[pulumi.Input[_builtins.float]] = None, + repository: Optional[pulumi.Input[_builtins.str]] = None, + user_first_name: Optional[pulumi.Input[_builtins.str]] = None, + user_id: Optional[pulumi.Input[_builtins.float]] = None, + user_last_name: Optional[pulumi.Input[_builtins.str]] = None, + user_name: Optional[pulumi.Input[_builtins.str]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_name: Optional[pulumi.Input[_builtins.str]] = None) -> 'Pipeline': + """ + Get an existing Pipeline resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] optimization_status: must be one of ["OPTIMIZED", "OPTIMIZABLE", "UNAVAILABLE"] + :param pulumi.Input[_builtins.float] pipeline_id: Unique numeric identifier for the pipeline + :param pulumi.Input[_builtins.str] repository: Git repository URL containing the pipeline source code + :param pulumi.Input[_builtins.str] user_first_name: First name of the user who created the pipeline + :param pulumi.Input[_builtins.float] user_id: Numeric identifier of the user who created the pipeline + :param pulumi.Input[_builtins.str] user_name: Username of the pipeline creator + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PipelineState.__new__(_PipelineState) + + __props__.__dict__["compute_env"] = compute_env + __props__.__dict__["deleted"] = deleted + __props__.__dict__["description"] = description + __props__.__dict__["icon"] = icon + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["labels"] = labels + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["launch"] = launch + __props__.__dict__["name"] = name + __props__.__dict__["optimization_id"] = optimization_id + __props__.__dict__["optimization_status"] = optimization_status + __props__.__dict__["optimization_targets"] = optimization_targets + __props__.__dict__["org_id"] = org_id + __props__.__dict__["org_name"] = org_name + __props__.__dict__["pipeline_id"] = pipeline_id + __props__.__dict__["repository"] = repository + __props__.__dict__["user_first_name"] = user_first_name + __props__.__dict__["user_id"] = user_id + __props__.__dict__["user_last_name"] = user_last_name + __props__.__dict__["user_name"] = user_name + __props__.__dict__["visibility"] = visibility + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["workspace_name"] = workspace_name + return Pipeline(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> pulumi.Output['outputs.PipelineComputeEnv']: + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter + def deleted(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "deleted") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter + def icon(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "icon") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.float]]]: + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.PipelineLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def launch(self) -> pulumi.Output['outputs.PipelineLaunch']: + return pulumi.get(self, "launch") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationStatus") + def optimization_status(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["OPTIMIZED", "OPTIMIZABLE", "UNAVAILABLE"] + """ + return pulumi.get(self, "optimization_status") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter(name="pipelineId") + def pipeline_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the pipeline + """ + return pulumi.get(self, "pipeline_id") + + @_builtins.property + @pulumi.getter + def repository(self) -> pulumi.Output[_builtins.str]: + """ + Git repository URL containing the pipeline source code + """ + return pulumi.get(self, "repository") + + @_builtins.property + @pulumi.getter(name="userFirstName") + def user_first_name(self) -> pulumi.Output[_builtins.str]: + """ + First name of the user who created the pipeline + """ + return pulumi.get(self, "user_first_name") + + @_builtins.property + @pulumi.getter(name="userId") + def user_id(self) -> pulumi.Output[_builtins.float]: + """ + Numeric identifier of the user who created the pipeline + """ + return pulumi.get(self, "user_id") + + @_builtins.property + @pulumi.getter(name="userLastName") + def user_last_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "user_last_name") + + @_builtins.property + @pulumi.getter(name="userName") + def user_name(self) -> pulumi.Output[_builtins.str]: + """ + Username of the pipeline creator + """ + return pulumi.get(self, "user_name") + + @_builtins.property + @pulumi.getter + def visibility(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "visibility") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "workspace_name") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pipeline_secret.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pipeline_secret.py new file mode 100644 index 00000000..a853cf61 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pipeline_secret.py @@ -0,0 +1,364 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['PipelineSecretArgs', 'PipelineSecret'] + +@pulumi.input_type +class PipelineSecretArgs: + def __init__(__self__, *, + value: pulumi.Input[_builtins.str], + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a PipelineSecret resource. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + pulumi.set(__self__, "value", value) + if name is not None: + pulumi.set(__self__, "name", name) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter + def value(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "value", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _PipelineSecretState: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + pipeline_secret_id: Optional[pulumi.Input[_builtins.float]] = None, + secret_id: Optional[pulumi.Input[_builtins.float]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering PipelineSecret resources. + :param pulumi.Input[_builtins.str] date_created: Read-only timestamp when the secret was created + :param pulumi.Input[_builtins.str] last_used: Read-only timestamp when the secret was last accessed + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] pipeline_secret_id: Unique numeric identifier for the secret (nullable) + :param pulumi.Input[_builtins.float] secret_id: Secret numeric identifier + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + if pipeline_secret_id is not None: + pulumi.set(__self__, "pipeline_secret_id", pipeline_secret_id) + if secret_id is not None: + pulumi.set(__self__, "secret_id", secret_id) + if value is not None: + pulumi.set(__self__, "value", value) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Read-only timestamp when the secret was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Read-only timestamp when the secret was last accessed + """ + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="pipelineSecretId") + def pipeline_secret_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the secret (nullable) + """ + return pulumi.get(self, "pipeline_secret_id") + + @pipeline_secret_id.setter + def pipeline_secret_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "pipeline_secret_id", value) + + @_builtins.property + @pulumi.getter(name="secretId") + def secret_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Secret numeric identifier + """ + return pulumi.get(self, "secret_id") + + @secret_id.setter + def secret_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "secret_id", value) + + @_builtins.property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "value", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/pipelineSecret:PipelineSecret") +class PipelineSecret(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a PipelineSecret resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PipelineSecretArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a PipelineSecret resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param PipelineSecretArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(PipelineSecretArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = PipelineSecretArgs.__new__(PipelineSecretArgs) + + __props__.__dict__["name"] = name + if value is None and not opts.urn: + raise TypeError("Missing required property 'value'") + __props__.__dict__["value"] = value + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["date_created"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["last_used"] = None + __props__.__dict__["pipeline_secret_id"] = None + __props__.__dict__["secret_id"] = None + super(PipelineSecret, __self__).__init__( + 'seqera:index/pipelineSecret:PipelineSecret', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + pipeline_secret_id: Optional[pulumi.Input[_builtins.float]] = None, + secret_id: Optional[pulumi.Input[_builtins.float]] = None, + value: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'PipelineSecret': + """ + Get an existing PipelineSecret resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] date_created: Read-only timestamp when the secret was created + :param pulumi.Input[_builtins.str] last_used: Read-only timestamp when the secret was last accessed + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] pipeline_secret_id: Unique numeric identifier for the secret (nullable) + :param pulumi.Input[_builtins.float] secret_id: Secret numeric identifier + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PipelineSecretState.__new__(_PipelineSecretState) + + __props__.__dict__["date_created"] = date_created + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["last_used"] = last_used + __props__.__dict__["name"] = name + __props__.__dict__["pipeline_secret_id"] = pipeline_secret_id + __props__.__dict__["secret_id"] = secret_id + __props__.__dict__["value"] = value + __props__.__dict__["workspace_id"] = workspace_id + return PipelineSecret(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + """ + Read-only timestamp when the secret was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> pulumi.Output[_builtins.str]: + """ + Read-only timestamp when the secret was last accessed + """ + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="pipelineSecretId") + def pipeline_secret_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the secret (nullable) + """ + return pulumi.get(self, "pipeline_secret_id") + + @_builtins.property + @pulumi.getter(name="secretId") + def secret_id(self) -> pulumi.Output[_builtins.float]: + """ + Secret numeric identifier + """ + return pulumi.get(self, "secret_id") + + @_builtins.property + @pulumi.getter + def value(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "value") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/provider.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/provider.py new file mode 100644 index 00000000..7527e804 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/provider.py @@ -0,0 +1,156 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ProviderArgs', 'Provider'] + +@pulumi.input_type +class ProviderArgs: + def __init__(__self__, *, + bearer_auth: pulumi.Input[_builtins.str], + server_url: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Provider resource. + :param pulumi.Input[_builtins.str] server_url: Server URL (defaults to https://api.cloud.seqera.io) + """ + pulumi.set(__self__, "bearer_auth", bearer_auth) + if server_url is not None: + pulumi.set(__self__, "server_url", server_url) + + @_builtins.property + @pulumi.getter(name="bearerAuth") + def bearer_auth(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "bearer_auth") + + @bearer_auth.setter + def bearer_auth(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "bearer_auth", value) + + @_builtins.property + @pulumi.getter(name="serverUrl") + def server_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Server URL (defaults to https://api.cloud.seqera.io) + """ + return pulumi.get(self, "server_url") + + @server_url.setter + def server_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "server_url", value) + + +@pulumi.type_token("pulumi:providers:seqera") +class Provider(pulumi.ProviderResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bearer_auth: Optional[pulumi.Input[_builtins.str]] = None, + server_url: Optional[pulumi.Input[_builtins.str]] = None, + __props__=None): + """ + The provider type for the seqera package. By default, resources use package-wide configuration + settings, however an explicit `Provider` instance may be created and passed during resource + construction to achieve fine-grained programmatic control over provider settings. See the + [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] server_url: Server URL (defaults to https://api.cloud.seqera.io) + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ProviderArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + The provider type for the seqera package. By default, resources use package-wide configuration + settings, however an explicit `Provider` instance may be created and passed during resource + construction to achieve fine-grained programmatic control over provider settings. See the + [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. + + :param str resource_name: The name of the resource. + :param ProviderArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(ProviderArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bearer_auth: Optional[pulumi.Input[_builtins.str]] = None, + server_url: Optional[pulumi.Input[_builtins.str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ProviderArgs.__new__(ProviderArgs) + + if bearer_auth is None and not opts.urn: + raise TypeError("Missing required property 'bearer_auth'") + __props__.__dict__["bearer_auth"] = None if bearer_auth is None else pulumi.Output.secret(bearer_auth) + __props__.__dict__["server_url"] = server_url + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["bearerAuth"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(Provider, __self__).__init__( + 'seqera', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @_builtins.property + @pulumi.getter(name="bearerAuth") + def bearer_auth(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "bearer_auth") + + @_builtins.property + @pulumi.getter(name="serverUrl") + def server_url(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Server URL (defaults to https://api.cloud.seqera.io) + """ + return pulumi.get(self, "server_url") + + @pulumi.output_type + class TerraformConfigResult: + def __init__(__self__, result=None): + if result and not isinstance(result, dict): + raise TypeError("Expected argument 'result' to be a dict") + pulumi.set(__self__, "result", result) + + @_builtins.property + @pulumi.getter + def result(self) -> Mapping[str, Any]: + return pulumi.get(self, "result") + + def terraform_config(__self__) -> pulumi.Output['Provider.TerraformConfigResult']: + """ + This function returns a Terraform config object with terraform-namecased keys,to be used with the Terraform Module Provider. + """ + __args__ = dict() + __args__['__self__'] = __self__ + return pulumi.runtime.call('pulumi:providers:seqera/terraformConfig', __args__, res=__self__, typ=Provider.TerraformConfigResult, package_ref=_utilities.get_package()) + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pulumi-plugin.json b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pulumi-plugin.json new file mode 100644 index 00000000..d30dbb9d --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/pulumi-plugin.json @@ -0,0 +1,10 @@ +{ + "resource": true, + "name": "terraform-provider", + "version": "0.13.0", + "parameterization": { + "name": "seqera", + "version": "0.25.2", + "value": "eyJyZW1vdGUiOnsidXJsIjoicmVnaXN0cnkudGVycmFmb3JtLmlvL3NlcWVyYWxhYnMvc2VxZXJhIiwidmVyc2lvbiI6IjAuMjUuMiJ9fQ==" + } +} diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/studios.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/studios.py new file mode 100644 index 00000000..d4ef6458 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/studios.py @@ -0,0 +1,1000 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['StudiosArgs', 'Studios'] + +@pulumi.input_type +class StudiosArgs: + def __init__(__self__, *, + compute_env_id: pulumi.Input[_builtins.str], + data_studio_tool_url: pulumi.Input[_builtins.str], + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + configuration: Optional[pulumi.Input['StudiosConfigurationArgs']] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Studios resource. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] data_studio_tool_url: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] auto_start: Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + :param pulumi.Input['StudiosConfigurationArgs'] configuration: Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.float] initial_checkpoint_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] is_private: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "data_studio_tool_url", data_studio_tool_url) + if auto_start is not None: + pulumi.set(__self__, "auto_start", auto_start) + if configuration is not None: + pulumi.set(__self__, "configuration", configuration) + if description is not None: + pulumi.set(__self__, "description", description) + if initial_checkpoint_id is not None: + pulumi.set(__self__, "initial_checkpoint_id", initial_checkpoint_id) + if is_private is not None: + pulumi.set(__self__, "is_private", is_private) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if name is not None: + pulumi.set(__self__, "name", name) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter(name="dataStudioToolUrl") + def data_studio_tool_url(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "data_studio_tool_url") + + @data_studio_tool_url.setter + def data_studio_tool_url(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "data_studio_tool_url", value) + + @_builtins.property + @pulumi.getter(name="autoStart") + def auto_start(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + """ + return pulumi.get(self, "auto_start") + + @auto_start.setter + def auto_start(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_start", value) + + @_builtins.property + @pulumi.getter + def configuration(self) -> Optional[pulumi.Input['StudiosConfigurationArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "configuration") + + @configuration.setter + def configuration(self, value: Optional[pulumi.Input['StudiosConfigurationArgs']]): + pulumi.set(self, "configuration", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="initialCheckpointId") + def initial_checkpoint_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "initial_checkpoint_id") + + @initial_checkpoint_id.setter + def initial_checkpoint_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "initial_checkpoint_id", value) + + @_builtins.property + @pulumi.getter(name="isPrivate") + def is_private(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "is_private") + + @is_private.setter + def is_private(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_private", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @spot.setter + def spot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "spot", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _StudiosState: + def __init__(__self__, *, + active_connections: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosActiveConnectionArgs']]]] = None, + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + base_image: Optional[pulumi.Input[_builtins.str]] = None, + compute_env: Optional[pulumi.Input['StudiosComputeEnvArgs']] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + configuration: Optional[pulumi.Input['StudiosConfigurationArgs']] = None, + custom_image: Optional[pulumi.Input[_builtins.bool]] = None, + data_studio_tool_url: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + effective_lifespan_hours: Optional[pulumi.Input[_builtins.float]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosLabelArgs']]]] = None, + last_started: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + mounted_data_links: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkArgs']]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + parent_checkpoint: Optional[pulumi.Input['StudiosParentCheckpointArgs']] = None, + progresses: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosProgressArgs']]]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + status_info: Optional[pulumi.Input['StudiosStatusInfoArgs']] = None, + studio_url: Optional[pulumi.Input[_builtins.str]] = None, + template: Optional[pulumi.Input['StudiosTemplateArgs']] = None, + user: Optional[pulumi.Input['StudiosUserArgs']] = None, + wave_build_url: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Studios resources. + :param pulumi.Input[_builtins.bool] auto_start: Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input['StudiosConfigurationArgs'] configuration: Requires replacement if changed. + :param pulumi.Input[_builtins.str] data_studio_tool_url: Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.float] initial_checkpoint_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] is_private: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Unique identifier for the Studio session + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.str] studio_url: URL to access the running Studio instance + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + if active_connections is not None: + pulumi.set(__self__, "active_connections", active_connections) + if auto_start is not None: + pulumi.set(__self__, "auto_start", auto_start) + if base_image is not None: + pulumi.set(__self__, "base_image", base_image) + if compute_env is not None: + pulumi.set(__self__, "compute_env", compute_env) + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if configuration is not None: + pulumi.set(__self__, "configuration", configuration) + if custom_image is not None: + pulumi.set(__self__, "custom_image", custom_image) + if data_studio_tool_url is not None: + pulumi.set(__self__, "data_studio_tool_url", data_studio_tool_url) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if description is not None: + pulumi.set(__self__, "description", description) + if effective_lifespan_hours is not None: + pulumi.set(__self__, "effective_lifespan_hours", effective_lifespan_hours) + if initial_checkpoint_id is not None: + pulumi.set(__self__, "initial_checkpoint_id", initial_checkpoint_id) + if is_private is not None: + pulumi.set(__self__, "is_private", is_private) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if last_started is not None: + pulumi.set(__self__, "last_started", last_started) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if mounted_data_links is not None: + pulumi.set(__self__, "mounted_data_links", mounted_data_links) + if name is not None: + pulumi.set(__self__, "name", name) + if parent_checkpoint is not None: + pulumi.set(__self__, "parent_checkpoint", parent_checkpoint) + if progresses is not None: + pulumi.set(__self__, "progresses", progresses) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if spot is not None: + pulumi.set(__self__, "spot", spot) + if status_info is not None: + pulumi.set(__self__, "status_info", status_info) + if studio_url is not None: + pulumi.set(__self__, "studio_url", studio_url) + if template is not None: + pulumi.set(__self__, "template", template) + if user is not None: + pulumi.set(__self__, "user", user) + if wave_build_url is not None: + pulumi.set(__self__, "wave_build_url", wave_build_url) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="activeConnections") + def active_connections(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosActiveConnectionArgs']]]]: + return pulumi.get(self, "active_connections") + + @active_connections.setter + def active_connections(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosActiveConnectionArgs']]]]): + pulumi.set(self, "active_connections", value) + + @_builtins.property + @pulumi.getter(name="autoStart") + def auto_start(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + """ + return pulumi.get(self, "auto_start") + + @auto_start.setter + def auto_start(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "auto_start", value) + + @_builtins.property + @pulumi.getter(name="baseImage") + def base_image(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "base_image") + + @base_image.setter + def base_image(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "base_image", value) + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> Optional[pulumi.Input['StudiosComputeEnvArgs']]: + return pulumi.get(self, "compute_env") + + @compute_env.setter + def compute_env(self, value: Optional[pulumi.Input['StudiosComputeEnvArgs']]): + pulumi.set(self, "compute_env", value) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def configuration(self) -> Optional[pulumi.Input['StudiosConfigurationArgs']]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "configuration") + + @configuration.setter + def configuration(self, value: Optional[pulumi.Input['StudiosConfigurationArgs']]): + pulumi.set(self, "configuration", value) + + @_builtins.property + @pulumi.getter(name="customImage") + def custom_image(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "custom_image") + + @custom_image.setter + def custom_image(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "custom_image", value) + + @_builtins.property + @pulumi.getter(name="dataStudioToolUrl") + def data_studio_tool_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "data_studio_tool_url") + + @data_studio_tool_url.setter + def data_studio_tool_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "data_studio_tool_url", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="effectiveLifespanHours") + def effective_lifespan_hours(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "effective_lifespan_hours") + + @effective_lifespan_hours.setter + def effective_lifespan_hours(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "effective_lifespan_hours", value) + + @_builtins.property + @pulumi.getter(name="initialCheckpointId") + def initial_checkpoint_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "initial_checkpoint_id") + + @initial_checkpoint_id.setter + def initial_checkpoint_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "initial_checkpoint_id", value) + + @_builtins.property + @pulumi.getter(name="isPrivate") + def is_private(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "is_private") + + @is_private.setter + def is_private(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "is_private", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="lastStarted") + def last_started(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_started") + + @last_started.setter + def last_started(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_started", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter(name="mountedDataLinks") + def mounted_data_links(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkArgs']]]]: + return pulumi.get(self, "mounted_data_links") + + @mounted_data_links.setter + def mounted_data_links(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosMountedDataLinkArgs']]]]): + pulumi.set(self, "mounted_data_links", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="parentCheckpoint") + def parent_checkpoint(self) -> Optional[pulumi.Input['StudiosParentCheckpointArgs']]: + return pulumi.get(self, "parent_checkpoint") + + @parent_checkpoint.setter + def parent_checkpoint(self, value: Optional[pulumi.Input['StudiosParentCheckpointArgs']]): + pulumi.set(self, "parent_checkpoint", value) + + @_builtins.property + @pulumi.getter + def progresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudiosProgressArgs']]]]: + return pulumi.get(self, "progresses") + + @progresses.setter + def progresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudiosProgressArgs']]]]): + pulumi.set(self, "progresses", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Unique identifier for the Studio session + """ + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter + def spot(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @spot.setter + def spot(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "spot", value) + + @_builtins.property + @pulumi.getter(name="statusInfo") + def status_info(self) -> Optional[pulumi.Input['StudiosStatusInfoArgs']]: + return pulumi.get(self, "status_info") + + @status_info.setter + def status_info(self, value: Optional[pulumi.Input['StudiosStatusInfoArgs']]): + pulumi.set(self, "status_info", value) + + @_builtins.property + @pulumi.getter(name="studioUrl") + def studio_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + URL to access the running Studio instance + """ + return pulumi.get(self, "studio_url") + + @studio_url.setter + def studio_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "studio_url", value) + + @_builtins.property + @pulumi.getter + def template(self) -> Optional[pulumi.Input['StudiosTemplateArgs']]: + return pulumi.get(self, "template") + + @template.setter + def template(self, value: Optional[pulumi.Input['StudiosTemplateArgs']]): + pulumi.set(self, "template", value) + + @_builtins.property + @pulumi.getter + def user(self) -> Optional[pulumi.Input['StudiosUserArgs']]: + return pulumi.get(self, "user") + + @user.setter + def user(self, value: Optional[pulumi.Input['StudiosUserArgs']]): + pulumi.set(self, "user", value) + + @_builtins.property + @pulumi.getter(name="waveBuildUrl") + def wave_build_url(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "wave_build_url") + + @wave_build_url.setter + def wave_build_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "wave_build_url", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/studios:Studios") +class Studios(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + configuration: Optional[pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']]] = None, + data_studio_tool_url: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Studios resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] auto_start: Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']] configuration: Requires replacement if changed. + :param pulumi.Input[_builtins.str] data_studio_tool_url: Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.float] initial_checkpoint_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] is_private: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: StudiosArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Studios resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param StudiosArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(StudiosArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + configuration: Optional[pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']]] = None, + data_studio_tool_url: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = StudiosArgs.__new__(StudiosArgs) + + __props__.__dict__["auto_start"] = auto_start + if compute_env_id is None and not opts.urn: + raise TypeError("Missing required property 'compute_env_id'") + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["configuration"] = configuration + if data_studio_tool_url is None and not opts.urn: + raise TypeError("Missing required property 'data_studio_tool_url'") + __props__.__dict__["data_studio_tool_url"] = data_studio_tool_url + __props__.__dict__["description"] = description + __props__.__dict__["initial_checkpoint_id"] = initial_checkpoint_id + __props__.__dict__["is_private"] = is_private + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["name"] = name + __props__.__dict__["spot"] = spot + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["active_connections"] = None + __props__.__dict__["base_image"] = None + __props__.__dict__["compute_env"] = None + __props__.__dict__["custom_image"] = None + __props__.__dict__["date_created"] = None + __props__.__dict__["effective_lifespan_hours"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["last_started"] = None + __props__.__dict__["last_updated"] = None + __props__.__dict__["mounted_data_links"] = None + __props__.__dict__["parent_checkpoint"] = None + __props__.__dict__["progresses"] = None + __props__.__dict__["session_id"] = None + __props__.__dict__["status_info"] = None + __props__.__dict__["studio_url"] = None + __props__.__dict__["template"] = None + __props__.__dict__["user"] = None + __props__.__dict__["wave_build_url"] = None + super(Studios, __self__).__init__( + 'seqera:index/studios:Studios', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + active_connections: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StudiosActiveConnectionArgs', 'StudiosActiveConnectionArgsDict']]]]] = None, + auto_start: Optional[pulumi.Input[_builtins.bool]] = None, + base_image: Optional[pulumi.Input[_builtins.str]] = None, + compute_env: Optional[pulumi.Input[Union['StudiosComputeEnvArgs', 'StudiosComputeEnvArgsDict']]] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + configuration: Optional[pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']]] = None, + custom_image: Optional[pulumi.Input[_builtins.bool]] = None, + data_studio_tool_url: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + effective_lifespan_hours: Optional[pulumi.Input[_builtins.float]] = None, + initial_checkpoint_id: Optional[pulumi.Input[_builtins.float]] = None, + is_private: Optional[pulumi.Input[_builtins.bool]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StudiosLabelArgs', 'StudiosLabelArgsDict']]]]] = None, + last_started: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + mounted_data_links: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StudiosMountedDataLinkArgs', 'StudiosMountedDataLinkArgsDict']]]]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + parent_checkpoint: Optional[pulumi.Input[Union['StudiosParentCheckpointArgs', 'StudiosParentCheckpointArgsDict']]] = None, + progresses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StudiosProgressArgs', 'StudiosProgressArgsDict']]]]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + spot: Optional[pulumi.Input[_builtins.bool]] = None, + status_info: Optional[pulumi.Input[Union['StudiosStatusInfoArgs', 'StudiosStatusInfoArgsDict']]] = None, + studio_url: Optional[pulumi.Input[_builtins.str]] = None, + template: Optional[pulumi.Input[Union['StudiosTemplateArgs', 'StudiosTemplateArgsDict']]] = None, + user: Optional[pulumi.Input[Union['StudiosUserArgs', 'StudiosUserArgsDict']]] = None, + wave_build_url: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Studios': + """ + Get an existing Studios resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.bool] auto_start: Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Union['StudiosConfigurationArgs', 'StudiosConfigurationArgsDict']] configuration: Requires replacement if changed. + :param pulumi.Input[_builtins.str] data_studio_tool_url: Requires replacement if changed. + :param pulumi.Input[_builtins.str] description: Requires replacement if changed. + :param pulumi.Input[_builtins.float] initial_checkpoint_id: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] is_private: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Unique identifier for the Studio session + :param pulumi.Input[_builtins.bool] spot: Requires replacement if changed. + :param pulumi.Input[_builtins.str] studio_url: URL to access the running Studio instance + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _StudiosState.__new__(_StudiosState) + + __props__.__dict__["active_connections"] = active_connections + __props__.__dict__["auto_start"] = auto_start + __props__.__dict__["base_image"] = base_image + __props__.__dict__["compute_env"] = compute_env + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["configuration"] = configuration + __props__.__dict__["custom_image"] = custom_image + __props__.__dict__["data_studio_tool_url"] = data_studio_tool_url + __props__.__dict__["date_created"] = date_created + __props__.__dict__["description"] = description + __props__.__dict__["effective_lifespan_hours"] = effective_lifespan_hours + __props__.__dict__["initial_checkpoint_id"] = initial_checkpoint_id + __props__.__dict__["is_private"] = is_private + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["labels"] = labels + __props__.__dict__["last_started"] = last_started + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["mounted_data_links"] = mounted_data_links + __props__.__dict__["name"] = name + __props__.__dict__["parent_checkpoint"] = parent_checkpoint + __props__.__dict__["progresses"] = progresses + __props__.__dict__["session_id"] = session_id + __props__.__dict__["spot"] = spot + __props__.__dict__["status_info"] = status_info + __props__.__dict__["studio_url"] = studio_url + __props__.__dict__["template"] = template + __props__.__dict__["user"] = user + __props__.__dict__["wave_build_url"] = wave_build_url + __props__.__dict__["workspace_id"] = workspace_id + return Studios(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="activeConnections") + def active_connections(self) -> pulumi.Output[Sequence['outputs.StudiosActiveConnection']]: + return pulumi.get(self, "active_connections") + + @_builtins.property + @pulumi.getter(name="autoStart") + def auto_start(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Optionally disable the Studio's automatic launch when it is created. Requires replacement if changed. + """ + return pulumi.get(self, "auto_start") + + @_builtins.property + @pulumi.getter(name="baseImage") + def base_image(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "base_image") + + @_builtins.property + @pulumi.getter(name="computeEnv") + def compute_env(self) -> pulumi.Output['outputs.StudiosComputeEnv']: + return pulumi.get(self, "compute_env") + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter + def configuration(self) -> pulumi.Output['outputs.StudiosConfiguration']: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "configuration") + + @_builtins.property + @pulumi.getter(name="customImage") + def custom_image(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "custom_image") + + @_builtins.property + @pulumi.getter(name="dataStudioToolUrl") + def data_studio_tool_url(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "data_studio_tool_url") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="effectiveLifespanHours") + def effective_lifespan_hours(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "effective_lifespan_hours") + + @_builtins.property + @pulumi.getter(name="initialCheckpointId") + def initial_checkpoint_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "initial_checkpoint_id") + + @_builtins.property + @pulumi.getter(name="isPrivate") + def is_private(self) -> pulumi.Output[_builtins.bool]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "is_private") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.float]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.StudiosLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="lastStarted") + def last_started(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_started") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter(name="mountedDataLinks") + def mounted_data_links(self) -> pulumi.Output[Sequence['outputs.StudiosMountedDataLink']]: + return pulumi.get(self, "mounted_data_links") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="parentCheckpoint") + def parent_checkpoint(self) -> pulumi.Output['outputs.StudiosParentCheckpoint']: + return pulumi.get(self, "parent_checkpoint") + + @_builtins.property + @pulumi.getter + def progresses(self) -> pulumi.Output[Sequence['outputs.StudiosProgress']]: + return pulumi.get(self, "progresses") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> pulumi.Output[_builtins.str]: + """ + Unique identifier for the Studio session + """ + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter + def spot(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "spot") + + @_builtins.property + @pulumi.getter(name="statusInfo") + def status_info(self) -> pulumi.Output['outputs.StudiosStatusInfo']: + return pulumi.get(self, "status_info") + + @_builtins.property + @pulumi.getter(name="studioUrl") + def studio_url(self) -> pulumi.Output[_builtins.str]: + """ + URL to access the running Studio instance + """ + return pulumi.get(self, "studio_url") + + @_builtins.property + @pulumi.getter + def template(self) -> pulumi.Output['outputs.StudiosTemplate']: + return pulumi.get(self, "template") + + @_builtins.property + @pulumi.getter + def user(self) -> pulumi.Output['outputs.StudiosUser']: + return pulumi.get(self, "user") + + @_builtins.property + @pulumi.getter(name="waveBuildUrl") + def wave_build_url(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "wave_build_url") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/teams.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/teams.py new file mode 100644 index 00000000..e9d6c4bc --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/teams.py @@ -0,0 +1,337 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['TeamsArgs', 'Teams'] + +@pulumi.input_type +class TeamsArgs: + def __init__(__self__, *, + org_id: pulumi.Input[_builtins.float], + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None): + """ + The set of arguments for constructing a Teams resource. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + """ + pulumi.set(__self__, "org_id", org_id) + if avatar_id is not None: + pulumi.set(__self__, "avatar_id", avatar_id) + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Input[_builtins.float]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter(name="avatarId") + def avatar_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "avatar_id") + + @avatar_id.setter + def avatar_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar_id", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _TeamsState: + def __init__(__self__, *, + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + avatar_url: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + members_count: Optional[pulumi.Input[_builtins.float]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + team_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Teams resources. + :param pulumi.Input[_builtins.str] avatar_url: URL to the team's avatar or profile image + :param pulumi.Input[_builtins.float] members_count: Total number of members in the team + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.float] team_id: Unique numeric identifier for the team + """ + if avatar_id is not None: + pulumi.set(__self__, "avatar_id", avatar_id) + if avatar_url is not None: + pulumi.set(__self__, "avatar_url", avatar_url) + if description is not None: + pulumi.set(__self__, "description", description) + if members_count is not None: + pulumi.set(__self__, "members_count", members_count) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if team_id is not None: + pulumi.set(__self__, "team_id", team_id) + + @_builtins.property + @pulumi.getter(name="avatarId") + def avatar_id(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "avatar_id") + + @avatar_id.setter + def avatar_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar_id", value) + + @_builtins.property + @pulumi.getter(name="avatarUrl") + def avatar_url(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + URL to the team's avatar or profile image + """ + return pulumi.get(self, "avatar_url") + + @avatar_url.setter + def avatar_url(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "avatar_url", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="membersCount") + def members_count(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Total number of members in the team + """ + return pulumi.get(self, "members_count") + + @members_count.setter + def members_count(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "members_count", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the team + """ + return pulumi.get(self, "team_id") + + @team_id.setter + def team_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "team_id", value) + + +@pulumi.type_token("seqera:index/teams:Teams") +class Teams(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Teams resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: TeamsArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Teams resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param TeamsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(TeamsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = TeamsArgs.__new__(TeamsArgs) + + __props__.__dict__["avatar_id"] = avatar_id + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + if org_id is None and not opts.urn: + raise TypeError("Missing required property 'org_id'") + __props__.__dict__["org_id"] = org_id + __props__.__dict__["avatar_url"] = None + __props__.__dict__["members_count"] = None + __props__.__dict__["team_id"] = None + super(Teams, __self__).__init__( + 'seqera:index/teams:Teams', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + avatar_id: Optional[pulumi.Input[_builtins.str]] = None, + avatar_url: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + members_count: Optional[pulumi.Input[_builtins.float]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + team_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Teams': + """ + Get an existing Teams resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] avatar_url: URL to the team's avatar or profile image + :param pulumi.Input[_builtins.float] members_count: Total number of members in the team + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.float] team_id: Unique numeric identifier for the team + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TeamsState.__new__(_TeamsState) + + __props__.__dict__["avatar_id"] = avatar_id + __props__.__dict__["avatar_url"] = avatar_url + __props__.__dict__["description"] = description + __props__.__dict__["members_count"] = members_count + __props__.__dict__["name"] = name + __props__.__dict__["org_id"] = org_id + __props__.__dict__["team_id"] = team_id + return Teams(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="avatarId") + def avatar_id(self) -> pulumi.Output[Optional[_builtins.str]]: + return pulumi.get(self, "avatar_id") + + @_builtins.property + @pulumi.getter(name="avatarUrl") + def avatar_url(self) -> pulumi.Output[_builtins.str]: + """ + URL to the team's avatar or profile image + """ + return pulumi.get(self, "avatar_url") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="membersCount") + def members_count(self) -> pulumi.Output[_builtins.float]: + """ + Total number of members in the team + """ + return pulumi.get(self, "members_count") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="teamId") + def team_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the team + """ + return pulumi.get(self, "team_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/tokens.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/tokens.py new file mode 100644 index 00000000..12f517d8 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/tokens.py @@ -0,0 +1,368 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['TokensArgs', 'Tokens'] + +@pulumi.input_type +class TokensArgs: + def __init__(__self__, *, + name: Optional[pulumi.Input[_builtins.str]] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Tokens resource. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] token_id: Token numeric identifier + """ + if name is not None: + pulumi.set(__self__, "name", name) + if token_id is not None: + pulumi.set(__self__, "token_id", token_id) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="tokenId") + def token_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Token numeric identifier + """ + return pulumi.get(self, "token_id") + + @token_id.setter + def token_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "token_id", value) + + +@pulumi.input_type +class _TokensState: + def __init__(__self__, *, + access_key: Optional[pulumi.Input[_builtins.str]] = None, + basic_auth: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + token: Optional[pulumi.Input['TokensTokenArgs']] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None, + tokens_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Tokens resources. + :param pulumi.Input[_builtins.str] basic_auth: Deprecated basic authentication string + :param pulumi.Input[_builtins.str] date_created: Timestamp when the token was created + :param pulumi.Input[_builtins.str] last_used: Timestamp when the token was last used for authentication + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input['TokensTokenArgs'] token: Represents an API access token for authentication. Contains token metadata, permissions, and expiration information for + secure API access to platform resources. + :param pulumi.Input[_builtins.float] token_id: Token numeric identifier + :param pulumi.Input[_builtins.float] tokens_id: Unique numeric identifier for the access token (nullable) + """ + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if basic_auth is not None: + warnings.warn("""Deprecated""", DeprecationWarning) + pulumi.log.warn("""basic_auth is deprecated: Deprecated""") + if basic_auth is not None: + pulumi.set(__self__, "basic_auth", basic_auth) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if last_used is not None: + pulumi.set(__self__, "last_used", last_used) + if name is not None: + pulumi.set(__self__, "name", name) + if token is not None: + pulumi.set(__self__, "token", token) + if token_id is not None: + pulumi.set(__self__, "token_id", token_id) + if tokens_id is not None: + pulumi.set(__self__, "tokens_id", tokens_id) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "access_key") + + @access_key.setter + def access_key(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "access_key", value) + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Deprecated basic authentication string + """ + return pulumi.get(self, "basic_auth") + + @basic_auth.setter + def basic_auth(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "basic_auth", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the token was created + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Timestamp when the token was last used for authentication + """ + return pulumi.get(self, "last_used") + + @last_used.setter + def last_used(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_used", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter + def token(self) -> Optional[pulumi.Input['TokensTokenArgs']]: + """ + Represents an API access token for authentication. Contains token metadata, permissions, and expiration information for + secure API access to platform resources. + """ + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input['TokensTokenArgs']]): + pulumi.set(self, "token", value) + + @_builtins.property + @pulumi.getter(name="tokenId") + def token_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Token numeric identifier + """ + return pulumi.get(self, "token_id") + + @token_id.setter + def token_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "token_id", value) + + @_builtins.property + @pulumi.getter(name="tokensId") + def tokens_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Unique numeric identifier for the access token (nullable) + """ + return pulumi.get(self, "tokens_id") + + @tokens_id.setter + def tokens_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "tokens_id", value) + + +@pulumi.type_token("seqera:index/tokens:Tokens") +class Tokens(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Tokens resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[_builtins.float] token_id: Token numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[TokensArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Tokens resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param TokensArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(TokensArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = TokensArgs.__new__(TokensArgs) + + __props__.__dict__["name"] = name + __props__.__dict__["token_id"] = token_id + __props__.__dict__["access_key"] = None + __props__.__dict__["basic_auth"] = None + __props__.__dict__["date_created"] = None + __props__.__dict__["last_used"] = None + __props__.__dict__["token"] = None + __props__.__dict__["tokens_id"] = None + super(Tokens, __self__).__init__( + 'seqera:index/tokens:Tokens', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + access_key: Optional[pulumi.Input[_builtins.str]] = None, + basic_auth: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + last_used: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + token: Optional[pulumi.Input[Union['TokensTokenArgs', 'TokensTokenArgsDict']]] = None, + token_id: Optional[pulumi.Input[_builtins.float]] = None, + tokens_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Tokens': + """ + Get an existing Tokens resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] basic_auth: Deprecated basic authentication string + :param pulumi.Input[_builtins.str] date_created: Timestamp when the token was created + :param pulumi.Input[_builtins.str] last_used: Timestamp when the token was last used for authentication + :param pulumi.Input[_builtins.str] name: Requires replacement if changed. + :param pulumi.Input[Union['TokensTokenArgs', 'TokensTokenArgsDict']] token: Represents an API access token for authentication. Contains token metadata, permissions, and expiration information for + secure API access to platform resources. + :param pulumi.Input[_builtins.float] token_id: Token numeric identifier + :param pulumi.Input[_builtins.float] tokens_id: Unique numeric identifier for the access token (nullable) + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TokensState.__new__(_TokensState) + + __props__.__dict__["access_key"] = access_key + __props__.__dict__["basic_auth"] = basic_auth + __props__.__dict__["date_created"] = date_created + __props__.__dict__["last_used"] = last_used + __props__.__dict__["name"] = name + __props__.__dict__["token"] = token + __props__.__dict__["token_id"] = token_id + __props__.__dict__["tokens_id"] = tokens_id + return Tokens(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="accessKey") + def access_key(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "access_key") + + @_builtins.property + @pulumi.getter(name="basicAuth") + @_utilities.deprecated("""Deprecated""") + def basic_auth(self) -> pulumi.Output[_builtins.str]: + """ + Deprecated basic authentication string + """ + return pulumi.get(self, "basic_auth") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + """ + Timestamp when the token was created + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="lastUsed") + def last_used(self) -> pulumi.Output[_builtins.str]: + """ + Timestamp when the token was last used for authentication + """ + return pulumi.get(self, "last_used") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter + def token(self) -> pulumi.Output['outputs.TokensToken']: + """ + Represents an API access token for authentication. Contains token metadata, permissions, and expiration information for + secure API access to platform resources. + """ + return pulumi.get(self, "token") + + @_builtins.property + @pulumi.getter(name="tokenId") + def token_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Token numeric identifier + """ + return pulumi.get(self, "token_id") + + @_builtins.property + @pulumi.getter(name="tokensId") + def tokens_id(self) -> pulumi.Output[_builtins.float]: + """ + Unique numeric identifier for the access token (nullable) + """ + return pulumi.get(self, "tokens_id") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/workflows.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/workflows.py new file mode 100644 index 00000000..9c7c52f1 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/workflows.py @@ -0,0 +1,1775 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['WorkflowsArgs', 'Workflows'] + +@pulumi.input_type +class WorkflowsArgs: + def __init__(__self__, *, + compute_env_id: pulumi.Input[_builtins.str], + pipeline: pulumi.Input[_builtins.str], + work_dir: pulumi.Input[_builtins.str], + workspace_id: pulumi.Input[_builtins.float], + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + The set of arguments for constructing a Workflows resource. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] force: Force the deletion even if the workflow is active + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.float] source_workspace_id: Source Optional workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + pulumi.set(__self__, "compute_env_id", compute_env_id) + pulumi.set(__self__, "pipeline", pipeline) + pulumi.set(__self__, "work_dir", work_dir) + pulumi.set(__self__, "workspace_id", workspace_id) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if force is not None: + pulumi.set(__self__, "force", force) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if source_workspace_id is not None: + pulumi.set(__self__, "source_workspace_id", source_workspace_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter + def pipeline(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @pipeline.setter + def pipeline(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "pipeline", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> pulumi.Input[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Input[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @config_profiles.setter + def config_profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_profiles", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @entry_name.setter + def entry_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "entry_name", value) + + @_builtins.property + @pulumi.getter + def force(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Force the deletion even if the workflow is active + """ + return pulumi.get(self, "force") + + @force.setter + def force(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "force", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @launch_container.setter + def launch_container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_container", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @params_text.setter + def params_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "params_text", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @pull_latest.setter + def pull_latest(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "pull_latest", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @schema_name.setter + def schema_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "schema_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="sourceWorkspaceId") + def source_workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Source Optional workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "source_workspace_id") + + @source_workspace_id.setter + def source_workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "source_workspace_id", value) + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @stub_run.setter + def stub_run(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "stub_run", value) + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @tower_config.setter + def tower_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tower_config", value) + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @user_secrets.setter + def user_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "user_secrets", value) + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + + @workspace_secrets.setter + def workspace_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "workspace_secrets", value) + + +@pulumi.input_type +class _WorkflowsState: + def __init__(__self__, *, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + job_info: Optional[pulumi.Input['WorkflowsJobInfoArgs']] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsLabelArgs']]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + messages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + optimized: Optional[pulumi.Input[_builtins.bool]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + org_name: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + pipeline: Optional[pulumi.Input[_builtins.str]] = None, + platform: Optional[pulumi.Input['WorkflowsPlatformArgs']] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + progress: Optional[pulumi.Input['WorkflowsProgressArgs']] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + workflow: Optional[pulumi.Input['WorkflowsWorkflowArgs']] = None, + workflow_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None): + """ + Input properties used for looking up and filtering Workflows resources. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] force: Force the deletion even if the workflow is active + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.float] source_workspace_id: Source Optional workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.str] workflow_id: Workflow string identifier + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + if compute_env_id is not None: + pulumi.set(__self__, "compute_env_id", compute_env_id) + if config_profiles is not None: + pulumi.set(__self__, "config_profiles", config_profiles) + if config_text is not None: + pulumi.set(__self__, "config_text", config_text) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if entry_name is not None: + pulumi.set(__self__, "entry_name", entry_name) + if force is not None: + pulumi.set(__self__, "force", force) + if head_job_cpus is not None: + pulumi.set(__self__, "head_job_cpus", head_job_cpus) + if head_job_memory_mb is not None: + pulumi.set(__self__, "head_job_memory_mb", head_job_memory_mb) + if job_info is not None: + pulumi.set(__self__, "job_info", job_info) + if label_ids is not None: + pulumi.set(__self__, "label_ids", label_ids) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if launch_container is not None: + pulumi.set(__self__, "launch_container", launch_container) + if main_script is not None: + pulumi.set(__self__, "main_script", main_script) + if messages is not None: + pulumi.set(__self__, "messages", messages) + if optimization_id is not None: + pulumi.set(__self__, "optimization_id", optimization_id) + if optimization_targets is not None: + pulumi.set(__self__, "optimization_targets", optimization_targets) + if optimized is not None: + pulumi.set(__self__, "optimized", optimized) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if org_name is not None: + pulumi.set(__self__, "org_name", org_name) + if params_text is not None: + pulumi.set(__self__, "params_text", params_text) + if pipeline is not None: + pulumi.set(__self__, "pipeline", pipeline) + if platform is not None: + pulumi.set(__self__, "platform", platform) + if post_run_script is not None: + pulumi.set(__self__, "post_run_script", post_run_script) + if pre_run_script is not None: + pulumi.set(__self__, "pre_run_script", pre_run_script) + if progress is not None: + pulumi.set(__self__, "progress", progress) + if pull_latest is not None: + pulumi.set(__self__, "pull_latest", pull_latest) + if resume is not None: + pulumi.set(__self__, "resume", resume) + if revision is not None: + pulumi.set(__self__, "revision", revision) + if run_name is not None: + pulumi.set(__self__, "run_name", run_name) + if schema_name is not None: + pulumi.set(__self__, "schema_name", schema_name) + if session_id is not None: + pulumi.set(__self__, "session_id", session_id) + if source_workspace_id is not None: + pulumi.set(__self__, "source_workspace_id", source_workspace_id) + if stub_run is not None: + pulumi.set(__self__, "stub_run", stub_run) + if tower_config is not None: + pulumi.set(__self__, "tower_config", tower_config) + if user_secrets is not None: + pulumi.set(__self__, "user_secrets", user_secrets) + if work_dir is not None: + pulumi.set(__self__, "work_dir", work_dir) + if workflow is not None: + pulumi.set(__self__, "workflow", workflow) + if workflow_id is not None: + pulumi.set(__self__, "workflow_id", workflow_id) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + if workspace_name is not None: + pulumi.set(__self__, "workspace_name", workspace_name) + if workspace_secrets is not None: + pulumi.set(__self__, "workspace_secrets", workspace_secrets) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @compute_env_id.setter + def compute_env_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "compute_env_id", value) + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @config_profiles.setter + def config_profiles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "config_profiles", value) + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @config_text.setter + def config_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "config_text", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @entry_name.setter + def entry_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "entry_name", value) + + @_builtins.property + @pulumi.getter + def force(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Force the deletion even if the workflow is active + """ + return pulumi.get(self, "force") + + @force.setter + def force(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "force", value) + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @head_job_cpus.setter + def head_job_cpus(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_cpus", value) + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @head_job_memory_mb.setter + def head_job_memory_mb(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "head_job_memory_mb", value) + + @_builtins.property + @pulumi.getter(name="jobInfo") + def job_info(self) -> Optional[pulumi.Input['WorkflowsJobInfoArgs']]: + return pulumi.get(self, "job_info") + + @job_info.setter + def job_info(self, value: Optional[pulumi.Input['WorkflowsJobInfoArgs']]): + pulumi.set(self, "job_info", value) + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @label_ids.setter + def label_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]]): + pulumi.set(self, "label_ids", value) + + @_builtins.property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsLabelArgs']]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowsLabelArgs']]]]): + pulumi.set(self, "labels", value) + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @launch_container.setter + def launch_container(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "launch_container", value) + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @main_script.setter + def main_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "main_script", value) + + @_builtins.property + @pulumi.getter + def messages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + return pulumi.get(self, "messages") + + @messages.setter + def messages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "messages", value) + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @optimization_id.setter + def optimization_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_id", value) + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @optimization_targets.setter + def optimization_targets(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "optimization_targets", value) + + @_builtins.property + @pulumi.getter + def optimized(self) -> Optional[pulumi.Input[_builtins.bool]]: + return pulumi.get(self, "optimized") + + @optimized.setter + def optimized(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "optimized", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "org_name") + + @org_name.setter + def org_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "org_name", value) + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @params_text.setter + def params_text(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "params_text", value) + + @_builtins.property + @pulumi.getter + def pipeline(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @pipeline.setter + def pipeline(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pipeline", value) + + @_builtins.property + @pulumi.getter + def platform(self) -> Optional[pulumi.Input['WorkflowsPlatformArgs']]: + return pulumi.get(self, "platform") + + @platform.setter + def platform(self, value: Optional[pulumi.Input['WorkflowsPlatformArgs']]): + pulumi.set(self, "platform", value) + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "post_run_script") + + @post_run_script.setter + def post_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "post_run_script", value) + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "pre_run_script") + + @pre_run_script.setter + def pre_run_script(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "pre_run_script", value) + + @_builtins.property + @pulumi.getter + def progress(self) -> Optional[pulumi.Input['WorkflowsProgressArgs']]: + return pulumi.get(self, "progress") + + @progress.setter + def progress(self, value: Optional[pulumi.Input['WorkflowsProgressArgs']]): + pulumi.set(self, "progress", value) + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @pull_latest.setter + def pull_latest(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "pull_latest", value) + + @_builtins.property + @pulumi.getter + def resume(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @resume.setter + def resume(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "resume", value) + + @_builtins.property + @pulumi.getter + def revision(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @revision.setter + def revision(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "revision", value) + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @run_name.setter + def run_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "run_name", value) + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @schema_name.setter + def schema_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "schema_name", value) + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @session_id.setter + def session_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "session_id", value) + + @_builtins.property + @pulumi.getter(name="sourceWorkspaceId") + def source_workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Source Optional workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "source_workspace_id") + + @source_workspace_id.setter + def source_workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "source_workspace_id", value) + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> Optional[pulumi.Input[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @stub_run.setter + def stub_run(self, value: Optional[pulumi.Input[_builtins.bool]]): + pulumi.set(self, "stub_run", value) + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @tower_config.setter + def tower_config(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "tower_config", value) + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @user_secrets.setter + def user_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "user_secrets", value) + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @work_dir.setter + def work_dir(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "work_dir", value) + + @_builtins.property + @pulumi.getter + def workflow(self) -> Optional[pulumi.Input['WorkflowsWorkflowArgs']]: + return pulumi.get(self, "workflow") + + @workflow.setter + def workflow(self, value: Optional[pulumi.Input['WorkflowsWorkflowArgs']]): + pulumi.set(self, "workflow", value) + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Workflow string identifier + """ + return pulumi.get(self, "workflow_id") + + @workflow_id.setter + def workflow_id(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "workflow_id", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "workspace_name") + + @workspace_name.setter + def workspace_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "workspace_name", value) + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + + @workspace_secrets.setter + def workspace_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]): + pulumi.set(self, "workspace_secrets", value) + + +@pulumi.type_token("seqera:index/workflows:Workflows") +class Workflows(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + pipeline: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + __props__=None): + """ + Create a Workflows resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] force: Force the deletion even if the workflow is active + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.float] source_workspace_id: Source Optional workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: WorkflowsArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Workflows resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param WorkflowsArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(WorkflowsArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + pipeline: Optional[pulumi.Input[_builtins.str]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = WorkflowsArgs.__new__(WorkflowsArgs) + + if compute_env_id is None and not opts.urn: + raise TypeError("Missing required property 'compute_env_id'") + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["config_profiles"] = config_profiles + __props__.__dict__["config_text"] = config_text + __props__.__dict__["date_created"] = date_created + __props__.__dict__["entry_name"] = entry_name + __props__.__dict__["force"] = force + __props__.__dict__["head_job_cpus"] = head_job_cpus + __props__.__dict__["head_job_memory_mb"] = head_job_memory_mb + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["launch_container"] = launch_container + __props__.__dict__["main_script"] = main_script + __props__.__dict__["optimization_id"] = optimization_id + __props__.__dict__["optimization_targets"] = optimization_targets + __props__.__dict__["params_text"] = params_text + if pipeline is None and not opts.urn: + raise TypeError("Missing required property 'pipeline'") + __props__.__dict__["pipeline"] = pipeline + __props__.__dict__["post_run_script"] = post_run_script + __props__.__dict__["pre_run_script"] = pre_run_script + __props__.__dict__["pull_latest"] = pull_latest + __props__.__dict__["resume"] = resume + __props__.__dict__["revision"] = revision + __props__.__dict__["run_name"] = run_name + __props__.__dict__["schema_name"] = schema_name + __props__.__dict__["session_id"] = session_id + __props__.__dict__["source_workspace_id"] = source_workspace_id + __props__.__dict__["stub_run"] = stub_run + __props__.__dict__["tower_config"] = tower_config + __props__.__dict__["user_secrets"] = user_secrets + if work_dir is None and not opts.urn: + raise TypeError("Missing required property 'work_dir'") + __props__.__dict__["work_dir"] = work_dir + if workspace_id is None and not opts.urn: + raise TypeError("Missing required property 'workspace_id'") + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["workspace_secrets"] = workspace_secrets + __props__.__dict__["job_info"] = None + __props__.__dict__["labels"] = None + __props__.__dict__["messages"] = None + __props__.__dict__["optimized"] = None + __props__.__dict__["org_id"] = None + __props__.__dict__["org_name"] = None + __props__.__dict__["platform"] = None + __props__.__dict__["progress"] = None + __props__.__dict__["workflow"] = None + __props__.__dict__["workflow_id"] = None + __props__.__dict__["workspace_name"] = None + super(Workflows, __self__).__init__( + 'seqera:index/workflows:Workflows', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + compute_env_id: Optional[pulumi.Input[_builtins.str]] = None, + config_profiles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + config_text: Optional[pulumi.Input[_builtins.str]] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + entry_name: Optional[pulumi.Input[_builtins.str]] = None, + force: Optional[pulumi.Input[_builtins.bool]] = None, + head_job_cpus: Optional[pulumi.Input[_builtins.float]] = None, + head_job_memory_mb: Optional[pulumi.Input[_builtins.float]] = None, + job_info: Optional[pulumi.Input[Union['WorkflowsJobInfoArgs', 'WorkflowsJobInfoArgsDict']]] = None, + label_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.float]]]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['WorkflowsLabelArgs', 'WorkflowsLabelArgsDict']]]]] = None, + launch_container: Optional[pulumi.Input[_builtins.str]] = None, + main_script: Optional[pulumi.Input[_builtins.str]] = None, + messages: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + optimization_id: Optional[pulumi.Input[_builtins.str]] = None, + optimization_targets: Optional[pulumi.Input[_builtins.str]] = None, + optimized: Optional[pulumi.Input[_builtins.bool]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + org_name: Optional[pulumi.Input[_builtins.str]] = None, + params_text: Optional[pulumi.Input[_builtins.str]] = None, + pipeline: Optional[pulumi.Input[_builtins.str]] = None, + platform: Optional[pulumi.Input[Union['WorkflowsPlatformArgs', 'WorkflowsPlatformArgsDict']]] = None, + post_run_script: Optional[pulumi.Input[_builtins.str]] = None, + pre_run_script: Optional[pulumi.Input[_builtins.str]] = None, + progress: Optional[pulumi.Input[Union['WorkflowsProgressArgs', 'WorkflowsProgressArgsDict']]] = None, + pull_latest: Optional[pulumi.Input[_builtins.bool]] = None, + resume: Optional[pulumi.Input[_builtins.bool]] = None, + revision: Optional[pulumi.Input[_builtins.str]] = None, + run_name: Optional[pulumi.Input[_builtins.str]] = None, + schema_name: Optional[pulumi.Input[_builtins.str]] = None, + session_id: Optional[pulumi.Input[_builtins.str]] = None, + source_workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + stub_run: Optional[pulumi.Input[_builtins.bool]] = None, + tower_config: Optional[pulumi.Input[_builtins.str]] = None, + user_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None, + work_dir: Optional[pulumi.Input[_builtins.str]] = None, + workflow: Optional[pulumi.Input[Union['WorkflowsWorkflowArgs', 'WorkflowsWorkflowArgsDict']]] = None, + workflow_id: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + workspace_name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'Workflows': + """ + Get an existing Workflows resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] compute_env_id: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] config_profiles: Requires replacement if changed. + :param pulumi.Input[_builtins.str] config_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] entry_name: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] force: Force the deletion even if the workflow is active + :param pulumi.Input[_builtins.float] head_job_cpus: Requires replacement if changed. + :param pulumi.Input[_builtins.float] head_job_memory_mb: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.float]]] label_ids: Requires replacement if changed. + :param pulumi.Input[_builtins.str] launch_container: Requires replacement if changed. + :param pulumi.Input[_builtins.str] main_script: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_id: Requires replacement if changed. + :param pulumi.Input[_builtins.str] optimization_targets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] params_text: Requires replacement if changed. + :param pulumi.Input[_builtins.str] pipeline: Requires replacement if changed. + :param pulumi.Input[_builtins.str] post_run_script: Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.str] pre_run_script: Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + :param pulumi.Input[_builtins.bool] pull_latest: Requires replacement if changed. + :param pulumi.Input[_builtins.bool] resume: Requires replacement if changed. + :param pulumi.Input[_builtins.str] revision: Requires replacement if changed. + :param pulumi.Input[_builtins.str] run_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] schema_name: Requires replacement if changed. + :param pulumi.Input[_builtins.str] session_id: Requires replacement if changed. + :param pulumi.Input[_builtins.float] source_workspace_id: Source Optional workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[_builtins.bool] stub_run: Requires replacement if changed. + :param pulumi.Input[_builtins.str] tower_config: Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_secrets: Requires replacement if changed. + :param pulumi.Input[_builtins.str] work_dir: Requires replacement if changed. + :param pulumi.Input[_builtins.str] workflow_id: Workflow string identifier + :param pulumi.Input[_builtins.float] workspace_id: Workspace numeric identifier. Requires replacement if changed. + :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] workspace_secrets: Requires replacement if changed. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _WorkflowsState.__new__(_WorkflowsState) + + __props__.__dict__["compute_env_id"] = compute_env_id + __props__.__dict__["config_profiles"] = config_profiles + __props__.__dict__["config_text"] = config_text + __props__.__dict__["date_created"] = date_created + __props__.__dict__["entry_name"] = entry_name + __props__.__dict__["force"] = force + __props__.__dict__["head_job_cpus"] = head_job_cpus + __props__.__dict__["head_job_memory_mb"] = head_job_memory_mb + __props__.__dict__["job_info"] = job_info + __props__.__dict__["label_ids"] = label_ids + __props__.__dict__["labels"] = labels + __props__.__dict__["launch_container"] = launch_container + __props__.__dict__["main_script"] = main_script + __props__.__dict__["messages"] = messages + __props__.__dict__["optimization_id"] = optimization_id + __props__.__dict__["optimization_targets"] = optimization_targets + __props__.__dict__["optimized"] = optimized + __props__.__dict__["org_id"] = org_id + __props__.__dict__["org_name"] = org_name + __props__.__dict__["params_text"] = params_text + __props__.__dict__["pipeline"] = pipeline + __props__.__dict__["platform"] = platform + __props__.__dict__["post_run_script"] = post_run_script + __props__.__dict__["pre_run_script"] = pre_run_script + __props__.__dict__["progress"] = progress + __props__.__dict__["pull_latest"] = pull_latest + __props__.__dict__["resume"] = resume + __props__.__dict__["revision"] = revision + __props__.__dict__["run_name"] = run_name + __props__.__dict__["schema_name"] = schema_name + __props__.__dict__["session_id"] = session_id + __props__.__dict__["source_workspace_id"] = source_workspace_id + __props__.__dict__["stub_run"] = stub_run + __props__.__dict__["tower_config"] = tower_config + __props__.__dict__["user_secrets"] = user_secrets + __props__.__dict__["work_dir"] = work_dir + __props__.__dict__["workflow"] = workflow + __props__.__dict__["workflow_id"] = workflow_id + __props__.__dict__["workspace_id"] = workspace_id + __props__.__dict__["workspace_name"] = workspace_name + __props__.__dict__["workspace_secrets"] = workspace_secrets + return Workflows(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="computeEnvId") + def compute_env_id(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "compute_env_id") + + @_builtins.property + @pulumi.getter(name="configProfiles") + def config_profiles(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_profiles") + + @_builtins.property + @pulumi.getter(name="configText") + def config_text(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "config_text") + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter(name="entryName") + def entry_name(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "entry_name") + + @_builtins.property + @pulumi.getter + def force(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Force the deletion even if the workflow is active + """ + return pulumi.get(self, "force") + + @_builtins.property + @pulumi.getter(name="headJobCpus") + def head_job_cpus(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_cpus") + + @_builtins.property + @pulumi.getter(name="headJobMemoryMb") + def head_job_memory_mb(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "head_job_memory_mb") + + @_builtins.property + @pulumi.getter(name="jobInfo") + def job_info(self) -> pulumi.Output['outputs.WorkflowsJobInfo']: + return pulumi.get(self, "job_info") + + @_builtins.property + @pulumi.getter(name="labelIds") + def label_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.float]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "label_ids") + + @_builtins.property + @pulumi.getter + def labels(self) -> pulumi.Output[Sequence['outputs.WorkflowsLabel']]: + return pulumi.get(self, "labels") + + @_builtins.property + @pulumi.getter(name="launchContainer") + def launch_container(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "launch_container") + + @_builtins.property + @pulumi.getter(name="mainScript") + def main_script(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "main_script") + + @_builtins.property + @pulumi.getter + def messages(self) -> pulumi.Output[Sequence[_builtins.str]]: + return pulumi.get(self, "messages") + + @_builtins.property + @pulumi.getter(name="optimizationId") + def optimization_id(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_id") + + @_builtins.property + @pulumi.getter(name="optimizationTargets") + def optimization_targets(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "optimization_targets") + + @_builtins.property + @pulumi.getter + def optimized(self) -> pulumi.Output[_builtins.bool]: + return pulumi.get(self, "optimized") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter(name="orgName") + def org_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "org_name") + + @_builtins.property + @pulumi.getter(name="paramsText") + def params_text(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "params_text") + + @_builtins.property + @pulumi.getter + def pipeline(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pipeline") + + @_builtins.property + @pulumi.getter + def platform(self) -> pulumi.Output['outputs.WorkflowsPlatform']: + return pulumi.get(self, "platform") + + @_builtins.property + @pulumi.getter(name="postRunScript") + def post_run_script(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Add a script that executes after all Nextflow processes have completed. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "post_run_script") + + @_builtins.property + @pulumi.getter(name="preRunScript") + def pre_run_script(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Add a script that executes in the nf-launch script prior to invoking Nextflow processes. See [Pre and post-run + scripts](https://docs.seqera.io/platform-cloud/launch/advanced#pre-and-post-run-scripts). Requires replacement if + changed. + """ + return pulumi.get(self, "pre_run_script") + + @_builtins.property + @pulumi.getter + def progress(self) -> pulumi.Output['outputs.WorkflowsProgress']: + return pulumi.get(self, "progress") + + @_builtins.property + @pulumi.getter(name="pullLatest") + def pull_latest(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "pull_latest") + + @_builtins.property + @pulumi.getter + def resume(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "resume") + + @_builtins.property + @pulumi.getter + def revision(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "revision") + + @_builtins.property + @pulumi.getter(name="runName") + def run_name(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "run_name") + + @_builtins.property + @pulumi.getter(name="schemaName") + def schema_name(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "schema_name") + + @_builtins.property + @pulumi.getter(name="sessionId") + def session_id(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "session_id") + + @_builtins.property + @pulumi.getter(name="sourceWorkspaceId") + def source_workspace_id(self) -> pulumi.Output[Optional[_builtins.float]]: + """ + Source Optional workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "source_workspace_id") + + @_builtins.property + @pulumi.getter(name="stubRun") + def stub_run(self) -> pulumi.Output[Optional[_builtins.bool]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "stub_run") + + @_builtins.property + @pulumi.getter(name="towerConfig") + def tower_config(self) -> pulumi.Output[Optional[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "tower_config") + + @_builtins.property + @pulumi.getter(name="userSecrets") + def user_secrets(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "user_secrets") + + @_builtins.property + @pulumi.getter(name="workDir") + def work_dir(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "work_dir") + + @_builtins.property + @pulumi.getter + def workflow(self) -> pulumi.Output['outputs.WorkflowsWorkflow']: + return pulumi.get(self, "workflow") + + @_builtins.property + @pulumi.getter(name="workflowId") + def workflow_id(self) -> pulumi.Output[_builtins.str]: + """ + Workflow string identifier + """ + return pulumi.get(self, "workflow_id") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Workspace numeric identifier. Requires replacement if changed. + """ + return pulumi.get(self, "workspace_id") + + @_builtins.property + @pulumi.getter(name="workspaceName") + def workspace_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "workspace_name") + + @_builtins.property + @pulumi.getter(name="workspaceSecrets") + def workspace_secrets(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "workspace_secrets") + diff --git a/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/workspace.py b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/workspace.py new file mode 100644 index 00000000..698783d1 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/sdks/seqera/pulumi_seqera/workspace.py @@ -0,0 +1,443 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins as _builtins +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['WorkspaceArgs', 'Workspace'] + +@pulumi.input_type +class WorkspaceArgs: + def __init__(__self__, *, + full_name: pulumi.Input[_builtins.str], + org_id: pulumi.Input[_builtins.float], + visibility: pulumi.Input[_builtins.str], + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + The set of arguments for constructing a Workspace resource. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.str] visibility: must be one of ["PRIVATE", "SHARED"] + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] last_updated: Requires replacement if changed. + :param pulumi.Input[_builtins.float] workspace_id: Optional workspace numeric identifier + """ + pulumi.set(__self__, "full_name", full_name) + pulumi.set(__self__, "org_id", org_id) + pulumi.set(__self__, "visibility", visibility) + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if description is not None: + pulumi.set(__self__, "description", description) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if name is not None: + pulumi.set(__self__, "name", name) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> pulumi.Input[_builtins.str]: + return pulumi.get(self, "full_name") + + @full_name.setter + def full_name(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "full_name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Input[_builtins.float]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: pulumi.Input[_builtins.float]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + def visibility(self) -> pulumi.Input[_builtins.str]: + """ + must be one of ["PRIVATE", "SHARED"] + """ + return pulumi.get(self, "visibility") + + @visibility.setter + def visibility(self, value: pulumi.Input[_builtins.str]): + pulumi.set(self, "visibility", value) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Optional workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.input_type +class _WorkspaceState: + def __init__(__self__, *, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None): + """ + Input properties used for looking up and filtering Workspace resources. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] last_updated: Requires replacement if changed. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.str] visibility: must be one of ["PRIVATE", "SHARED"] + :param pulumi.Input[_builtins.float] workspace_id: Optional workspace numeric identifier + """ + if date_created is not None: + pulumi.set(__self__, "date_created", date_created) + if description is not None: + pulumi.set(__self__, "description", description) + if full_name is not None: + pulumi.set(__self__, "full_name", full_name) + if last_updated is not None: + pulumi.set(__self__, "last_updated", last_updated) + if name is not None: + pulumi.set(__self__, "name", name) + if org_id is not None: + pulumi.set(__self__, "org_id", org_id) + if visibility is not None: + pulumi.set(__self__, "visibility", visibility) + if workspace_id is not None: + pulumi.set(__self__, "workspace_id", workspace_id) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @date_created.setter + def date_created(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "date_created", value) + + @_builtins.property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "description", value) + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "full_name") + + @full_name.setter + def full_name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "full_name", value) + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "last_updated") + + @last_updated.setter + def last_updated(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "last_updated", value) + + @_builtins.property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[_builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "name", value) + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @org_id.setter + def org_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "org_id", value) + + @_builtins.property + @pulumi.getter + def visibility(self) -> Optional[pulumi.Input[_builtins.str]]: + """ + must be one of ["PRIVATE", "SHARED"] + """ + return pulumi.get(self, "visibility") + + @visibility.setter + def visibility(self, value: Optional[pulumi.Input[_builtins.str]]): + pulumi.set(self, "visibility", value) + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> Optional[pulumi.Input[_builtins.float]]: + """ + Optional workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + + @workspace_id.setter + def workspace_id(self, value: Optional[pulumi.Input[_builtins.float]]): + pulumi.set(self, "workspace_id", value) + + +@pulumi.type_token("seqera:index/workspace:Workspace") +class Workspace(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + """ + Create a Workspace resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] last_updated: Requires replacement if changed. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.str] visibility: must be one of ["PRIVATE", "SHARED"] + :param pulumi.Input[_builtins.float] workspace_id: Optional workspace numeric identifier + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: WorkspaceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Workspace resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param WorkspaceArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(WorkspaceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = WorkspaceArgs.__new__(WorkspaceArgs) + + __props__.__dict__["date_created"] = date_created + __props__.__dict__["description"] = description + if full_name is None and not opts.urn: + raise TypeError("Missing required property 'full_name'") + __props__.__dict__["full_name"] = full_name + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["name"] = name + if org_id is None and not opts.urn: + raise TypeError("Missing required property 'org_id'") + __props__.__dict__["org_id"] = org_id + if visibility is None and not opts.urn: + raise TypeError("Missing required property 'visibility'") + __props__.__dict__["visibility"] = visibility + __props__.__dict__["workspace_id"] = workspace_id + super(Workspace, __self__).__init__( + 'seqera:index/workspace:Workspace', + resource_name, + __props__, + opts, + package_ref=_utilities.get_package()) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + date_created: Optional[pulumi.Input[_builtins.str]] = None, + description: Optional[pulumi.Input[_builtins.str]] = None, + full_name: Optional[pulumi.Input[_builtins.str]] = None, + last_updated: Optional[pulumi.Input[_builtins.str]] = None, + name: Optional[pulumi.Input[_builtins.str]] = None, + org_id: Optional[pulumi.Input[_builtins.float]] = None, + visibility: Optional[pulumi.Input[_builtins.str]] = None, + workspace_id: Optional[pulumi.Input[_builtins.float]] = None) -> 'Workspace': + """ + Get an existing Workspace resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[_builtins.str] date_created: Requires replacement if changed. + :param pulumi.Input[_builtins.str] last_updated: Requires replacement if changed. + :param pulumi.Input[_builtins.float] org_id: Organization numeric identifier + :param pulumi.Input[_builtins.str] visibility: must be one of ["PRIVATE", "SHARED"] + :param pulumi.Input[_builtins.float] workspace_id: Optional workspace numeric identifier + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _WorkspaceState.__new__(_WorkspaceState) + + __props__.__dict__["date_created"] = date_created + __props__.__dict__["description"] = description + __props__.__dict__["full_name"] = full_name + __props__.__dict__["last_updated"] = last_updated + __props__.__dict__["name"] = name + __props__.__dict__["org_id"] = org_id + __props__.__dict__["visibility"] = visibility + __props__.__dict__["workspace_id"] = workspace_id + return Workspace(resource_name, opts=opts, __props__=__props__) + + @_builtins.property + @pulumi.getter(name="dateCreated") + def date_created(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "date_created") + + @_builtins.property + @pulumi.getter + def description(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "description") + + @_builtins.property + @pulumi.getter(name="fullName") + def full_name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "full_name") + + @_builtins.property + @pulumi.getter(name="lastUpdated") + def last_updated(self) -> pulumi.Output[_builtins.str]: + """ + Requires replacement if changed. + """ + return pulumi.get(self, "last_updated") + + @_builtins.property + @pulumi.getter + def name(self) -> pulumi.Output[_builtins.str]: + return pulumi.get(self, "name") + + @_builtins.property + @pulumi.getter(name="orgId") + def org_id(self) -> pulumi.Output[_builtins.float]: + """ + Organization numeric identifier + """ + return pulumi.get(self, "org_id") + + @_builtins.property + @pulumi.getter + def visibility(self) -> pulumi.Output[_builtins.str]: + """ + must be one of ["PRIVATE", "SHARED"] + """ + return pulumi.get(self, "visibility") + + @_builtins.property + @pulumi.getter(name="workspaceId") + def workspace_id(self) -> pulumi.Output[_builtins.float]: + """ + Optional workspace numeric identifier + """ + return pulumi.get(self, "workspace_id") + diff --git a/pulumi/seqera_platform/resource_optimization/workspace_config.py b/pulumi/seqera_platform/resource_optimization/workspace_config.py new file mode 100644 index 00000000..43c207a7 --- /dev/null +++ b/pulumi/seqera_platform/resource_optimization/workspace_config.py @@ -0,0 +1,51 @@ +"""Configuration specific to the Resource Optimization workspace""" + +from typing import Dict, Any + + +def get_workspace_config() -> Dict[str, Any]: + """ + Get workspace-specific configuration for Resource Optimization testing. + + This workspace only includes CPU compute environments (no ARM or GPU) + for Florian's resource optimization work. + + Returns: + Dict containing workspace settings including compute environment configuration + """ + return { + "workspace_name": "ResourceOptimization", + "organization_name": "nf-core", + "description": "Workspace for resource optimization testing and analysis", + + # Compute environment configuration - CPU only + "compute_environments": { + "cpu": { + "enabled": True, + "name": "aws_ireland_fusionv2_nvme_cpu", + "instance_types": ["c6id", "m6id", "r6id"], + "max_cpus": 500, + }, + "gpu": { + "enabled": False, # Not needed for resource optimization + }, + "arm": { + "enabled": False, # Not needed for resource optimization + }, + }, + + # AWS configuration + "aws_region": "eu-west-1", + "s3_bucket_name": "nf-core-resource-optimization", + + # GitHub integration - may not be needed for this workspace + "github_integration": { + "enabled": False, # Can enable later if needed + }, + + # Workspace participants - configure based on team needs + "workspace_participants": { + "enabled": True, + "teams": [], # Configure team access as needed + }, + } diff --git a/pulumi/seqera_platform/shared/__init__.py b/pulumi/seqera_platform/shared/__init__.py new file mode 100644 index 00000000..b5e4da14 --- /dev/null +++ b/pulumi/seqera_platform/shared/__init__.py @@ -0,0 +1,8 @@ +"""AWS Megatests Infrastructure Package + +This package provides modular infrastructure components for the nf-core AWS Megatests +Pulumi project, including provider configurations, infrastructure resources, +and third-party integrations. +""" + +__version__ = "1.0.0" diff --git a/pulumi/seqera_platform/shared/config/__init__.py b/pulumi/seqera_platform/shared/config/__init__.py new file mode 100644 index 00000000..0d879069 --- /dev/null +++ b/pulumi/seqera_platform/shared/config/__init__.py @@ -0,0 +1,5 @@ +"""Configuration management for AWS Megatests infrastructure.""" + +from .settings import get_configuration, ConfigurationError + +__all__ = ["get_configuration", "ConfigurationError"] diff --git a/pulumi/seqera_platform/shared/config/settings.py b/pulumi/seqera_platform/shared/config/settings.py new file mode 100644 index 00000000..ed3c986c --- /dev/null +++ b/pulumi/seqera_platform/shared/config/settings.py @@ -0,0 +1,117 @@ +"""Configuration management for AWS Megatests infrastructure using Pulumi ESC.""" + +import os +from typing import Dict, Any, Optional +from dataclasses import dataclass + +from utils.constants import DEFAULT_ENV_VARS + + +class ConfigurationError(Exception): + """Exception raised when configuration validation fails.""" + + pass + + +@dataclass +class InfrastructureConfig: + """Typed configuration for AWS Megatests infrastructure. + + Attributes: + tower_access_token: Seqera Platform access token + tower_workspace_id: Seqera Platform workspace ID + github_token: GitHub personal access token (classic) + platform_github_org_token: GitHub fine-grained token to avoid rate limits when pulling pipelines + """ + + tower_access_token: Optional[str] + tower_workspace_id: str + github_token: Optional[str] + platform_github_org_token: Optional[str] + + def validate(self) -> None: + """Validate configuration values. + + Raises: + ConfigurationError: If required configuration is missing or invalid + """ + missing_vars = [] + + if not self.tower_access_token: + missing_vars.append("TOWER_ACCESS_TOKEN") + + if not self.github_token: + missing_vars.append("GITHUB_TOKEN") + + # Validate workspace ID is numeric + if ( + not self.tower_workspace_id + or not self.tower_workspace_id.replace(".", "").isdigit() + ): + missing_vars.append("TOWER_WORKSPACE_ID (must be numeric)") + + if missing_vars: + raise ConfigurationError( + f"Missing or invalid required environment variables: {', '.join(missing_vars)}. " + "Please ensure these are set in your ESC environment." + ) + + +def _get_env_var_with_fallback( + var_name: str, fallback: Optional[str] = None +) -> Optional[str]: + """Get environment variable with optional fallback. + + Args: + var_name: Name of the environment variable + fallback: Optional fallback value if variable is not set + + Returns: + Optional[str]: Environment variable value or fallback + """ + value = os.environ.get(var_name) + if not value and fallback: + print( + f"Warning: {var_name} not found in ESC environment, using fallback: {fallback}" + ) + return fallback + return value + + +def get_configuration() -> Dict[str, Any]: + """Get configuration values from ESC environment variables. + + All configuration comes from ESC environment variables which are automatically + set when the ESC environment is imported. + + Returns: + Dict[str, Any]: Configuration dictionary compatible with existing code + + Raises: + ConfigurationError: If required configuration is missing or invalid + """ + # Get workspace ID from environment or fall back to default + workspace_id = _get_env_var_with_fallback( + "TOWER_WORKSPACE_ID", DEFAULT_ENV_VARS.get("TOWER_WORKSPACE_ID") + ) + + # Create typed configuration object + config = InfrastructureConfig( + tower_access_token=os.environ.get("TOWER_ACCESS_TOKEN"), + tower_workspace_id=workspace_id or "", + github_token=os.environ.get("GITHUB_TOKEN"), + platform_github_org_token=os.environ.get("PLATFORM_GITHUB_ORG_TOKEN"), + ) + + # Validate configuration + config.validate() + + # Return dictionary format for backward compatibility + return { + "tower_access_token": config.tower_access_token, + "tower_workspace_id": config.tower_workspace_id, + "github_token": config.github_token, + "platform_github_org_token": config.platform_github_org_token, + # AWS credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN) + # are automatically handled by ESC and picked up by the AWS provider + } diff --git a/pulumi/seqera_platform/shared/infrastructure/__init__.py b/pulumi/seqera_platform/shared/infrastructure/__init__.py new file mode 100644 index 00000000..f342fd1e --- /dev/null +++ b/pulumi/seqera_platform/shared/infrastructure/__init__.py @@ -0,0 +1,16 @@ +"""Infrastructure components for AWS Megatests.""" + +from .s3 import create_s3_infrastructure +from .credentials import create_towerforge_credentials, get_towerforge_resources +from .compute_environments import ( + deploy_seqera_environments_terraform, + get_compute_environment_ids_terraform, +) + +__all__ = [ + "create_s3_infrastructure", + "create_towerforge_credentials", + "get_towerforge_resources", + "deploy_seqera_environments_terraform", + "get_compute_environment_ids_terraform", +] diff --git a/pulumi/seqera_platform/shared/infrastructure/compute_environments.py b/pulumi/seqera_platform/shared/infrastructure/compute_environments.py new file mode 100644 index 00000000..f593d778 --- /dev/null +++ b/pulumi/seqera_platform/shared/infrastructure/compute_environments.py @@ -0,0 +1,411 @@ +"""Seqera Platform compute environment deployment using Seqera Terraform provider.""" + +import json +import os +from typing import Dict, Any, Optional + +import pulumi +import pulumi_seqera as seqera + +from utils.constants import ( + COMPUTE_ENV_NAMES, + COMPUTE_ENV_DESCRIPTIONS, + CONFIG_FILES, + NEXTFLOW_CONFIG_FILES, + DEFAULT_COMPUTE_ENV_CONFIG, + DEFAULT_FORGE_CONFIG, + TIMEOUTS, + ERROR_MESSAGES, +) + + +class ComputeEnvironmentError(Exception): + """Exception raised when compute environment operations fail.""" + + pass + + +class ConfigurationError(Exception): + """Exception raised when configuration loading fails.""" + + pass + + +def load_nextflow_config(env_type: str) -> str: + """Load and merge Nextflow configuration from base and environment-specific files. + + Args: + env_type: Environment type (cpu, gpu, arm) + + Returns: + str: Merged Nextflow configuration content + + Raises: + ConfigurationError: If file loading fails + """ + config_file = NEXTFLOW_CONFIG_FILES.get(env_type) + if not config_file: + raise ConfigurationError( + f"No Nextflow config file defined for environment type: {env_type}" + ) + + if not os.path.exists(config_file): + raise FileNotFoundError(f"Nextflow config file not found: {config_file}") + + # Load base configuration + base_config_file = os.path.join( + os.path.dirname(config_file), "nextflow-base.config" + ) + base_config = "" + if os.path.exists(base_config_file): + try: + with open(base_config_file, "r") as f: + base_config = f.read().strip() + except Exception as e: + raise ConfigurationError( + f"Failed to read base Nextflow config file {base_config_file}: {e}" + ) + + # Load environment-specific configuration + try: + with open(config_file, "r") as f: + env_config = f.read().strip() + except Exception as e: + raise ConfigurationError( + f"Failed to read Nextflow config file {config_file}: {e}" + ) + + # Remove includeConfig line from environment config since we're injecting base config + env_config_lines = env_config.split("\n") + env_config_filtered = [ + line + for line in env_config_lines + if not line.strip().startswith("includeConfig") + ] + env_config_clean = "\n".join(env_config_filtered) + + # Merge base config with environment-specific config + if base_config: + merged_config = f"{base_config}\n\n{env_config_clean}" + else: + merged_config = env_config_clean + + return merged_config.strip() + + +def load_config_file(filename: str) -> Dict[str, Any]: + """Load configuration file with comprehensive error handling. + + Args: + filename: Path to the JSON configuration file + + Returns: + Dict[str, Any]: Loaded configuration data + + Raises: + ConfigurationError: If file loading or parsing fails + """ + if not os.path.exists(filename): + raise FileNotFoundError( + ERROR_MESSAGES["config_file_not_found"].format(filename) + ) + + with open(filename, "r") as f: + config_data = json.load(f) + + return config_data + + +def create_forge_config( + config_args: Dict[str, Any], +) -> seqera.ComputeEnvComputeEnvConfigAwsBatchForgeArgs: + """Create forge configuration for AWS Batch compute environment. + + Args: + config_args: Configuration arguments from JSON file + + Returns: + seqera.ComputeEnvComputeEnvConfigAwsBatchForgeArgs: Forge configuration + """ + forge_data = config_args.get("forge", {}) + + return seqera.ComputeEnvComputeEnvConfigAwsBatchForgeArgs( + type=forge_data.get("type", DEFAULT_FORGE_CONFIG["type"]), + min_cpus=forge_data.get("minCpus", DEFAULT_FORGE_CONFIG["minCpus"]), + max_cpus=forge_data.get("maxCpus", DEFAULT_FORGE_CONFIG["maxCpus"]), + gpu_enabled=forge_data.get("gpuEnabled", DEFAULT_FORGE_CONFIG["gpuEnabled"]), + instance_types=forge_data.get( + "instanceTypes", DEFAULT_FORGE_CONFIG["instanceTypes"] + ), + subnets=forge_data.get("subnets", DEFAULT_FORGE_CONFIG["subnets"]), + security_groups=forge_data.get( + "securityGroups", DEFAULT_FORGE_CONFIG["securityGroups"] + ), + dispose_on_deletion=forge_data.get( + "disposeOnDeletion", DEFAULT_FORGE_CONFIG["disposeOnDeletion"] + ), + allow_buckets=forge_data.get( + "allowBuckets", DEFAULT_FORGE_CONFIG["allowBuckets"] + ), + efs_create=forge_data.get("efsCreate", DEFAULT_FORGE_CONFIG["efsCreate"]), + ebs_boot_size=forge_data.get( + "ebsBootSize", DEFAULT_FORGE_CONFIG["ebsBootSize"] + ), + fargate_head_enabled=forge_data.get( + "fargateHeadEnabled", DEFAULT_FORGE_CONFIG["fargateHeadEnabled"] + ), + arm64_enabled=forge_data.get( + "arm64Enabled", DEFAULT_FORGE_CONFIG["arm64Enabled"] + ), + ) + + +def create_compute_environment( + provider: seqera.Provider, + name: str, + credentials_id: str, + workspace_id: float, + config_args: Dict[str, Any], + env_type: str, + description: Optional[str] = None, + depends_on: Optional[list] = None, + iam_policy_version: Optional[str] = None, +) -> seqera.ComputeEnv: + """Create a Seqera compute environment using Terraform provider with error handling. + + Args: + provider: Configured Seqera provider instance + name: Name for the compute environment + credentials_id: Seqera credentials ID + workspace_id: Seqera workspace ID + config_args: Configuration arguments from JSON file + env_type: Environment type (cpu, gpu, arm) for loading external nextflow config + description: Optional description for the compute environment + depends_on: Optional list of resources this compute environment depends on + iam_policy_version: Optional IAM policy version hash to trigger recreation on policy changes + + Returns: + seqera.ComputeEnv: Created compute environment resource + + Raises: + ComputeEnvironmentError: If compute environment creation fails + ValueError: If required parameters are missing + ConfigurationError: If nextflow config loading fails + """ + pulumi.log.info(f"Creating compute environment: {name}") + + # Validate input parameters + if not name or not credentials_id: + raise ValueError(ERROR_MESSAGES["missing_compute_env_params"].format(name)) + + if not config_args: + raise ValueError(ERROR_MESSAGES["missing_config_args"].format(name)) + + # Create the forge configuration + forge_config = create_forge_config(config_args) + + # Load Nextflow configuration from external file + nextflow_config = load_nextflow_config(env_type) + + # Create AWS Batch configuration + aws_batch_config = seqera.ComputeEnvComputeEnvConfigAwsBatchArgs( + region=config_args.get("region", DEFAULT_COMPUTE_ENV_CONFIG["region"]), + work_dir=config_args.get("workDir", DEFAULT_COMPUTE_ENV_CONFIG["workDir"]), + forge=forge_config, + wave_enabled=config_args.get( + "waveEnabled", DEFAULT_COMPUTE_ENV_CONFIG["waveEnabled"] + ), + fusion2_enabled=config_args.get( + "fusion2Enabled", DEFAULT_COMPUTE_ENV_CONFIG["fusion2Enabled"] + ), + nvnme_storage_enabled=config_args.get( + "nvnmeStorageEnabled", DEFAULT_COMPUTE_ENV_CONFIG["nvnmeStorageEnabled"] + ), + fusion_snapshots=config_args.get( + "fusionSnapshots", DEFAULT_COMPUTE_ENV_CONFIG["fusionSnapshots"] + ), + nextflow_config=nextflow_config, # Use external config file + ) + + # Create the compute environment configuration + compute_env_config = seqera.ComputeEnvComputeEnvConfigArgs( + aws_batch=aws_batch_config + ) + + # Create the compute environment args + compute_env_args = seqera.ComputeEnvComputeEnvArgs( + name=name, + platform="aws-batch", + credentials_id=credentials_id, + config=compute_env_config, + description=description, + ) + + # Add IAM policy version to compute environment description to trigger recreation on policy changes + if iam_policy_version: + # Append policy version hash to description to force recreation when IAM policies change + policy_suffix = f" (IAM Policy Version: {iam_policy_version[:8]})" + if description: + compute_env_args = seqera.ComputeEnvComputeEnvArgs( + name=name, + platform="aws-batch", + credentials_id=credentials_id, + config=compute_env_config, + description=f"{description}{policy_suffix}", + ) + else: + compute_env_args = seqera.ComputeEnvComputeEnvArgs( + name=name, + platform="aws-batch", + credentials_id=credentials_id, + config=compute_env_config, + description=f"Compute environment{policy_suffix}", + ) + + # Create the compute environment resource + resource_options = pulumi.ResourceOptions( + provider=provider, + # Force delete before replace to avoid name conflicts + delete_before_replace=True, + # Add custom timeout for compute environment creation + custom_timeouts=pulumi.CustomTimeouts( + create=TIMEOUTS["compute_env_create"], + update=TIMEOUTS["compute_env_update"], + delete=TIMEOUTS["compute_env_delete"], + ), + ) + + # Add dependencies if specified + if depends_on: + resource_options.depends_on = depends_on + + compute_env = seqera.ComputeEnv( + name, + compute_env=compute_env_args, + workspace_id=workspace_id, + opts=resource_options, + ) + + return compute_env + + +def deploy_seqera_environments_terraform( + config: Dict[str, Any], + towerforge_credentials_id: str, + seqera_provider: Optional[seqera.Provider] = None, + seqera_credential_resource: Optional[seqera.Credential] = None, + iam_policy_hash: Optional[str] = None, + workspace_config: Optional[Dict[str, Any]] = None, +) -> Dict[str, Any]: + """Deploy Seqera Platform compute environments using Terraform provider. + + Args: + config: Configuration dictionary + towerforge_credentials_id: Dynamic TowerForge credentials ID + seqera_provider: Optional existing Seqera provider instance + seqera_credential_resource: Optional Seqera credential resource for dependency + iam_policy_hash: Optional IAM policy hash to force recreation on policy changes + workspace_config: Optional workspace configuration to control which environments are deployed + + Returns: + Dict[str, Any]: Dictionary containing created compute environments and provider + + Raises: + ConfigurationError: If configuration loading fails + ComputeEnvironmentError: If compute environment creation fails + ValueError: If workspace ID is invalid + """ + pulumi.log.info( + "Starting Seqera compute environment deployment using Terraform provider" + ) + + # Use provided seqera provider or create a new one + if seqera_provider is not None: + provider = seqera_provider + pulumi.log.info("Using existing Seqera provider") + else: + # Import here to avoid circular imports + from providers.seqera import create_seqera_provider + + provider = create_seqera_provider(config) + + # Load all configuration files + cpu_config = load_config_file(CONFIG_FILES["cpu"]) + gpu_config = load_config_file(CONFIG_FILES["gpu"]) + arm_config = load_config_file(CONFIG_FILES["arm"]) + + # Validate workspace ID + workspace_id = float(config["tower_workspace_id"]) + + # Create compute environments based on workspace configuration + environments = {} + + # Set up dependencies - compute environments depend on Seqera credential resource + depends_on_resources = [] + if seqera_credential_resource: + depends_on_resources.append(seqera_credential_resource) + + # Determine which environments to deploy + # If workspace_config is not provided, deploy all environments (backward compatibility) + env_configs = [ + ("cpu", cpu_config), + ("gpu", gpu_config), + ("arm", arm_config), + ] + + for env_type, config_data in env_configs: + # Check if this environment should be deployed based on workspace config + should_deploy = True + if workspace_config: + compute_envs = workspace_config.get("compute_environments", {}) + env_config = compute_envs.get(env_type, {}) + should_deploy = env_config.get("enabled", True) + + if not should_deploy: + pulumi.log.info(f"Skipping {env_type} environment (disabled in workspace config)") + continue + + env_name = COMPUTE_ENV_NAMES[env_type] + description = COMPUTE_ENV_DESCRIPTIONS[env_type] + + environments[f"{env_type}_env"] = create_compute_environment( + provider=provider, + name=env_name, + credentials_id=towerforge_credentials_id, + workspace_id=workspace_id, + config_args=config_data, + env_type=env_type, + description=description, + depends_on=depends_on_resources if depends_on_resources else None, + iam_policy_version=iam_policy_hash, + ) + + return { + **environments, + "provider": provider, + } + + +def get_compute_environment_ids_terraform( + terraform_resources: Dict[str, Any], +) -> Dict[str, Any]: + """Extract compute environment IDs from Terraform provider resources. + + Args: + terraform_resources: Dictionary containing terraform resources + + Returns: + Dict[str, Any]: Dictionary mapping environment types to their IDs + Only includes environments that were actually deployed + """ + compute_env_ids = {} + + # Only include environments that exist in terraform_resources + if "cpu_env" in terraform_resources: + compute_env_ids["cpu"] = terraform_resources["cpu_env"].compute_env_id + if "gpu_env" in terraform_resources: + compute_env_ids["gpu"] = terraform_resources["gpu_env"].compute_env_id + if "arm_env" in terraform_resources: + compute_env_ids["arm"] = terraform_resources["arm_env"].compute_env_id + + return compute_env_ids diff --git a/pulumi/seqera_platform/shared/infrastructure/credentials.py b/pulumi/seqera_platform/shared/infrastructure/credentials.py new file mode 100644 index 00000000..51a90c1f --- /dev/null +++ b/pulumi/seqera_platform/shared/infrastructure/credentials.py @@ -0,0 +1,515 @@ +"""TowerForge IAM credentials management module. + +This module creates and manages IAM resources for TowerForge AWS operations, +including policies for Forge operations, Launch operations, and S3 bucket access. +It also uploads the credentials to Seqera Platform for use by compute environments. +""" + +import json +import hashlib +from typing import Optional, Tuple, Dict, Any + +import pulumi +import pulumi_aws as aws +import pulumi_seqera as seqera + +from utils.constants import ( + TOWERFORGE_USER_NAME, + TOWERFORGE_POLICY_NAMES, + TOWERFORGE_CREDENTIAL_NAME, + TOWERFORGE_CREDENTIAL_DESCRIPTION, + TIMEOUTS, +) + + +class CredentialError(Exception): + """Exception raised when credential operations fail.""" + + pass + + +def _create_forge_policy_document() -> Dict[str, Any]: + """Create TowerForge Forge Policy document with comprehensive permissions.""" + return { + "Version": "2012-10-17", + "Statement": [ + { + "Sid": "TowerForge0", + "Effect": "Allow", + "Action": [ + "ssm:GetParameters", + "iam:CreateInstanceProfile", + "iam:DeleteInstanceProfile", + "iam:AddRoleToInstanceProfile", + "iam:RemoveRoleFromInstanceProfile", + "iam:CreateRole", + "iam:DeleteRole", + "iam:AttachRolePolicy", + "iam:DetachRolePolicy", + "iam:PutRolePolicy", + "iam:DeleteRolePolicy", + "iam:PassRole", + "iam:TagRole", + "iam:TagInstanceProfile", + "iam:ListRolePolicies", + "iam:ListAttachedRolePolicies", + "iam:GetRole", + "batch:CreateComputeEnvironment", + "batch:UpdateComputeEnvironment", + "batch:DeleteComputeEnvironment", + "batch:CreateJobQueue", + "batch:UpdateJobQueue", + "batch:DeleteJobQueue", + "batch:DescribeComputeEnvironments", + "batch:DescribeJobQueues", + "fsx:CreateFileSystem", + "fsx:DeleteFileSystem", + "fsx:DescribeFileSystems", + "fsx:TagResource", + "ec2:DescribeSecurityGroups", + "ec2:DescribeAccountAttributes", + "ec2:DescribeSubnets", + "ec2:DescribeLaunchTemplates", + "ec2:DescribeLaunchTemplateVersions", + "ec2:CreateLaunchTemplate", + "ec2:DeleteLaunchTemplate", + "ec2:DescribeKeyPairs", + "ec2:DescribeVpcs", + "ec2:DescribeInstanceTypes", + "ec2:DescribeInstanceTypeOfferings", + "ec2:GetEbsEncryptionByDefault", + "efs:CreateFileSystem", + "efs:DeleteFileSystem", + "efs:DescribeFileSystems", + "efs:CreateMountTarget", + "efs:DeleteMountTarget", + "efs:DescribeMountTargets", + "efs:ModifyFileSystem", + "efs:PutLifecycleConfiguration", + "efs:TagResource", + "elasticfilesystem:CreateFileSystem", + "elasticfilesystem:DeleteFileSystem", + "elasticfilesystem:DescribeFileSystems", + "elasticfilesystem:CreateMountTarget", + "elasticfilesystem:DeleteMountTarget", + "elasticfilesystem:DescribeMountTargets", + "elasticfilesystem:UpdateFileSystem", + "elasticfilesystem:PutLifecycleConfiguration", + "elasticfilesystem:TagResource", + ], + "Resource": "*", + }, + { + "Sid": "TowerLaunch0", + "Effect": "Allow", + "Action": [ + "s3:Get*", + "s3:List*", + "batch:DescribeJobQueues", + "batch:CancelJob", + "batch:SubmitJob", + "batch:ListJobs", + "batch:TagResource", + "batch:DescribeComputeEnvironments", + "batch:TerminateJob", + "batch:DescribeJobs", + "batch:RegisterJobDefinition", + "batch:DescribeJobDefinitions", + "ecs:DescribeTasks", + "ec2:DescribeInstances", + "ec2:DescribeInstanceTypes", + "ec2:DescribeInstanceAttribute", + "ecs:DescribeContainerInstances", + "ec2:DescribeInstanceStatus", + "ec2:DescribeImages", + "logs:Describe*", + "logs:Get*", + "logs:List*", + "logs:StartQuery", + "logs:StopQuery", + "logs:TestMetricFilter", + "logs:FilterLogEvents", + "ses:SendRawEmail", + "secretsmanager:ListSecrets", + ], + "Resource": "*", + }, + ], + } + + +def _create_launch_policy_document() -> Dict[str, Any]: + """Create TowerForge Launch Policy document with limited permissions.""" + return { + "Version": "2012-10-17", + "Statement": [ + { + "Sid": "TowerLaunch0", + "Effect": "Allow", + "Action": [ + "batch:DescribeJobQueues", + "batch:CancelJob", + "batch:SubmitJob", + "batch:ListJobs", + "batch:TagResource", + "batch:DescribeComputeEnvironments", + "batch:TerminateJob", + "batch:DescribeJobs", + "batch:RegisterJobDefinition", + "batch:DescribeJobDefinitions", + "ecs:DescribeTasks", + "ec2:DescribeInstances", + "ec2:DescribeInstanceTypes", + "ec2:DescribeInstanceAttribute", + "ecs:DescribeContainerInstances", + "ec2:DescribeInstanceStatus", + "ec2:DescribeImages", + "logs:Describe*", + "logs:Get*", + "logs:List*", + "logs:StartQuery", + "logs:StopQuery", + "logs:TestMetricFilter", + "logs:FilterLogEvents", + "ses:SendRawEmail", + "secretsmanager:ListSecrets", + ], + "Resource": "*", + } + ], + } + + +def _create_s3_policy_document(bucket_arn: str) -> Dict[str, Any]: + """Create S3 bucket access policy document with multipart upload support. + + Includes permissions for: + - Basic bucket operations (list, get location) + - Object operations (get, put, tag, delete) + - Multipart upload operations (for large files >5GB) + + Args: + bucket_arn: ARN of the S3 bucket to grant access to + + Returns: + Dict[str, Any]: S3 policy document with enhanced permissions + """ + return { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": [ + "s3:ListBucket", + "s3:GetBucketLocation", + "s3:ListBucketMultipartUploads" + ], + "Resource": [bucket_arn], + }, + { + "Action": [ + "s3:GetObject", + "s3:PutObject", + "s3:PutObjectTagging", + "s3:DeleteObject", + "s3:AbortMultipartUpload", + "s3:ListMultipartUploadParts" + ], + "Resource": [f"{bucket_arn}/*"], + "Effect": "Allow", + }, + ], + } + + +def create_seqera_credentials( + seqera_provider: seqera.Provider, + workspace_id: float, + access_key_id: pulumi.Output[str], + access_key_secret: pulumi.Output[str], +) -> seqera.Credential: + """Upload TowerForge AWS credentials to Seqera Platform. + + Args: + seqera_provider: Configured Seqera provider instance + workspace_id: Seqera Platform workspace ID + access_key_id: AWS access key ID from TowerForge IAM user + access_key_secret: AWS secret access key from TowerForge IAM user + + Returns: + seqera.Credential: Seqera credential resource with credentials_id + + Raises: + CredentialError: If credential upload fails + """ + pulumi.log.info("Uploading TowerForge credentials to Seqera Platform") + + # Create AWS credentials configuration for Seqera Platform + aws_keys = seqera.CredentialKeysArgs( + aws=seqera.CredentialKeysAwsArgs( + access_key=access_key_id, + secret_key=access_key_secret, + # Note: assume_role_arn is optional and not needed for direct IAM user credentials + ) + ) + + # Upload credentials to Seqera Platform + seqera_credential = seqera.Credential( + "towerforge-aws-credential", + name=TOWERFORGE_CREDENTIAL_NAME, + description=TOWERFORGE_CREDENTIAL_DESCRIPTION, + provider_type="aws", + workspace_id=workspace_id, + keys=aws_keys, + opts=pulumi.ResourceOptions( + provider=seqera_provider, + # Ensure credentials are uploaded after IAM access key is created + custom_timeouts=pulumi.CustomTimeouts( + create=TIMEOUTS["seqera_credential_create"], + update=TIMEOUTS["seqera_credential_update"], + delete=TIMEOUTS["seqera_credential_delete"], + ), + ), + ) + + return seqera_credential + + +def _create_iam_policies( + aws_provider: aws.Provider, s3_bucket, workspace_suffix: str = "" +) -> Tuple[aws.iam.Policy, aws.iam.Policy, aws.iam.Policy]: + """Create IAM policies for TowerForge operations. + + Args: + aws_provider: Configured AWS provider instance + s3_bucket: S3 bucket resource for policy attachment + workspace_suffix: Optional suffix for workspace-specific policy names + + Returns: + Tuple of (forge_policy, launch_policy, s3_policy) + """ + # TowerForge Forge Policy - Comprehensive permissions for resource creation + forge_policy = aws.iam.Policy( + f"towerforge-forge-policy{workspace_suffix}", + name=f"{TOWERFORGE_POLICY_NAMES['forge']}{workspace_suffix}", + description="IAM policy for TowerForge to create and manage AWS Batch resources", + policy=json.dumps(_create_forge_policy_document()), + opts=pulumi.ResourceOptions(provider=aws_provider), + ) + + # TowerForge Launch Policy - Limited permissions for pipeline execution + launch_policy = aws.iam.Policy( + f"towerforge-launch-policy{workspace_suffix}", + name=f"{TOWERFORGE_POLICY_NAMES['launch']}{workspace_suffix}", + description="IAM policy for TowerForge to launch and monitor pipeline executions", + policy=json.dumps(_create_launch_policy_document()), + opts=pulumi.ResourceOptions(provider=aws_provider), + ) + + # TowerForge S3 Bucket Access Policy - Access to specified S3 bucket + s3_policy = aws.iam.Policy( + f"towerforge-s3-policy{workspace_suffix}", + name=f"{TOWERFORGE_POLICY_NAMES['s3']}{workspace_suffix}", + description=s3_bucket.bucket.apply( + lambda bucket_name: f"IAM policy for TowerForge to access {bucket_name} S3 bucket" + ), + policy=s3_bucket.arn.apply( + lambda arn: json.dumps(_create_s3_policy_document(arn)) + ), + opts=pulumi.ResourceOptions(provider=aws_provider, depends_on=[s3_bucket]), + ) + + return forge_policy, launch_policy, s3_policy + + +def _generate_policy_hash( + forge_policy: aws.iam.Policy, + launch_policy: aws.iam.Policy, + s3_policy: aws.iam.Policy, +) -> str: + """Generate a hash of IAM policies to detect changes. + + Args: + forge_policy: TowerForge Forge policy + launch_policy: TowerForge Launch policy + s3_policy: TowerForge S3 policy + + Returns: + str: SHA256 hash of the combined policy documents + """ + # Create a deterministic hash of all policy documents + forge_doc = _create_forge_policy_document() + launch_doc = _create_launch_policy_document() + + # Combine all policy documents for hashing + combined_policies = json.dumps( + { + "forge": forge_doc, + "launch": launch_doc, + # Note: S3 policy is bucket-specific, so we'll use a placeholder for consistent hashing + # Version updated to include multipart upload permissions + "s3": {"bucket_dependent": True, "version": "v2-multipart"}, + }, + sort_keys=True, + ) + + return hashlib.sha256(combined_policies.encode()).hexdigest() + + +def create_towerforge_credentials( + aws_provider: aws.Provider, + s3_bucket, + seqera_provider: seqera.Provider, + workspace_id: float, + workspace_name: str = None, +) -> Tuple[ + pulumi.Output[str], pulumi.Output[str], pulumi.Output[str], seqera.Credential, str +]: + """Create TowerForge IAM resources and upload to Seqera Platform. + + Creates IAM policies, user, and access keys for TowerForge operations, + then uploads the credentials to Seqera Platform for use by compute environments. + Based on https://github.com/seqeralabs/nf-tower-aws + + Args: + aws_provider: Configured AWS provider instance + s3_bucket: S3 bucket resource for policy attachment + seqera_provider: Configured Seqera provider instance + workspace_id: Seqera Platform workspace ID + workspace_name: Optional workspace name for unique resource naming + + Returns: + Tuple: (access_key_id, access_key_secret, seqera_credentials_id, seqera_credential_resource, iam_policy_hash) + """ + # Create workspace-specific resource names + workspace_suffix = f"-{workspace_name}" if workspace_name else "" + user_name = f"{TOWERFORGE_USER_NAME}{workspace_suffix}" + + # Create IAM policies + forge_policy, launch_policy, s3_policy = _create_iam_policies( + aws_provider, s3_bucket, workspace_suffix=workspace_suffix + ) + + # Generate policy version hash for compute environment recreation on policy changes + iam_policy_hash = _generate_policy_hash(forge_policy, launch_policy, s3_policy) + + # Create TowerForge IAM User + towerforge_user = aws.iam.User( + f"towerforge-user{workspace_suffix}", + name=user_name, + opts=pulumi.ResourceOptions(provider=aws_provider), + ) + + # Attach policies to the TowerForge user + forge_attachment = aws.iam.UserPolicyAttachment( + "towerforge-forge-policy-attachment", + user=towerforge_user.name, + policy_arn=forge_policy.arn, + opts=pulumi.ResourceOptions( + provider=aws_provider, depends_on=[towerforge_user, forge_policy] + ), + ) + + launch_attachment = aws.iam.UserPolicyAttachment( + "towerforge-launch-policy-attachment", + user=towerforge_user.name, + policy_arn=launch_policy.arn, + opts=pulumi.ResourceOptions( + provider=aws_provider, + depends_on=[towerforge_user, launch_policy], + ), + ) + + s3_attachment = aws.iam.UserPolicyAttachment( + "towerforge-s3-policy-attachment", + user=towerforge_user.name, + policy_arn=s3_policy.arn, + opts=pulumi.ResourceOptions( + provider=aws_provider, depends_on=[towerforge_user, s3_policy] + ), + ) + + # Create access keys for the TowerForge user + towerforge_access_key = aws.iam.AccessKey( + "towerforge-access-key", + user=towerforge_user.name, + opts=pulumi.ResourceOptions( + provider=aws_provider, + depends_on=[forge_attachment, launch_attachment, s3_attachment], + additional_secret_outputs=["secret"], + ), + ) + + # Upload the credentials to Seqera Platform + seqera_credential = create_seqera_credentials( + seqera_provider=seqera_provider, + workspace_id=workspace_id, + access_key_id=towerforge_access_key.id, + access_key_secret=towerforge_access_key.secret, + ) + + # Return the access key credentials, Seqera credentials ID, credential resource, and policy hash + return ( + towerforge_access_key.id, + towerforge_access_key.secret, + seqera_credential.credentials_id, + seqera_credential, + iam_policy_hash, + ) + + +def get_towerforge_resources( + aws_provider: aws.Provider, + s3_bucket, + seqera_provider: Optional[seqera.Provider] = None, + workspace_id: Optional[float] = None, +) -> Dict[str, Any]: + """Create TowerForge resources and return resource information for exports. + + This function creates the TowerForge IAM resources and returns a dictionary + containing resource information for Pulumi exports. + + Args: + aws_provider: Configured AWS provider instance + s3_bucket: S3 bucket resource for policy attachment + seqera_provider: Optional Seqera provider for credential upload + workspace_id: Optional workspace ID for Seqera Platform + + Returns: + Dict[str, Any]: Resource information for Pulumi exports + + Raises: + ValueError: If required parameters are missing + """ + # Create the credentials (this will create all the resources) + if seqera_provider and workspace_id: + ( + access_key_id, + access_key_secret, + seqera_credentials_id, + seqera_credential, + iam_policy_hash, + ) = create_towerforge_credentials( + aws_provider, s3_bucket, seqera_provider, workspace_id + ) + else: + # Fallback for backward compatibility - this will raise an error since signature changed + raise ValueError( + "get_towerforge_resources now requires seqera_provider and workspace_id parameters. " + "Please update your code to use the new signature or call create_towerforge_credentials directly." + ) + + return { + "user": { + "name": TOWERFORGE_USER_NAME, + "arn": f"arn:aws:iam::{{aws_account_id}}:user/{TOWERFORGE_USER_NAME}", # Will be populated by Pulumi + }, + "access_key_id": access_key_id, + "access_key_secret": access_key_secret, + "seqera_credentials_id": seqera_credentials_id, + "policies": { + "forge_policy_name": TOWERFORGE_POLICY_NAMES["forge"], + "launch_policy_name": TOWERFORGE_POLICY_NAMES["launch"], + "s3_policy_name": TOWERFORGE_POLICY_NAMES["s3"], + }, + } diff --git a/pulumi/seqera_platform/shared/infrastructure/s3.py b/pulumi/seqera_platform/shared/infrastructure/s3.py new file mode 100644 index 00000000..c7cb1915 --- /dev/null +++ b/pulumi/seqera_platform/shared/infrastructure/s3.py @@ -0,0 +1,204 @@ +"""S3 infrastructure management for AWS Megatests.""" + +from typing import Dict, Any + +import pulumi +from pulumi_aws import s3 + +from utils.constants import S3_BUCKET_NAME + + +def create_s3_infrastructure(aws_provider, bucket_name: str = None, import_existing: bool = True) -> Dict[str, Any]: + """Create or import S3 bucket and lifecycle configuration. + + Args: + aws_provider: Configured AWS provider instance + bucket_name: Optional bucket name override. If not provided, uses S3_BUCKET_NAME from constants + import_existing: If True, import existing bucket. If False, create new bucket. + + Returns: + Dict[str, Any]: Dictionary containing bucket and lifecycle configuration + """ + # Use provided bucket name or fall back to constant + actual_bucket_name = bucket_name or S3_BUCKET_NAME + + # Create resource options based on whether we're importing or creating + if import_existing: + # Import existing AWS resources (for legacy workspaces) + resource_opts = pulumi.ResourceOptions( + import_=actual_bucket_name, # Import existing bucket + protect=True, # Protect from accidental deletion + provider=aws_provider, # Use configured AWS provider + ignore_changes=[ + "lifecycle_rules", + "versioning", + ], # Don't modify existing configurations - managed manually due to permission constraints + ) + else: + # Create new bucket + resource_opts = pulumi.ResourceOptions( + protect=True, # Protect from accidental deletion + provider=aws_provider, # Use configured AWS provider + ) + + # S3 bucket for Nextflow work directory + nf_core_awsmegatests_bucket = s3.Bucket( + actual_bucket_name, + bucket=actual_bucket_name, + opts=resource_opts, + ) + + # S3 bucket lifecycle configuration + # Create lifecycle rules for automated cost optimization and cleanup + bucket_lifecycle_configuration = create_s3_lifecycle_configuration( + aws_provider, nf_core_awsmegatests_bucket + ) + + # S3 bucket CORS configuration for Seqera Data Explorer compatibility + bucket_cors_configuration = create_s3_cors_configuration( + aws_provider, nf_core_awsmegatests_bucket + ) + + return { + "bucket": nf_core_awsmegatests_bucket, + "lifecycle_configuration": bucket_lifecycle_configuration, + "cors_configuration": bucket_cors_configuration, + } + + +def create_s3_lifecycle_configuration(aws_provider, bucket): + """Create S3 lifecycle configuration with proper rules for Nextflow workflows. + + Args: + aws_provider: Configured AWS provider instance + bucket: S3 bucket resource + + Returns: + S3 bucket lifecycle configuration resource + """ + # S3 bucket lifecycle configuration for cost optimization and cleanup + # Rules designed specifically for Nextflow workflow patterns + lifecycle_configuration = s3.BucketLifecycleConfigurationV2( + "nf-core-awsmegatests-lifecycle", + bucket=bucket.id, + rules=[ + # Rule 1: Preserve metadata files with cost optimization + s3.BucketLifecycleConfigurationV2RuleArgs( + id="preserve-metadata-files", + status="Enabled", + filter=s3.BucketLifecycleConfigurationV2RuleFilterArgs( + tag=s3.BucketLifecycleConfigurationV2RuleFilterTagArgs( + key="nextflow.io/metadata", value="true" + ) + ), + transitions=[ + s3.BucketLifecycleConfigurationV2RuleTransitionArgs( + days=30, storage_class="STANDARD_IA" + ), + s3.BucketLifecycleConfigurationV2RuleTransitionArgs( + days=90, storage_class="GLACIER" + ), + ], + ), + # Rule 2: Clean up temporary files after 30 days + s3.BucketLifecycleConfigurationV2RuleArgs( + id="cleanup-temporary-files", + status="Enabled", + filter=s3.BucketLifecycleConfigurationV2RuleFilterArgs( + tag=s3.BucketLifecycleConfigurationV2RuleFilterTagArgs( + key="nextflow.io/temporary", value="true" + ) + ), + expiration=s3.BucketLifecycleConfigurationV2RuleExpirationArgs(days=30), + ), + # Rule 3: Clean up work directory after 30 days + s3.BucketLifecycleConfigurationV2RuleArgs( + id="cleanup-work-directory", + status="Enabled", + filter=s3.BucketLifecycleConfigurationV2RuleFilterArgs(prefix="work/"), + expiration=s3.BucketLifecycleConfigurationV2RuleExpirationArgs(days=30), + ), + # Rule 4: Clean up scratch directory after 30 days + s3.BucketLifecycleConfigurationV2RuleArgs( + id="cleanup-scratch-directory", + status="Enabled", + filter=s3.BucketLifecycleConfigurationV2RuleFilterArgs( + prefix="scratch/" + ), + expiration=s3.BucketLifecycleConfigurationV2RuleExpirationArgs(days=30), + ), + # Rule 5: Clean up cache directories after 30 days + s3.BucketLifecycleConfigurationV2RuleArgs( + id="cleanup-cache-directories", + status="Enabled", + filter=s3.BucketLifecycleConfigurationV2RuleFilterArgs(prefix="cache/"), + expiration=s3.BucketLifecycleConfigurationV2RuleExpirationArgs(days=30), + ), + # Rule 6: Clean up .cache directories after 30 days + s3.BucketLifecycleConfigurationV2RuleArgs( + id="cleanup-dot-cache-directories", + status="Enabled", + filter=s3.BucketLifecycleConfigurationV2RuleFilterArgs( + prefix=".cache/" + ), + expiration=s3.BucketLifecycleConfigurationV2RuleExpirationArgs(days=30), + ), + # Rule 7: Clean up incomplete multipart uploads + s3.BucketLifecycleConfigurationV2RuleArgs( + id="cleanup-incomplete-multipart-uploads", + status="Enabled", + abort_incomplete_multipart_upload=s3.BucketLifecycleConfigurationV2RuleAbortIncompleteMultipartUploadArgs( + days_after_initiation=7 + ), + ), + ], + opts=pulumi.ResourceOptions(provider=aws_provider, depends_on=[bucket]), + ) + + return lifecycle_configuration + + +def create_s3_cors_configuration(aws_provider, bucket): + """Create S3 CORS configuration for Seqera Data Explorer compatibility. + + Args: + aws_provider: Configured AWS provider instance + bucket: S3 bucket resource + + Returns: + S3 bucket CORS configuration resource + """ + # S3 CORS configuration for Seqera Data Explorer compatibility + # Based on official Seqera documentation: + # https://docs.seqera.io/platform-cloud/data/data-explorer#amazon-s3-cors-configuration + cors_configuration = s3.BucketCorsConfigurationV2( + "nf-core-awsmegatests-cors", + bucket=bucket.id, + cors_rules=[ + s3.BucketCorsConfigurationV2CorsRuleArgs( + id="SeqeraDataExplorerAccess", + allowed_headers=["*"], + allowed_methods=["GET", "HEAD", "POST", "PUT", "DELETE"], + allowed_origins=[ + "https://*.cloud.seqera.io", + "https://*.tower.nf", + "https://cloud.seqera.io", + "https://tower.nf", + ], + expose_headers=["ETag"], + max_age_seconds=3000, + ), + # Additional rule for direct browser access + s3.BucketCorsConfigurationV2CorsRuleArgs( + id="BrowserDirectAccess", + allowed_headers=["Authorization", "Content-Type", "Range"], + allowed_methods=["GET", "HEAD"], + allowed_origins=["*"], + expose_headers=["Content-Range", "Content-Length", "ETag"], + max_age_seconds=3000, + ), + ], + opts=pulumi.ResourceOptions(provider=aws_provider, depends_on=[bucket]), + ) + + return cors_configuration diff --git a/pulumi/seqera_platform/shared/integrations/__init__.py b/pulumi/seqera_platform/shared/integrations/__init__.py new file mode 100644 index 00000000..ba069edd --- /dev/null +++ b/pulumi/seqera_platform/shared/integrations/__init__.py @@ -0,0 +1,10 @@ +"""Third-party integrations for AWS Megatests.""" + +from .github import create_github_resources +from .github_credentials import create_github_credential, get_github_credential_config + +__all__ = [ + "create_github_resources", + "create_github_credential", + "get_github_credential_config", +] diff --git a/pulumi/seqera_platform/shared/integrations/github.py b/pulumi/seqera_platform/shared/integrations/github.py new file mode 100644 index 00000000..37daf260 --- /dev/null +++ b/pulumi/seqera_platform/shared/integrations/github.py @@ -0,0 +1,169 @@ +"""GitHub integration for AWS Megatests - secrets and variables management.""" + +from typing import Dict, Any, List, Optional, Union + +import pulumi +import pulumi_github as github + +from utils.constants import GITHUB_VARIABLE_NAMES, S3_BUCKET_NAME + + +class GitHubIntegrationError(Exception): + """Exception raised when GitHub integration operations fail.""" + + pass + + +def _create_organization_variable( + provider: github.Provider, + resource_name: str, + variable_name: str, + value: Union[str, pulumi.Output[str]], +) -> github.ActionsOrganizationVariable: + """Create a GitHub organization variable with consistent configuration. + + Args: + provider: GitHub provider instance + resource_name: Pulumi resource name + variable_name: GitHub variable name + value: Variable value + + Returns: + github.ActionsOrganizationVariable: Created variable resource + """ + return github.ActionsOrganizationVariable( + resource_name, + visibility="all", + variable_name=variable_name, + value=value, + opts=pulumi.ResourceOptions( + provider=provider, + delete_before_replace=True, # Workaround for GitHub provider issue #250 + ignore_changes=[ + "visibility" + ], # Ignore changes to visibility if variable exists + ), + ) + + +def _create_gh_commands( + workspace_id_val: str, cpu_env_id_val: str, tower_token_val: Optional[str] = None +) -> List[str]: + """Generate manual gh CLI commands for secrets management. + + Args: + workspace_id_val: Workspace ID value + cpu_env_id_val: CPU environment ID value + tower_token_val: Optional tower access token placeholder + + Returns: + List[str]: List of gh CLI commands + """ + commands = [] + + # Legacy workspace ID secret + commands.append( + f'gh secret set TOWER_WORKSPACE_ID --org nf-core --body "{workspace_id_val}" --visibility all' + ) + + # Legacy compute env secret (CPU) + commands.append( + f'gh secret set TOWER_COMPUTE_ENV --org nf-core --body "{cpu_env_id_val}" --visibility all' + ) + + # Tower access token (if provided) + if tower_token_val: + commands.append( + "OP_ACCOUNT=nf-core gh secret set TOWER_ACCESS_TOKEN --org nf-core " + "--body \"$(op read 'op://Dev/Seqera Platform/TOWER_ACCESS_TOKEN')\" --visibility all" + ) + + return commands + + +def create_github_resources( + github_provider: github.Provider, + compute_env_ids: Dict[str, Any], + tower_workspace_id: Union[str, pulumi.Output[str]], + tower_access_token: Optional[str] = None, +) -> Dict[str, Any]: + """Create GitHub organization variables and provide manual secret commands. + + Args: + github_provider: GitHub provider instance + compute_env_ids: Dictionary containing compute environment IDs + tower_workspace_id: Seqera Platform workspace ID + tower_access_token: Tower access token for manual secret commands (optional) + + Returns: + Dict[str, Any]: Dictionary containing created variables and manual commands + + Raises: + GitHubIntegrationError: If GitHub resource creation fails + """ + # Create org-level GitHub variables for compute environment IDs (non-sensitive) + # Using delete_before_replace to work around pulumi/pulumi-github#250 + variables = {} + + # Compute environment variables + for env_type in ["cpu", "gpu", "arm"]: + var_name = GITHUB_VARIABLE_NAMES[env_type] + resource_name = f"tower-compute-env-{env_type}" + + variables[env_type] = _create_organization_variable( + github_provider, + resource_name, + var_name, + compute_env_ids[env_type], + ) + + # Workspace ID variable + variables["workspace_id"] = _create_organization_variable( + github_provider, + "tower-workspace-id", + GITHUB_VARIABLE_NAMES["workspace_id"], + tower_workspace_id, + ) + + # Legacy S3 bucket variable + variables["legacy_s3_bucket"] = _create_organization_variable( + github_provider, + "legacy-aws-s3-bucket", + GITHUB_VARIABLE_NAMES["s3_bucket"], + S3_BUCKET_NAME, + ) + + # GitHub Secrets Management - Manual Commands Only + # NOTE: Due to pulumi/pulumi-github#250, secrets must be managed manually + # https://github.com/nf-core/ops/issues/162 - Legacy compatibility needed + + # Generate manual gh CLI commands for secrets management + if all(isinstance(compute_env_ids[k], str) for k in compute_env_ids) and isinstance( + tower_workspace_id, str + ): + # All static values + gh_cli_commands: Union[List[str], pulumi.Output[List[str]]] = ( + _create_gh_commands( + tower_workspace_id, + compute_env_ids["cpu"], + "" if tower_access_token else None, + ) + ) + else: + # Dynamic values - create commands that will be resolved at runtime + gh_cli_commands = pulumi.Output.all( + workspace_id=tower_workspace_id, cpu_env_id=compute_env_ids["cpu"] + ).apply( + lambda args: _create_gh_commands( + args["workspace_id"], + args["cpu_env_id"], + "" if tower_access_token else None, + ) + ) + + return { + "variables": variables, + "secrets": {}, # No Pulumi-managed secrets due to provider issue + "gh_cli_commands": gh_cli_commands, + "note": "Secrets must be managed manually due to pulumi/pulumi-github#250", + } diff --git a/pulumi/seqera_platform/shared/integrations/github_credentials.py b/pulumi/seqera_platform/shared/integrations/github_credentials.py new file mode 100644 index 00000000..707bc8c7 --- /dev/null +++ b/pulumi/seqera_platform/shared/integrations/github_credentials.py @@ -0,0 +1,96 @@ +"""GitHub credentials integration for Seqera Platform.""" + +import pulumi +import pulumi_seqera as seqera +from typing import Dict, Tuple + + +class GitHubCredentialError(Exception): + """Exception raised when GitHub credential creation fails.""" + + pass + + +def create_github_credential( + seqera_provider: seqera.Provider, + workspace_id: int, + github_token: str, + github_username: str = "nf-core-bot", + credential_name: str = "nf-core-github-finegrained", +) -> Tuple[seqera.Credential, str]: + """Create a GitHub fine-grained credential in Seqera Platform. + + This credential allows Seqera Platform to pull pipeline repositories from GitHub + without hitting GitHub rate limits. The fine-grained token provides secure, + scoped access to nf-core repositories with minimal required permissions. + + Args: + seqera_provider: Configured Seqera provider instance + workspace_id: Seqera workspace ID + github_token: Fine-grained GitHub personal access token for repository access + github_username: GitHub username (default: nf-core-bot) + credential_name: Name for the credential in Seqera + + Returns: + Tuple of (credential_resource, credential_id) + + Raises: + GitHubCredentialError: If credential creation fails + ValueError: If required parameters are missing + """ + # Validate required parameters + if not github_token: + raise ValueError("GitHub token is required") + if not workspace_id: + raise ValueError("Workspace ID is required") + + pulumi.log.info( + f"Creating GitHub credential '{credential_name}' in workspace {workspace_id}" + ) + + try: + # Create GitHub credential using Seqera Terraform provider + github_credential = seqera.Credential( + f"github-credential-{credential_name}", + name=credential_name, + description="Fine-grained GitHub token to avoid rate limits when Platform pulls pipeline repositories", + provider_type="github", + base_url="https://github.com/nf-core/", # Scope to nf-core organization + keys=seqera.CredentialKeysArgs( + github=seqera.CredentialKeysGithubArgs( + username=github_username, + password=github_token, # GitHub tokens go in the password field + ) + ), + workspace_id=workspace_id, + opts=pulumi.ResourceOptions( + provider=seqera_provider, + protect=True, # Protect credential from accidental deletion + ), + ) + + # Return both the resource and the credential ID for reference + return github_credential, github_credential.id + + except Exception as e: + pulumi.log.error(f"Failed to create GitHub credential: {str(e)}") + raise GitHubCredentialError( + f"GitHub credential creation failed: {str(e)}" + ) from e + + +def get_github_credential_config() -> Dict[str, str]: + """Get configuration for GitHub credential creation. + + Returns: + Dict containing configuration values from ESC environment + """ + import os + + return { + "github_finegrained_token": os.environ.get("PLATFORM_GITHUB_ORG_TOKEN", ""), + "github_username": os.environ.get("GITHUB_USERNAME", "nf-core-bot"), + "credential_name": os.environ.get( + "GITHUB_CREDENTIAL_NAME", "nf-core-github-finegrained" + ), + } diff --git a/pulumi/seqera_platform/shared/integrations/workspace_participants_command.py b/pulumi/seqera_platform/shared/integrations/workspace_participants_command.py new file mode 100644 index 00000000..b8a6b388 --- /dev/null +++ b/pulumi/seqera_platform/shared/integrations/workspace_participants_command.py @@ -0,0 +1,268 @@ +"""Seqera Platform workspace participant management using Pulumi Command provider.""" + +import json +import pulumi +import pulumi_command as command +from typing import Dict, List, Optional +from utils.logging import log_info + + +def create_team_data_setup_command( + workspace_id: int, + seqera_token: str, + github_token: str, + opts: Optional[pulumi.ResourceOptions] = None, +) -> command.local.Command: + """ + Create a Pulumi Command that generates team data with proper credentials. + + This runs the team data setup scripts automatically during Pulumi deployment. + """ + setup_cmd = command.local.Command( + "team-data-setup", + create=""" +# Generate team member data with proper credentials +echo "=== Setting up team member data with privacy protection ===" + +# Run setup script with environment credentials +uv run python scripts/setup_team_data.py + +echo "✓ Team data setup completed" +echo "Files generated locally (not committed to git):" +echo " - scripts/maintainers_data.json" +echo " - scripts/core_team_data.json" +echo " - scripts/unified_team_data.json" + """, + environment={ + "GITHUB_TOKEN": github_token, + "TOWER_ACCESS_TOKEN": seqera_token, + }, + opts=opts, + ) + + return setup_cmd + + +def create_individual_member_commands( + workspace_id: int, + token: str, + github_token: str, + org_id: int = 252464779077610, # nf-core + opts: Optional[pulumi.ResourceOptions] = None, +) -> tuple[command.local.Command, Dict[str, command.local.Command]]: + """ + Create individual Pulumi Command resources for each GitHub team member. + + This provides granular tracking of each maintainer's workspace participant status. + """ + # First, ensure team data is set up with proper credentials + setup_cmd = create_team_data_setup_command(workspace_id, token, github_token, opts) + + # Generate team data at runtime to avoid committing private emails + log_info("Team data will be generated automatically during deployment...") + + # Load team data (will be available after setup command runs) + try: + with open("scripts/unified_team_data.json", "r") as f: + data = json.load(f) + team_members = data.get("seqera_participants", []) + log_info(f"Loaded {len(team_members)} team members from runtime data") + except FileNotFoundError: + # For preview purposes, show expected team count + log_info("Team data will be generated during deployment (35 expected members)") + team_members = [] + except Exception as e: + log_info(f"Team data will be generated at runtime: {e}") + team_members = [] + + member_commands = {} + + log_info(f"Creating individual tracking for {len(team_members)} team members") + + for member in team_members: + email = member["name"] + github_username = member["github_username"] + role = member["role"] # OWNER for core team, MAINTAIN for maintainers + + # Create safe resource name + safe_name = github_username.replace("-", "_").replace(".", "_") + + # Note: Role precedence handled in bash script (core team checked first) + + # Create individual command for this member + member_cmd = command.local.Command( + f"team_sync_{safe_name}", + create=f''' +#!/bin/bash +# Sync GitHub team member '{github_username}' to Seqera workspace with {role} role +echo "=== Syncing {github_username} ({email}) as {role} ===" + +# Verify user is still in appropriate GitHub teams +echo "Checking GitHub team membership..." +found_in_team=false + +# Check core team first (higher precedence) +if gh api orgs/nf-core/teams/core/members --jq '.[].login' | grep -q "^{github_username}$"; then + echo "✓ {github_username} confirmed in nf-core/core team (OWNER role)" + current_role="OWNER" + found_in_team=true +elif gh api orgs/nf-core/teams/maintainers/members --jq '.[].login' | grep -q "^{github_username}$"; then + echo "✓ {github_username} confirmed in nf-core/maintainers team (MAINTAIN role)" + current_role="MAINTAIN" + found_in_team=true +fi + +if [ "$found_in_team" = false ]; then + echo "⚠️ {github_username} not found in any relevant team, skipping" + exit 0 +fi + +# Ensure we're using the correct role (core team precedence) +target_role="{role}" +if [ "$current_role" != "$target_role" ]; then + echo "🔄 Role precedence: Using $current_role (detected) instead of $target_role" + target_role="$current_role" +fi + +# Check current email (in case it changed) +echo "Fetching current email..." +current_email=$(gh api /users/{github_username} --jq '.email // empty') + +# Handle members without public emails +if [[ "{email}" == github:* ]]; then + # Member has no public email, try to get current one + if [ -z "$current_email" ]; then + echo "⚠️ {github_username} has no public email - cannot add to Seqera Platform" + echo "STATUS:NO_EMAIL:{github_username}:$target_role" + exit 0 + else + echo "✓ {github_username} now has public email: $current_email" + fi +else + # Member had cached email, check if it changed + cached_email="{email}" + if [ -z "$current_email" ]; then + echo "⚠️ {github_username} email no longer public, using cached: $cached_email" + current_email="$cached_email" + elif [ "$current_email" != "$cached_email" ]; then + echo "🔄 {github_username} email changed: $cached_email → $current_email" + else + echo "✓ Current email confirmed: $current_email" + fi +fi + +# Add to Seqera workspace +echo "Adding to Seqera workspace {workspace_id}..." +response=$(curl -s -w "%{{http_code}}" -X PUT \\ + "https://api.cloud.seqera.io/orgs/{org_id}/workspaces/{workspace_id}/participants/add" \\ + -H "Authorization: Bearer {token}" \\ + -H "Content-Type: application/json" \\ + -d '{{"userNameOrEmail": "'$current_email'"}}') + +http_code="${{response: -3}}" +response_body="${{response%???}}" + +case $http_code in + 200|201|204) + echo "✓ Successfully added {github_username} with $target_role role" + echo "STATUS:ADDED:$current_email:$target_role" + ;; + 409) + echo "~ {github_username} already exists in workspace" + echo "STATUS:EXISTS:$current_email:$target_role" + ;; + 404) + echo "✗ User not found in Seqera Platform: $current_email" + echo "STATUS:USER_NOT_FOUND:$current_email:N/A" + ;; + *) + echo "✗ Failed to add {github_username}: HTTP $http_code" + echo "Response: $response_body" + echo "STATUS:FAILED:$current_email:ERROR" + exit 1 + ;; +esac + +echo "Completed sync for {github_username}" + ''', + environment={ + "GITHUB_TOKEN": github_token, + }, + opts=pulumi.ResourceOptions( + depends_on=[setup_cmd], + parent=opts.parent if opts else None, + ), + ) + + member_commands[github_username] = member_cmd + + return setup_cmd, member_commands + + +def create_workspace_participants_via_command( + workspace_id: int, + token: str, + participants_data: List[Dict[str, str]], + opts: Optional[pulumi.ResourceOptions] = None, +) -> command.local.Command: + """ + Create workspace participants using Pulumi Command provider to run the Python script. + + Args: + workspace_id: Seqera workspace ID + token: Seqera API access token + participants_data: List of participant dictionaries + opts: Pulumi resource options + + Returns: + Command resource that manages workspace participants + """ + # Create the command that will run our Python script + participant_count = len(participants_data) + log_info(f"Creating command to add {participant_count} workspace participants") + + # The command runs within the Pulumi execution context + add_participants_cmd = command.local.Command( + "add-workspace-participants", + create="uv run python scripts/add_maintainers_to_workspace.py --yes", + environment={ + "TOWER_ACCESS_TOKEN": token, + "TOWER_WORKSPACE_ID": str(workspace_id), + }, + opts=pulumi.ResourceOptions(**opts.__dict__ if opts else {}), + ) + + return add_participants_cmd + + +def create_workspace_participants_verification( + workspace_id: int, + token: str, + depends_on: List[pulumi.Resource], + opts: Optional[pulumi.ResourceOptions] = None, +) -> command.local.Command: + """ + Create a verification command that checks workspace participants were added correctly. + + Args: + workspace_id: Seqera workspace ID + token: Seqera API access token + depends_on: Resources this command depends on + opts: Pulumi resource options + + Returns: + Command resource that verifies workspace participants + """ + verification_cmd = command.local.Command( + "verify-workspace-participants", + create="uv run python scripts/inspect_participants.py", + environment={ + "TOWER_ACCESS_TOKEN": token, + "TOWER_WORKSPACE_ID": str(workspace_id), + }, + opts=pulumi.ResourceOptions( + depends_on=depends_on, **(opts.__dict__ if opts else {}) + ), + ) + + return verification_cmd diff --git a/pulumi/seqera_platform/shared/integrations/workspace_participants_simple.py b/pulumi/seqera_platform/shared/integrations/workspace_participants_simple.py new file mode 100644 index 00000000..0a2d2943 --- /dev/null +++ b/pulumi/seqera_platform/shared/integrations/workspace_participants_simple.py @@ -0,0 +1,124 @@ +"""Simple workspace participant management using Pulumi's apply() pattern.""" + +import json +import pulumi +import requests +from typing import Dict, List, Any +from utils.logging import log_info + + +def add_workspace_participant_simple( + email: str, + role: str, + workspace_id: pulumi.Output[str], + token: pulumi.Output[str], + org_id: int = 252464779077610, +) -> pulumi.Output[Dict[str, Any]]: + """ + Add a workspace participant using Pulumi's apply() pattern. + + This is simpler than dynamic resources but still integrates with Pulumi. + """ + + def _add_participant(args): + """Internal function that does the actual API call.""" + workspace_id_val, token_val = args + + headers = { + "Authorization": f"Bearer {token_val}", + "Content-Type": "application/json", + } + + url = f"https://api.cloud.seqera.io/orgs/{org_id}/workspaces/{workspace_id_val}/participants/add" + payload = {"userNameOrEmail": email} + + try: + response = requests.put(url, headers=headers, json=payload, timeout=30) + + if response.status_code in [200, 201, 204]: + return { + "email": email, + "role": role, + "workspace_id": workspace_id_val, + "status": "added", + "participant_id": f"{org_id}:{workspace_id_val}:{email}", + } + elif response.status_code == 409: + return { + "email": email, + "role": role, + "workspace_id": workspace_id_val, + "status": "already_exists", + "participant_id": f"{org_id}:{workspace_id_val}:{email}", + } + else: + return { + "email": email, + "role": role, + "workspace_id": workspace_id_val, + "status": "failed", + "error": f"HTTP {response.status_code}", + } + + except Exception as e: + return { + "email": email, + "role": role, + "workspace_id": workspace_id_val, + "status": "error", + "error": str(e), + } + + # Use Pulumi's apply to handle the async nature of Outputs + return pulumi.Output.all(workspace_id, token).apply(_add_participant) + + +def create_workspace_participants_simple( + workspace_id: pulumi.Output[str], + token: pulumi.Output[str], + maintainer_emails: List[str], + role: str = "MAINTAIN", +) -> pulumi.Output[List[Dict[str, Any]]]: + """ + Create multiple workspace participants using the simple approach. + + Args: + workspace_id: Seqera workspace ID as Pulumi Output + token: Seqera API token as Pulumi Output + maintainer_emails: List of email addresses to add + role: Role to assign (default: MAINTAIN) + + Returns: + Pulumi Output containing list of participant creation results + """ + + participant_outputs = [] + + for email in maintainer_emails: + participant_result = add_workspace_participant_simple( + email, role, workspace_id, token + ) + participant_outputs.append(participant_result) + + # Combine all outputs into a single list + return pulumi.Output.all(*participant_outputs) + + +def load_maintainer_emails_static() -> List[str]: + """Load maintainer emails from the JSON file (static version for Pulumi).""" + try: + with open("scripts/maintainers_data.json", "r") as f: + data = json.load(f) + + participants = data.get("seqera_participants", []) + emails = [p["name"] for p in participants] + + log_info(f"Loaded {len(emails)} maintainer emails for workspace participants") + return emails + + except FileNotFoundError: + log_info("Maintainers data file not found, skipping workspace participants") + return [] + except Exception as e: + log_info(f"Error loading maintainers data: {e}") + return [] diff --git a/pulumi/seqera_platform/shared/providers/__init__.py b/pulumi/seqera_platform/shared/providers/__init__.py new file mode 100644 index 00000000..39eb2523 --- /dev/null +++ b/pulumi/seqera_platform/shared/providers/__init__.py @@ -0,0 +1,7 @@ +"""Provider configurations for AWS Megatests infrastructure.""" + +from .aws import create_aws_provider +from .github import create_github_provider +from .seqera import create_seqera_provider + +__all__ = ["create_aws_provider", "create_github_provider", "create_seqera_provider"] diff --git a/pulumi/seqera_platform/shared/providers/aws.py b/pulumi/seqera_platform/shared/providers/aws.py new file mode 100644 index 00000000..466cd56e --- /dev/null +++ b/pulumi/seqera_platform/shared/providers/aws.py @@ -0,0 +1,19 @@ +"""AWS provider configuration for AWS Megatests infrastructure.""" + +import pulumi_aws as aws +from utils.constants import AWS_REGION + + +def create_aws_provider() -> aws.Provider: + """Create AWS provider using ESC OIDC authentication. + + The ESC environment should automatically provide AWS credentials + when the environment is imported in Pulumi.prod.yaml. + + Returns: + aws.Provider: Configured AWS provider instance + """ + return aws.Provider( + "aws-provider", + region=AWS_REGION, + ) diff --git a/pulumi/seqera_platform/shared/providers/github.py b/pulumi/seqera_platform/shared/providers/github.py new file mode 100644 index 00000000..3a82c67c --- /dev/null +++ b/pulumi/seqera_platform/shared/providers/github.py @@ -0,0 +1,16 @@ +"""GitHub provider configuration for AWS Megatests infrastructure.""" + +import pulumi_github as github +from utils.constants import GITHUB_ORG + + +def create_github_provider(github_token: str) -> github.Provider: + """Create GitHub provider with token authentication. + + Args: + github_token: GitHub personal access token with org admin permissions + + Returns: + github.Provider: Configured GitHub provider instance + """ + return github.Provider("github-provider", token=github_token, owner=GITHUB_ORG) diff --git a/pulumi/seqera_platform/shared/providers/seqera.py b/pulumi/seqera_platform/shared/providers/seqera.py new file mode 100644 index 00000000..29a5ffab --- /dev/null +++ b/pulumi/seqera_platform/shared/providers/seqera.py @@ -0,0 +1,38 @@ +"""Seqera provider configuration for AWS Megatests infrastructure.""" + +import pulumi +import pulumi_seqera as seqera +from typing import Dict, Any +from utils.constants import SEQERA_API_URL, ERROR_MESSAGES + + +class SeqeraProviderError(Exception): + """Exception raised when Seqera provider initialization fails.""" + + pass + + +def create_seqera_provider(config: Dict[str, Any]) -> seqera.Provider: + """Create and configure the Seqera provider with error handling. + + Args: + config: Configuration dictionary containing tower_access_token + + Returns: + seqera.Provider: Configured Seqera provider instance + + Raises: + SeqeraProviderError: If provider creation fails + ValueError: If required configuration is missing + """ + # Validate required configuration + if not config.get("tower_access_token"): + raise ValueError(ERROR_MESSAGES["missing_tower_token"]) + + pulumi.log.info("Creating Seqera provider with Cloud API endpoint") + + return seqera.Provider( + "seqera-provider", + bearer_auth=config["tower_access_token"], + server_url=SEQERA_API_URL, + ) diff --git a/pulumi/seqera_platform/shared/seqerakit/CLAUDE.md b/pulumi/seqera_platform/shared/seqerakit/CLAUDE.md new file mode 100644 index 00000000..9d5d00ea --- /dev/null +++ b/pulumi/seqera_platform/shared/seqerakit/CLAUDE.md @@ -0,0 +1,186 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +This directory contains seqerakit configurations for nf-core megatest infrastructure on the Seqera Platform, integrated with the parent Pulumi AWSMegatests project. Seqerakit is a Python-based Infrastructure as Code (IaC) utility that uses YAML configurations to automate Seqera Platform resource creation and management. + +**Integration**: These seqerakit configurations are deployed through the parent Pulumi project using the command provider, which automatically extracts compute environment IDs and deploys them as GitHub secrets. + +## Common Commands + +### Prerequisites + +**Note**: These configurations are typically deployed through the parent Pulumi project, not directly via seqerakit commands. + +For standalone usage: +```bash +# Install seqerakit +pip install seqerakit + +# Install direnv (for 1Password integration) +brew install direnv + +# Allow the .envrc file (loads secrets from 1Password) +cd .. && direnv allow + +# Alternatively, manually load environment variables +# export TOWER_ACCESS_TOKEN= +``` + +### Seqerakit Operations + +**Recommended**: Use the parent Pulumi project for deployment: +```bash +# From parent directory +cd .. && direnv exec . uv run pulumi up +``` + +**Direct seqerakit usage** (for testing/debugging): +```bash +# Dry run to validate configuration +seqerakit aws_ireland_fusionv2_nvme_cpu_current.yml --dryrun + +# Deploy individual compute environments (current production configs) +seqerakit aws_ireland_fusionv2_nvme_cpu_current.yml +seqerakit aws_ireland_fusionv2_nvme_cpu_arm_current.yml +seqerakit aws_ireland_fusionv2_nvme_gpu_current.yml + +# Delete resources +seqerakit aws_ireland_fusionv2_nvme_cpu_current.yml --delete +``` + +## Architecture + +### Configuration Structure + +The repository contains YAML-based Infrastructure as Code configurations for four distinct AWS Batch compute environments: + +1. **CPU Environment** (`aws_ireland_fusionv2_nvme_cpu.yml`): + + - Instance types: c6id, m6id, r6id (Intel x86_64 with NVMe storage) + - Features: Fusion v2, Wave, fast storage, no EBS auto-scale + - Provisioning: SPOT instances + +2. **GPU Environment** (`aws_ireland_fusionv2_nvme_gpu.yml`): + + - Instance types: g4dn, g5, c6id, m6id, r6id (GPU + CPU instances) + - Features: GPU enabled, Fusion v2, Wave, fast storage + - Provisioning: SPOT instances + +3. **ARM Environment** (`aws_ireland_fusionv2_nvme_arm.yml`): + + - Instance types: m6gd, c6gd, r6gd (ARM Graviton2 with NVMe storage) + - Features: Fusion v2, Wave, fast storage + - Provisioning: SPOT instances + +4. **No Fusion Environment** (`aws_ireland_nofusion.yml`): + - Traditional setup without Fusion v2 optimizations + - Features: Wave disabled, standard EBS storage + - Provisioning: SPOT instances + +### Environment Variables + +The `.envrc` file defines key configuration variables and loads secrets from 1Password: + +**Static Configuration**: + +- `ORGANIZATION_NAME`: "nf-core" +- `WORKSPACE_NAME`: "AWSmegatests" +- `AWS_CREDENTIALS_NAME`: "tower-awstest" +- `AWS_REGION`: "eu-west-1" +- `AWS_WORK_DIR`: "s3://nf-core-awsmegatests" +- `AWS_COMPUTE_ENV_ALLOWED_BUCKETS`: "s3://ngi-igenomes,s3://annotation-cache" + +**1Password Secrets**: + +- `TOWER_ACCESS_TOKEN`: `op://Dev/Tower nf-core Access Token/password` +- `AWS_ACCESS_KEY_ID`: `op://Dev/AWS Tower Test Credentials/access key id` +- `AWS_SECRET_ACCESS_KEY`: `op://Dev/AWS Tower Test Credentials/secret access key` + +### Common Configuration Patterns + +All compute environments share: + +- **Type**: aws-batch +- **Config Mode**: forge +- **Max CPUs**: 500 +- **Wait State**: AVAILABLE +- **On Exists**: overwrite +- **Provisioning Model**: SPOT + +Key differentiators: + +- **Instance Types**: Vary by architecture (x86_64, ARM, GPU) +- **Fusion v2**: Enabled for performance environments, disabled for traditional +- **Fast Storage**: NVMe-enabled instances vs standard storage +- **GPU Support**: Only enabled for GPU environment + +## Workflow + +The typical deployment workflow: + +1. **Environment Setup**: `direnv allow` to load configuration variables and 1Password secrets +2. **Validation**: Use `--dryrun` flag to validate YAML configurations +3. **Deployment**: Execute seqerakit commands to create compute environments +4. **Management**: Use `--delete` flag to remove resources when needed + +## Pulumi Integration + +### How Seqerakit Integrates with Pulumi + +These seqerakit configurations are deployed through the parent Pulumi project using: + +1. **Command Provider**: Executes seqerakit CLI commands as Pulumi resources +2. **Output Extraction**: Parses seqerakit output to extract compute environment IDs +3. **GitHub Secrets**: Automatically deploys extracted IDs as GitHub organization secrets +4. **1Password Integration**: Inherits secure credential management from parent project + +### Current Infrastructure Files + +- `current-env-cpu.json`: Exported CPU environment configuration +- `current-env-cpu-arm.json`: Exported CPU ARM environment configuration +- `current-env-gpu.json`: Exported GPU environment configuration +- `aws_ireland_fusionv2_nvme_cpu_current.yml`: Seqerakit config for CPU environment +- `aws_ireland_fusionv2_nvme_cpu_arm_current.yml`: Seqerakit config for CPU ARM environment +- `aws_ireland_fusionv2_nvme_gpu_current.yml`: Seqerakit config for GPU environment + +### Deployment Process + +1. **Pulumi Command Resources**: Execute seqerakit deployment commands +2. **ID Extraction**: Parse seqerakit output to get compute environment IDs +3. **GitHub Secrets**: Deploy extracted IDs to GitHub organization secrets +4. **Workspace ID**: Extract and deploy Seqera workspace ID + +### Required Configuration + +Environment variables are inherited from the parent `.envrc`: +- `TOWER_ACCESS_TOKEN`: Seqera Platform access token (from 1Password) +- `ORGANIZATION_NAME`, `WORKSPACE_NAME`: Seqera Platform identifiers +- AWS credentials for compute environment deployment + +### Migration from Manual Setup + +The current configurations were exported from existing environments: + +- CPU: `53ljSqphNKjm6jjmuB6T9b` → `aws_ireland_fusionv2_nvme_cpu` +- CPU ARM: `5LWYX9a2GxrIFiax8tn9DV` → `aws_ireland_fusionv2_nvme_cpu_ARM_snapshots` +- GPU: `7Gjp4zOBlhH9xMIlfs9LM2` → `aws_ireland_fusionv2_nvme_gpu_snapshots` + +## Known Issues + +From the project README: + +- How to enable snapshots with seqerakit +- How to create GPU-enabled compute environments with seqerakit (partially addressed in current configs) + +## Technical Details + +- **Cloud Provider**: AWS +- **Region**: eu-west-1 (Ireland) +- **Compute Backend**: AWS Batch +- **Container Technology**: Docker with Wave optimization +- **Storage**: S3 for work directory and data buckets +- **Networking**: Managed by Seqera Platform forge mode +- **Cost Optimization**: SPOT instances for all environments diff --git a/pulumi/seqera_platform/shared/seqerakit/README.md b/pulumi/seqera_platform/shared/seqerakit/README.md new file mode 100644 index 00000000..7e6514f0 --- /dev/null +++ b/pulumi/seqera_platform/shared/seqerakit/README.md @@ -0,0 +1,210 @@ +# nf-core megatest seqerakit + +Contains the seqerakit configurations for the three core compute environments used in nf-core megatests on the Seqera Platform. + +## Quick Start + +1. Install seqerakit: `pip install seqerakit` +2. Install direnv: `brew install direnv` +3. Allow environment loading: `direnv allow` +4. Deploy compute environments: + ```bash + seqerakit aws_ireland_fusionv2_nvme_cpu_current.yml + seqerakit aws_ireland_fusionv2_nvme_cpu_arm_current.yml + seqerakit aws_ireland_fusionv2_nvme_gpu_current.yml + ``` + +## Architecture + +### Three Core Compute Environments + +This repository manages **three compute environments** on AWS Batch, all with fusion snapshots enabled: + +#### 1. **CPU Environment** (`aws_ireland_fusionv2_nvme_cpu`) + +- **Instance Types**: `c6id`, `m6id`, `r6id` (Intel x86_64 with NVMe storage) +- **Features**: Fusion v2, Wave, NVMe storage, **snapshots enabled** +- **Provisioning**: SPOT instances +- **Max CPUs**: 500 +- **Use Case**: Standard CPU-intensive workflows + +#### 2. **ARM Environment** (`aws_ireland_fusionv2_nvme_cpu_ARM_snapshots`) + +- **Instance Types**: `m6gd`, `r6gd`, `c6gd` (ARM Graviton with NVMe storage) +- **Features**: Fusion v2, Wave, NVMe storage, **snapshots enabled** +- **Provisioning**: SPOT instances +- **Max CPUs**: 1000 +- **Use Case**: ARM-optimized workflows and cost optimization + +#### 3. **GPU Environment** (`aws_ireland_fusionv2_nvme_gpu_snapshots`) + +- **Instance Types**: `g4dn`, `g5` (GPU) + `c6id`, `m6id`, `r6id` (CPU fallback) +- **Features**: GPU enabled, Fusion v2, Wave, NVMe storage, **snapshots enabled** +- **Provisioning**: SPOT instances +- **Max CPUs**: 500 +- **Use Case**: GPU-accelerated workflows (ML, bioinformatics tools) + +### Common Configuration + +All environments share these settings: + +- **Type**: aws-batch +- **Region**: eu-west-1 (Ireland) +- **Provisioning**: SPOT instances +- **Wave**: Enabled for container optimization +- **Fusion v2**: Enabled for high-performance I/O +- **NVMe Storage**: Enabled for fast local storage +- **Snapshots**: **Enabled** for all environments +- **Wait State**: AVAILABLE +- **Overwrite**: Enabled + +## Snapshots Configuration + +All three environments have fusion snapshots enabled using the seqerakit `fusionSnapshots` field: + +```json +{ + "fusionSnapshots": true, + "fusion2Enabled": true, + "waveEnabled": true, + "nvnmeStorageEnabled": true, + "nextflowConfig": "aws.batch.maxSpotAttempts=5\nprocess {\n maxRetries = 2\n errorStrategy = { task.exitStatus in ((130..145) + 104 + 175) ? 'retry' : 'terminate' }\n}\n" +} +``` + +This approach keeps snapshots configuration separate from Nextflow configuration, making it cleaner and more maintainable. + +## Seqerakit Deployment + +### Why Seqerakit? + +We use seqerakit for Infrastructure as Code management of compute environments because: + +- **Native snapshots support**: Supports the `fusionSnapshots` field directly +- **Clean configuration**: No need to embed snapshots in `nextflowConfig` +- **GitOps workflow**: Infrastructure managed through version control +- **Validation**: Built-in `--dryrun` support for testing configurations + +### Deployment Commands + +```bash +# Deploy individual environments +seqerakit aws_ireland_fusionv2_nvme_cpu_current.yml +seqerakit aws_ireland_fusionv2_nvme_cpu_arm_current.yml +seqerakit aws_ireland_fusionv2_nvme_gpu_current.yml + +# Validate configurations (dry run) +seqerakit aws_ireland_fusionv2_nvme_cpu_current.yml --dryrun +seqerakit aws_ireland_fusionv2_nvme_cpu_arm_current.yml --dryrun +seqerakit aws_ireland_fusionv2_nvme_gpu_current.yml --dryrun + +# Delete environments +seqerakit aws_ireland_fusionv2_nvme_cpu_current.yml --delete +seqerakit aws_ireland_fusionv2_nvme_cpu_arm_current.yml --delete +seqerakit aws_ireland_fusionv2_nvme_gpu_current.yml --delete +``` + +## GitOps Workflow + +This repository implements GitOps integrated with the main Pulumi AWSMegatests project: + +- **Pulumi Integration**: Compute environment deployment is managed through the parent Pulumi project +- **Automated Secrets**: Compute environment IDs and credentials automatically pushed to GitHub secrets +- **1Password Integration**: Secure credential management with `.envrc` and Pulumi 1Password provider +- **Infrastructure as Code**: All environments managed through version control + +## Infrastructure Files + +### Current Production Files + +- `aws_ireland_fusionv2_nvme_cpu_current.yml` → `current-env-cpu.json` +- `aws_ireland_fusionv2_nvme_cpu_arm_current.yml` → `current-env-cpu-arm.json` +- `aws_ireland_fusionv2_nvme_gpu_current.yml` → `current-env-gpu.json` + +### Configuration Structure + +Each YAML file references an exported JSON configuration: + +```yaml +compute-envs: + - name: "environment_name" + workspace: "$ORGANIZATION_NAME/$WORKSPACE_NAME" + credentials: "$AWS_CREDENTIALS_NAME" + wait: "AVAILABLE" + file-path: "./current-env-[type].json" + overwrite: True +``` + +### JSON Configuration Structure + +Each JSON file contains the complete compute environment configuration: + +```json +{ + "discriminator": "aws-batch", + "region": "eu-west-1", + "executionRole": "arn:aws:iam::...:role/TowerForge-...-ExecutionRole", + "headJobRole": "arn:aws:iam::...:role/TowerForge-...-FargateRole", + "workDir": "s3://nf-core-awsmegatests", + "headJobCpus": 4, + "headJobMemoryMb": 16384, + "waveEnabled": true, + "fusion2Enabled": true, + "nvnmeStorageEnabled": true, + "fusionSnapshots": true, + "nextflowConfig": "aws.batch.maxSpotAttempts=5\nprocess {\n maxRetries = 2\n errorStrategy = { task.exitStatus in ((130..145) + 104 + 175) ? 'retry' : 'terminate' }\n}\n", + "forge": { + "type": "SPOT", + "minCpus": 0, + "maxCpus": 500, + "gpuEnabled": false, + "instanceTypes": ["c6id", "m6id", "r6id"], + "allowBuckets": [ + "s3://ngi-igenomes", + "s3://nf-core-awsmegatests", + "s3://annotation-cache/" + ], + "fargateHeadEnabled": true + } +} +``` + +## Environment Variables + +The `.envrc` file defines key configuration variables: + +```bash +export ORGANIZATION_NAME="nf-core" +export WORKSPACE_NAME="AWSmegatests" +export AWS_CREDENTIALS_NAME="tower-awstest" +export AWS_REGION="eu-west-1" +export AWS_WORK_DIR="s3://nf-core-awsmegatests" +export AWS_COMPUTE_ENV_ALLOWED_BUCKETS="s3://ngi-igenomes,s3://annotation-cache" +``` + +## Current Environment Status + +All three compute environments are successfully deployed with fusion snapshots enabled: + +✅ **CPU Environment**: Standard x86_64 instances with fusion snapshots +✅ **ARM Environment**: ARM Graviton instances with fusion snapshots +✅ **GPU Environment**: GPU + CPU instances with fusion snapshots + +## Environment IDs + +For reference, the current environment IDs are: + +- CPU: `53ljSqphNKjm6jjmuB6T9b` → `aws_ireland_fusionv2_nvme_cpu` +- ARM: `7eC1zALvNGIaFXbybVohP1` → `aws_ireland_fusionv2_nvme_cpu_ARM_snapshots` +- GPU: `2SRyFNKtLVAJCxMhcZRMfx` → `aws_ireland_fusionv2_nvme_gpu_snapshots` + +## Technical Details + +- **Cloud Provider**: AWS +- **Region**: eu-west-1 (Ireland) +- **Compute Backend**: AWS Batch +- **Container Technology**: Docker with Wave optimization +- **Storage**: S3 for work directory, NVMe for fast local storage +- **Networking**: Managed by Seqera Platform forge mode +- **Cost Optimization**: SPOT instances for all environments +- **Snapshots**: Enabled for optimized container layer caching using seqerakit's native `fusionSnapshots` field diff --git a/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_cpu_arm_current.yml b/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_cpu_arm_current.yml new file mode 100644 index 00000000..2288cc70 --- /dev/null +++ b/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_cpu_arm_current.yml @@ -0,0 +1,7 @@ +compute-envs: + - name: "aws_ireland_fusionv2_nvme_cpu_ARM_snapshots" + workspace: "$ORGANIZATION_NAME/$WORKSPACE_NAME" + credentials: "$AWS_CREDENTIALS_NAME" + wait: "AVAILABLE" + file-path: "./current-env-cpu-arm.json" + overwrite: True diff --git a/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_cpu_current.yml b/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_cpu_current.yml new file mode 100644 index 00000000..8da31562 --- /dev/null +++ b/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_cpu_current.yml @@ -0,0 +1,7 @@ +compute-envs: + - name: "aws_ireland_fusionv2_nvme_cpu_snapshots" + workspace: "$ORGANIZATION_NAME/$WORKSPACE_NAME" + credentials: "$AWS_CREDENTIALS_NAME" + wait: "AVAILABLE" + file-path: "./current-env-cpu.json" + overwrite: True diff --git a/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_gpu_current.yml b/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_gpu_current.yml new file mode 100644 index 00000000..e129b20e --- /dev/null +++ b/pulumi/seqera_platform/shared/seqerakit/aws_ireland_fusionv2_nvme_gpu_current.yml @@ -0,0 +1,7 @@ +compute-envs: + - name: "aws_ireland_fusionv2_nvme_gpu_snapshots" + workspace: "$ORGANIZATION_NAME/$WORKSPACE_NAME" + credentials: "$AWS_CREDENTIALS_NAME" + wait: "AVAILABLE" + file-path: "./current-env-gpu.json" + overwrite: True diff --git a/pulumi/seqera_platform/shared/seqerakit/current-env-cpu-arm.json b/pulumi/seqera_platform/shared/seqerakit/current-env-cpu-arm.json new file mode 100644 index 00000000..1134d92f --- /dev/null +++ b/pulumi/seqera_platform/shared/seqerakit/current-env-cpu-arm.json @@ -0,0 +1,30 @@ +{ + "discriminator": "aws-batch", + "region": "eu-west-1", + "workDir": "s3://nf-core-awsmegatests", + "environment": [], + "waveEnabled": true, + "fusion2Enabled": true, + "nvnmeStorageEnabled": true, + "fusionSnapshots": true, + "forge": { + "type": "SPOT", + "minCpus": 0, + "maxCpus": 500, + "gpuEnabled": false, + "instanceTypes": ["m6gd", "r6gd", "c6gd"], + "subnets": [], + "securityGroups": [], + "disposeOnDeletion": true, + "allowBuckets": [ + "s3://ngi-igenomes", + "s3://nf-core-awsmegatests", + "s3://annotation-cache/" + ], + "efsCreate": false, + "ebsBootSize": 50, + "fargateHeadEnabled": true, + "arm64Enabled": true + }, + "labels": [] +} diff --git a/pulumi/seqera_platform/shared/seqerakit/current-env-cpu.json b/pulumi/seqera_platform/shared/seqerakit/current-env-cpu.json new file mode 100644 index 00000000..a0390ed3 --- /dev/null +++ b/pulumi/seqera_platform/shared/seqerakit/current-env-cpu.json @@ -0,0 +1,30 @@ +{ + "discriminator": "aws-batch", + "region": "eu-west-1", + "workDir": "s3://nf-core-awsmegatests", + "environment": [], + "waveEnabled": true, + "fusion2Enabled": true, + "nvnmeStorageEnabled": true, + "fusionSnapshots": true, + "forge": { + "type": "SPOT", + "minCpus": 0, + "maxCpus": 1000, + "gpuEnabled": false, + "instanceTypes": ["c6id", "m6id", "r6id"], + "subnets": [], + "securityGroups": [], + "disposeOnDeletion": true, + "allowBuckets": [ + "s3://ngi-igenomes", + "s3://nf-core-awsmegatests", + "s3://annotation-cache/" + ], + "efsCreate": false, + "ebsBootSize": 50, + "fargateHeadEnabled": true, + "arm64Enabled": false + }, + "labels": [] +} diff --git a/pulumi/seqera_platform/shared/seqerakit/current-env-gpu.json b/pulumi/seqera_platform/shared/seqerakit/current-env-gpu.json new file mode 100644 index 00000000..a4840f04 --- /dev/null +++ b/pulumi/seqera_platform/shared/seqerakit/current-env-gpu.json @@ -0,0 +1,30 @@ +{ + "discriminator": "aws-batch", + "region": "eu-west-1", + "workDir": "s3://nf-core-awsmegatests", + "environment": [], + "waveEnabled": true, + "fusion2Enabled": true, + "nvnmeStorageEnabled": true, + "fusionSnapshots": true, + "forge": { + "type": "SPOT", + "minCpus": 0, + "maxCpus": 500, + "gpuEnabled": true, + "instanceTypes": ["g4dn", "g5", "c6id", "m6id", "r6id"], + "subnets": [], + "securityGroups": [], + "disposeOnDeletion": true, + "allowBuckets": [ + "s3://ngi-igenomes", + "s3://nf-core-awsmegatests", + "s3://annotation-cache/" + ], + "efsCreate": false, + "dragenEnabled": false, + "ebsBootSize": 50, + "fargateHeadEnabled": true + }, + "labels": [] +} diff --git a/pulumi/seqera_platform/shared/utils/__init__.py b/pulumi/seqera_platform/shared/utils/__init__.py new file mode 100644 index 00000000..5687405f --- /dev/null +++ b/pulumi/seqera_platform/shared/utils/__init__.py @@ -0,0 +1,31 @@ +"""Utility functions and constants for AWS Megatests.""" + +from .constants import ( + AWS_REGION, + S3_BUCKET_NAME, + SEQERA_API_URL, + COMPUTE_ENV_NAMES, + TOWERFORGE_POLICY_NAMES, +) +from .logging import ( + log_info, + log_error, + log_warning, + log_step, + log_resource_creation, + log_resource_success, +) + +__all__ = [ + "AWS_REGION", + "S3_BUCKET_NAME", + "SEQERA_API_URL", + "COMPUTE_ENV_NAMES", + "TOWERFORGE_POLICY_NAMES", + "log_info", + "log_error", + "log_warning", + "log_step", + "log_resource_creation", + "log_resource_success", +] diff --git a/pulumi/seqera_platform/shared/utils/constants.py b/pulumi/seqera_platform/shared/utils/constants.py new file mode 100644 index 00000000..208f6d73 --- /dev/null +++ b/pulumi/seqera_platform/shared/utils/constants.py @@ -0,0 +1,151 @@ +"""Constants and configuration values for AWS Megatests infrastructure.""" + +import os +from pathlib import Path + +# Get the shared directory path (parent of utils) +SHARED_DIR = Path(__file__).parent.parent + +# AWS Configuration +AWS_REGION = "eu-west-1" +S3_BUCKET_NAME = "nf-core-awsmegatests" +S3_WORK_DIR = f"s3://{S3_BUCKET_NAME}" + +# Seqera Configuration +SEQERA_API_URL = "https://api.cloud.seqera.io" + +# Compute Environment Names +COMPUTE_ENV_NAMES = { + "cpu": "aws_ireland_fusionv2_nvme_cpu_snapshots", + "gpu": "aws_ireland_fusionv2_nvme_gpu_snapshots", + "arm": "aws_ireland_fusionv2_nvme_cpu_ARM_snapshots", +} + +# Compute Environment Descriptions +COMPUTE_ENV_DESCRIPTIONS = { + "cpu": "CPU compute environment with Fusion v2 and NVMe storage", + "gpu": "GPU compute environment with Fusion v2 and NVMe storage", + "arm": "ARM CPU compute environment with Fusion v2 and NVMe storage", +} + +# Configuration File Paths (absolute paths from shared directory) +CONFIG_FILES = { + "cpu": str(SHARED_DIR / "seqerakit" / "current-env-cpu.json"), + "gpu": str(SHARED_DIR / "seqerakit" / "current-env-gpu.json"), + "arm": str(SHARED_DIR / "seqerakit" / "current-env-cpu-arm.json"), +} + +# Nextflow configuration files for compute environments (absolute paths) +NEXTFLOW_CONFIG_FILES = { + "cpu": str(SHARED_DIR / "seqerakit" / "configs" / "nextflow-cpu.config"), + "gpu": str(SHARED_DIR / "seqerakit" / "configs" / "nextflow-gpu.config"), + "arm": str(SHARED_DIR / "seqerakit" / "configs" / "nextflow-arm.config"), +} + +# TowerForge Configuration +TOWERFORGE_USER_NAME = "TowerForge-AWSMegatests" +TOWERFORGE_POLICY_NAMES = { + "forge": "TowerForge-Forge-Policy", + "launch": "TowerForge-Launch-Policy", + "s3": "TowerForge-S3-Policy", +} + +TOWERFORGE_CREDENTIAL_NAME = "TowerForge-AWSMegatests-Dynamic" +TOWERFORGE_CREDENTIAL_DESCRIPTION = ( + "Dynamically created TowerForge credentials for AWS Megatests compute environments" +) + +# GitHub Configuration +GITHUB_ORG = "nf-core" +GITHUB_VARIABLE_NAMES = { + "cpu": "TOWER_COMPUTE_ENV_CPU", + "gpu": "TOWER_COMPUTE_ENV_GPU", + "arm": "TOWER_COMPUTE_ENV_ARM", + "workspace_id": "TOWER_WORKSPACE_ID", + "s3_bucket": "AWS_S3_BUCKET", +} + +# Timeout Configuration (in minutes) +TIMEOUTS = { + "seqera_credential_create": "5m", + "seqera_credential_update": "5m", + "seqera_credential_delete": "2m", + "compute_env_create": "10m", + "compute_env_update": "10m", + "compute_env_delete": "5m", +} + +# Default Compute Environment Settings +DEFAULT_COMPUTE_ENV_CONFIG = { + "region": AWS_REGION, + "workDir": S3_WORK_DIR, + "waveEnabled": True, + "fusion2Enabled": True, + "nvnmeStorageEnabled": True, + "fusionSnapshots": True, + "nextflowConfig": "", +} + +DEFAULT_FORGE_CONFIG = { + "type": "SPOT", + "minCpus": 0, + "maxCpus": 1000, + "gpuEnabled": False, + "instanceTypes": [], + "subnets": [], + "securityGroups": [], + "disposeOnDeletion": True, + "allowBuckets": [], + "efsCreate": False, + "ebsBootSize": 50, + "fargateHeadEnabled": True, + "arm64Enabled": False, +} + +# Error Messages +ERROR_MESSAGES = { + "missing_tower_token": ( + "TOWER_ACCESS_TOKEN is required for Seqera provider. " + "Please ensure it's set in your ESC environment with proper permissions: " + "WORKSPACE_ADMIN or COMPUTE_ENV_ADMIN scope." + ), + "seqera_provider_init_failed": ( + "Seqera provider initialization failed. " + "This usually indicates token permissions issues. " + "Ensure your TOWER_ACCESS_TOKEN has WORKSPACE_ADMIN or COMPUTE_ENV_ADMIN permissions." + ), + "config_file_not_found": "Configuration file not found: {}", + "invalid_json": "Invalid JSON in configuration file {}: {}", + "config_load_failed": "Failed to load configuration file {}: {}", + "invalid_workspace_id": "Invalid or missing workspace ID: {}", + "missing_compute_env_params": "Missing required parameters for compute environment {}", + "missing_config_args": "Configuration arguments are required for compute environment {}", + "compute_env_create_failed": ( + "Failed to create compute environment '{}'. " + "Common causes: " + "1. Seqera API token lacks required permissions (403 Forbidden) " + "2. Invalid credentials_id reference " + "3. Workspace access restrictions " + "4. Network connectivity issues" + ), + "credential_upload_failed": ( + "Failed to upload credentials to Seqera Platform. " + "Common causes: " + "1. Seqera provider not properly configured " + "2. Invalid workspace ID " + "3. Network connectivity issues to api.cloud.seqera.io " + "4. Invalid AWS credentials format" + ), +} + +# Required Environment Variables +REQUIRED_ENV_VARS = [ + "TOWER_ACCESS_TOKEN", + "TOWER_WORKSPACE_ID", + "GITHUB_TOKEN", +] + +# Optional Environment Variables with Defaults +DEFAULT_ENV_VARS = { + "TOWER_WORKSPACE_ID": "59994744926013", # Fallback workspace ID +} diff --git a/pulumi/seqera_platform/shared/utils/logging.py b/pulumi/seqera_platform/shared/utils/logging.py new file mode 100644 index 00000000..2cb342bd --- /dev/null +++ b/pulumi/seqera_platform/shared/utils/logging.py @@ -0,0 +1,68 @@ +"""Logging utilities for AWS Megatests infrastructure.""" + +import pulumi +from typing import Optional + + +def log_info(message: str, context: Optional[str] = None) -> None: + """Log an informational message with optional context. + + Args: + message: The message to log + context: Optional context prefix + """ + formatted_message = f"[{context}] {message}" if context else message + pulumi.log.info(formatted_message) + + +def log_error(message: str, context: Optional[str] = None) -> None: + """Log an error message with optional context. + + Args: + message: The error message to log + context: Optional context prefix + """ + formatted_message = f"[{context}] {message}" if context else message + pulumi.log.error(formatted_message) + + +def log_warning(message: str, context: Optional[str] = None) -> None: + """Log a warning message with optional context. + + Args: + message: The warning message to log + context: Optional context prefix + """ + formatted_message = f"[{context}] {message}" if context else message + pulumi.log.warn(formatted_message) + + +def log_step(step_number: int, step_name: str, description: str) -> None: + """Log a deployment step with consistent formatting. + + Args: + step_number: The step number + step_name: Short name for the step + description: Detailed description of what the step does + """ + log_info(f"Step {step_number}: {step_name} - {description}") + + +def log_resource_creation(resource_type: str, resource_name: str) -> None: + """Log resource creation with consistent formatting. + + Args: + resource_type: Type of resource being created + resource_name: Name of the resource + """ + log_info(f"Creating {resource_type}: {resource_name}", "Resource") + + +def log_resource_success(resource_type: str, resource_name: str) -> None: + """Log successful resource creation. + + Args: + resource_type: Type of resource that was created + resource_name: Name of the resource + """ + log_info(f"Successfully created {resource_type}: {resource_name}", "Resource")