Datasets:

AnimeshShaw
/

GenIaC-SecBench

+*.hcl
+.terraform
+*.tfstate
+*.tfstate.backup
+*.binary
+.DS_Store
+data/**/*
+*/.DS_Store
+*.env
+evaluation/terraform_config/.terraform
+*/__pycache__/
+retriever/aws-index/
+retriever/terraform-provider-aws/
+.vscode/
+evaluation/tmp/rego_config/**/*
+evaluation/tmp/terraform_config/**/*
+evaluation/tmp/*
+evaluation/misc/complete-dataset-measurement/terraform_config/*
+evaluation/misc/complete-dataset-measurement/rego_config/*
+evaluation/misc/ablation/terraform_config/*

human_reference_dataset/iac-eval/LICENSE.txt ADDED Viewed

	@@ -0,0 +1,21 @@

+MIT License
+Copyright (c) 2024 autoiac-project
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

human_reference_dataset/iac-eval/README.md ADDED Viewed

	@@ -0,0 +1,55 @@

+<p align="center">| <a href="https://huggingface.co/datasets/autoiac-project/iac-eval"><u>Dataset</u></a> | 🏆 <a href="https://huggingface.co/datasets/autoiac-project/iac-eval"><u>Leaderboard TBD</u></a> | 📖 <a href="https://www.cs-pk.com/neurips24-iac-eval.pdf"><u>NeurIPS 2024 Paper</u></a> |</p>
+# IaC-Eval---first edition
+IaC-Eval is a comprehensive framework for quantitatively evaluating the capabilities of large language models in cloud IaC code generation. Infrastructure-as-Code (IaC) is an important component of cloud computing, that allows the definition of cloud infrastructure in high-level programs. Our framework targets Terraform specifically for now. We leave integration of other IaC tools as future work.
+IaC-Eval also provides the first human-curated and challenging Infrastructure-as-Code (IaC) dataset containing 458 questions ranging from simple to difficult across various cloud services (targeting AWS for now), which can be found in our [HuggingFace repository](https://huggingface.co/datasets/autoiac-project/iac-eval).
+**We are actively developing and patching the project. However, as of now, IaC-Eval is not production-ready.**
+## Installation
+1. Install Terraform (also [install AWS CLI and setup credentials](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/aws-build#prerequisites))
+2. Install [Opa](https://www.openpolicyagent.org/docs/latest/#1-download-opa) (make sure to add opa to path).
+3. <sup>*</sup>Obtain the following LLM model inference API keys as appropriate, depending on which of our currently supported models you want to perform evaluation on:
+- [OpenAI API token](https://platform.openai.com/docs/quickstart/account-setup): for GPT-3.5-Turbo and GPT-4
+- [Google API token](https://ai.google.dev/gemini-api/docs/quickstart?lang=python#set-up-api-key): for Gemini-1.0-Pro
+- [Replicate API token](https://replicate.com/): for CodeLlama and WizardCoder variants
+<sup>*</sup> Our evaluation against MagiCoder was performed on a manually deployed AWS SageMaker instance inference endpoint. We provide more details on our setup script, see `evaluation/README.md`, if that is of interest.
+### Using the Evaluation Pipeline
+To access and utilize the evaluation pipeline, you need to switch to a specific branch of this repository and set up the environment. Follow these steps:
+1. Ensure you have the `main` branch of the project checked out.
+2. Install the Conda environment by running:
+   ```shell
+   conda env create -f environment.yml
+   ```
+3. Activate the newly created Conda environment named `iac-eval`:
+   ```shell
+   conda activate iac-eval
+   ```
+   Note: before `conda activate` you might need to do `conda init SHELL_NAME` on your preferred shell (e.g. `conda init bash`). If you run into problems initializing the shell session, try referring to [this GitHub issue](https://github.com/conda/conda/issues/13423#issuecomment-2113968807) for a fix.
+4. (Optional) Preconfigure the retriever database (if you would like to use the RAG strategy): refer to instructions in `retriever/README.md`.
+5. See instructions in `evaluation/README.md` for details on how to use the main pipeline: `eval.py`, and other scripts.
+Note: You can run `./setup.sh` to check if you have Terraform and OPA installed. It will also create and activate the necessary conda environment. The shell script assumes you are using `bash`, change `#!/bin/SHELL` to your preferred shell in the script.
+## Contributing
+We welcome all forms of contribution! IaC-Eval aims to quantitatively and comprehensively evaluate the IaC code generation capabilities of large language models. If you find bugs or have ideas, please share them via GitHub Issues. This includes contributions to IaC-Eval's dataset, whose format can be found in it's [HuggingFace repository](https://huggingface.co/datasets/autoiac-project/iac-eval).
+## Acknowledgments
+<https://github.com/openai/human-eval/tree/master>

human_reference_dataset/iac-eval/environment.yml ADDED Viewed

	@@ -0,0 +1,246 @@

+name: iac-eval
+channels:
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - bzip2=1.0.8=h5eee18b_5
+  - ca-certificates=2024.3.11=h06a4308_0
+  - ld_impl_linux-64=2.38=h1181459_1
+  - libffi=3.4.4=h6a678d5_0
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libuuid=1.41.5=h5eee18b_0
+  - ncurses=6.4=h6a678d5_0
+  - openssl=3.0.13=h7f8727e_0
+  - pip=23.3.1=py310h06a4308_0
+  - python=3.10.14=h955ad1f_0
+  - readline=8.2=h5eee18b_0
+  - setuptools=68.2.2=py310h06a4308_0
+  - sqlite=3.41.2=h5eee18b_0
+  - tk=8.6.12=h1ccaba5_0
+  - wheel=0.41.2=py310h06a4308_0
+  - xz=5.4.6=h5eee18b_0
+  - zlib=1.2.13=h5eee18b_0
+  - pip:
+      - aiohttp==3.9.5
+      - aiosignal==1.3.1
+      - annotated-types==0.6.0
+      - anyio==4.3.0
+      - asgiref==3.8.1
+      - async-timeout==4.0.3
+      - attrs==23.2.0
+      - azure-core==1.30.1
+      - azure-identity==1.16.0
+      - backoff==2.2.1
+      - bcrypt==4.1.3
+      - beautifulsoup4==4.12.3
+      - boto3==1.34.98
+      - botocore==1.34.98
+      - build==1.2.1
+      - cachetools==5.3.3
+      - certifi==2024.2.2
+      - cffi==1.16.0
+      - charset-normalizer==3.3.2
+      - chroma-hnswlib==0.7.3
+      - chromadb==0.4.24
+      - click==8.1.7
+      - cloudpickle==2.2.1
+      - code-bert-score==0.4.1
+      - coloredlogs==15.0.1
+      - contourpy==1.2.0
+      - cryptography==42.0.7
+      - cycler==0.12.1
+      - dataclasses-json==0.6.6
+      - datasets==2.19.2
+      - deprecated==1.2.14
+      - dill==0.3.8
+      - dirtyjson==1.0.8
+      - distro==1.9.0
+      - dnspython==2.6.1
+      - docker==7.0.0
+      - email-validator==2.1.1
+      - exceptiongroup==1.2.1
+      - fastapi==0.111.0
+      - fastapi-cli==0.0.3
+      - filelock==3.14.0
+      - flatbuffers==24.3.25
+      - fonttools==4.50.0
+      - frozenlist==1.4.1
+      - fsspec==2024.3.1
+      - google-ai-generativelanguage==0.6.2
+      - google-api-core==2.18.0
+      - google-api-python-client==2.127.0
+      - google-auth==2.29.0
+      - google-auth-httplib2==0.2.0
+      - google-generativeai==0.5.2
+      - google-pasta==0.2.0
+      - googleapis-common-protos==1.63.0
+      - greenlet==3.0.3
+      - grpcio==1.62.2
+      - grpcio-status==1.62.2
+      - h11==0.14.0
+      - httpcore==1.0.5
+      - httplib2==0.22.0
+      - httptools==0.6.1
+      - httpx==0.27.0
+      - huggingface-hub==0.23.0
+      - humanfriendly==10.0
+      - idna==3.6
+      - importlib-metadata==6.11.0
+      - importlib-resources==6.4.0
+      - jinja2==3.1.4
+      - jmespath==1.0.1
+      - joblib==1.4.2
+      - jsonpatch==1.33
+      - jsonpointer==2.4
+      - jsonschema==4.22.0
+      - jsonschema-specifications==2023.12.1
+      - kiwisolver==1.4.5
+      - kubernetes==29.0.0
+      - langchain==0.1.13
+      - langchain-community==0.0.38
+      - langchain-core==0.1.52
+      - langchain-openai==0.1.1
+      - langchain-text-splitters==0.0.1
+      - langsmith==0.1.57
+      - llama-index==0.10.34
+      - llama-index-agent-openai==0.2.3
+      - llama-index-cli==0.1.12
+      - llama-index-core==0.10.34
+      - llama-index-embeddings-azure-openai==0.1.9
+      - llama-index-embeddings-openai==0.1.9
+      - llama-index-indices-managed-llama-cloud==0.1.6
+      - llama-index-legacy==0.9.48
+      - llama-index-llms-azure-openai==0.1.7
+      - llama-index-llms-openai==0.1.16
+      - llama-index-multi-modal-llms-openai==0.1.5
+      - llama-index-program-openai==0.1.6
+      - llama-index-question-gen-openai==0.1.3
+      - llama-index-readers-file==0.1.20
+      - llama-index-readers-llama-parse==0.1.4
+      - llama-parse==0.4.2
+      - llamaindex-py-client==0.1.19
+      - markdown-it-py==3.0.0
+      - markupsafe==2.1.5
+      - marshmallow==3.21.2
+      - matplotlib==3.8.3
+      - mdurl==0.1.2
+      - mmh3==4.1.0
+      - monotonic==1.6
+      - mpmath==1.3.0
+      - msal==1.28.0
+      - msal-extensions==1.1.0
+      - multidict==6.0.5
+      - multiprocess==0.70.16
+      - mypy-extensions==1.0.0
+      - nest-asyncio==1.6.0
+      - networkx==3.3
+      - nltk==3.8.1
+      - numpy==1.26.4
+      - nvidia-cublas-cu12==12.1.3.1
+      - nvidia-cuda-cupti-cu12==12.1.105
+      - nvidia-cuda-nvrtc-cu12==12.1.105
+      - nvidia-cuda-runtime-cu12==12.1.105
+      - nvidia-cudnn-cu12==8.9.2.26
+      - nvidia-cufft-cu12==11.0.2.54
+      - nvidia-curand-cu12==10.3.2.106
+      - nvidia-cusolver-cu12==11.4.5.107
+      - nvidia-cusparse-cu12==12.1.0.106
+      - nvidia-nccl-cu12==2.20.5
+      - nvidia-nvjitlink-cu12==12.5.40
+      - nvidia-nvtx-cu12==12.1.105
+      - oauthlib==3.2.2
+      - onnxruntime==1.17.3
+      - openai==1.14.2
+      - opentelemetry-api==1.24.0
+      - opentelemetry-exporter-otlp-proto-common==1.24.0
+      - opentelemetry-exporter-otlp-proto-grpc==1.24.0
+      - opentelemetry-instrumentation==0.45b0
+      - opentelemetry-instrumentation-asgi==0.45b0
+      - opentelemetry-instrumentation-fastapi==0.45b0
+      - opentelemetry-proto==1.24.0
+      - opentelemetry-sdk==1.24.0
+      - opentelemetry-semantic-conventions==0.45b0
+      - opentelemetry-util-http==0.45b0
+      - orjson==3.10.3
+      - overrides==7.7.0
+      - packaging==23.2
+      - pandas==2.2.1
+      - pathos==0.3.2
+      - pillow==10.3.0
+      - platformdirs==4.2.1
+      - portalocker==2.8.2
+      - posthog==3.5.0
+      - pox==0.3.4
+      - ppft==1.7.6.8
+      - proto-plus==1.23.0
+      - protobuf==4.25.3
+      - psutil==5.9.8
+      - pulsar-client==3.5.0
+      - pyarrow==16.1.0
+      - pyarrow-hotfix==0.6
+      - pyasn1==0.5.1
+      - pyasn1-modules==0.3.0
+      - pycparser==2.22
+      - pydantic==2.7.1
+      - pydantic-core==2.18.2
+      - pygments==2.18.0
+      - pyjwt==2.8.0
+      - pyparsing==3.1.2
+      - pypdf==4.2.0
+      - pypika==0.48.9
+      - pyproject-hooks==1.1.0
+      - python-dateutil==2.9.0.post0
+      - python-dotenv==1.0.1
+      - python-multipart==0.0.9
+      - pytz==2024.1
+      - pyyaml==6.0.1
+      - referencing==0.35.1
+      - regex==2024.5.10
+      - replicate==0.25.1
+      - requests==2.32.3
+      - requests-oauthlib==2.0.0
+      - rich==13.7.1
+      - rpds-py==0.18.0
+      - rsa==4.9
+      - s3transfer==0.10.1
+      - safetensors==0.4.3
+      - sagemaker==2.218.1
+      - schema==0.7.7
+      - shellingham==1.5.4
+      - six==1.16.0
+      - smdebug-rulesconfig==1.0.1
+      - sniffio==1.3.1
+      - soupsieve==2.5
+      - sqlalchemy==2.0.30
+      - starlette==0.37.2
+      - striprtf==0.0.26
+      - sympy==1.12
+      - tblib==3.0.0
+      - tenacity==8.3.0
+      - tiktoken==0.6.0
+      - tokenizers==0.19.1
+      - tomli==2.0.1
+      - torch==2.3.0
+      - tqdm==4.66.4
+      - transformers==4.41.2
+      - triton==2.3.0
+      - typer==0.12.3
+      - typing-extensions==4.11.0
+      - typing-inspect==0.9.0
+      - tzdata==2024.1
+      - ujson==5.9.0
+      - uritemplate==4.1.1
+      - urllib3==2.2.1
+      - uvicorn==0.29.0
+      - uvloop==0.19.0
+      - watchfiles==0.21.0
+      - websocket-client==1.8.0
+      - websockets==12.0
+      - wrapt==1.16.0
+      - xxhash==3.4.1
+      - yarl==1.9.4
+      - zipp==3.18.1
+prefix: /home/ubuntu/miniconda3/envs/iac-eval

human_reference_dataset/iac-eval/evaluation/README.md ADDED Viewed

	@@ -0,0 +1,97 @@

+# Evaluation Setup
+## Usage guide
+All commands assume you are in the `evaluation` directory, and that you have activated the env:
+```bash
+conda activate iac-eval
+```
+Note: You can run `./setup.sh` for dependency check/setup.
+Please run the following scripts in order. Note that the main evaluation pipeline will generate the base results, that will be used by the other scripts (except for "Complete dataset measurements") to calculate certain metrics (e.g., Pass@K or LLM-judge).
+### Main evaluation pipeline
+#### 🚀 Quick Start Demo Run
+The following will default to a sample size of 1 per task, and perform the evaluation for WizardCoder33B (via Replicate) only, but only for a subset (2 rows) of our main dataset. Useful for testing the functionality of the benchmark.
+```bash
+python3 eval.py --config=config.json --quick-test
+```
+#### 🔥 Quick Start
+The following will default to a sample size of 1 per task, and perform the evaluation for WizardCoder33B (via Replicate) only. This will perform the evaluation on all rows in the dataset, which can take a significant amount of time.
+```bash
+python3 eval.py --config=config.json
+```
+#### Instructions
+This function takes in data from the `data/` folder, and the evaluation results are written to the respective model folders (e.g., `/tmp/gpt4/` stores the temporary evaluated results, while `/results/gpt4` stores the final results).
+Options for prompt-enhancement-strategy: COT, FSP, RAG, multi-turn
+Specify the number of samples per task and evaluation models list using command line options (`python3 eval.py --help` for help) or config file with `python3 eval.py --config=PATH_TO_FILE` to your desired value, and run the evaluation pipeline using:
+```bash
+python3 eval.py [command-options]
+```
+<!-- 💡 -->
+> :exclamation: **Note**
+> 1. If no other values are specified, the evaluation is defaulted to run on all models in the models list with a sample size of 20 per task.
+> 2. If the script unexpectedly stops (e.g., due to an unforeseen error), you can directly rerun the script. It will continue where it left off.
+### LLM judge pipeline
+This currently only applies the GPT4-single LLM-judge metric onto the evaluated datasets. Outputs in `../results/<model>/llm-judge-evaluation-metric/`
+```bash
+python3 llm-judge-eval.py gpt4 llm-single
+```
+#### Complete dataset measurements:
+This script outputs a few json files which give us the difficulty level and resource distributions.
+This script also reads from `data/` and outputs the same dataset but with filled in "Difficulty" and "Resource" values, in `misc/complete-dataset-measurement/complete-dataset`.
+```bash
+python3 misc/complete-dataset-measurement/complete-dataset-measurement.py
+```
+### Ablation calculation
+This script mainly calculates other metrics such as BLEU, score by difficulty, accuracy, etc.
+This reads from `data`, and `evaluation/results` and outputs an `input_composition_dict.json` that gives the files that will be processed, and also incrementally outputs an `output_composition_dict.json` that contains the results.
+This script assumes that the "Difficulty" and "Resource" columns of the dataset CSV file are properly filled; if this is not the case (e.g., new version of the dataset), please run the above script once, and move the resulting dataset CSV file manually to the `data` directory.
+```bash
+python3 misc/ablation/ablation-iac-eval-pipeline.py
+```
+#### Ablation LLM-judge related calculation:
+This script calculates LLM judge metrics given results from LLM judge in `../results/<model>/llm-judge-evaluation-metric/`.
+This reads from `../results/<model>/llm-judge-evaluation-metric/`, and outputs an `input_composition_dict.json` that gives the files that will be processed, and also incrementally outputs an `output_composition_dict.json` that contains the results.
+```bash
+python3 misc/ablation-judge/ablation-llm-judge.py
+```
+#### Ablation Pass@k related calculation:
+This script calculates Pass@k metrics given results in `../results`.
+This reads from `../results/`, and outputs an `input_composition_dict.json` that gives the files that will be processed, and also incrementally outputs an `pass-k-output_composition_dict.json` that contains the results.
+Make sure that the value of the command line option `n` is set to below or equal to the number of evaluation samples that exist in `../results`, e.g., if GPT-4 had 2 generated samples, then `n<=2`.
+```bash
+python3 misc/ablation-multiple-sample/ablation-multiple-sample.py -n 20 # N refers to the number of samples.
+```
+### Sagemaker usage (for MagiCoder-S-CL-7B evaluation)
+This deploys a AWS SageMaker instance inference model and endpoint, running MagiCoder-S-CL-7B, that we can then later call for evaluation.
+```bash
+python3 misc/sagemaker_setup/sagemaker-magicoder-s-cl-7b-deploy.py
+```

human_reference_dataset/iac-eval/evaluation/config.json ADDED Viewed

	@@ -0,0 +1,4 @@

+{
+  "samples": 1,
+  "models": ["Wizardcoder33b"]
+}

human_reference_dataset/iac-eval/evaluation/data.py ADDED Viewed

	@@ -0,0 +1,19 @@

+from datasets import load_dataset
+import pandas as pd
+import os
+def import_dataset(quick_test=False):
+    # Load the entire dataset
+    if not quick_test:
+        dataset = load_dataset("autoiac-project/iac-eval", split="test")
+    else:
+        dataset = load_dataset("autoiac-project/iac-eval", "quick_test", split="test")
+    # convert the entire dataset to a Pandas DataFrame
+    df = dataset.to_pandas()
+    # Create directory if not exists:
+    os.makedirs("../data/complete", exist_ok=True)
+    # Save the dataset to a CSV file
+    df.to_csv("../data/complete/data.csv", index=False)

human_reference_dataset/iac-eval/evaluation/eval.py ADDED Viewed

	@@ -0,0 +1,1000 @@

+import os
+import shutil
+import csv
+import sys
+from pathlib import Path
+from openai import OpenAI
+import numpy as np
+import pandas as pd
+import subprocess
+import json
+import getpass
+import uuid
+import re
+import time
+import logging
+import models
+import prompt_templates
+import data
+import math
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "retriever"))
+)
+import llama_index_retriever
+import click
+from typing import List, Tuple
+DEFAULT_LOG_FILE = "logs/eval.log"
+DELIMITERS = ["```hcl", "```json", "```HCL", "```Terraform", "```terraform", "```"]
+# ``` needs to be in the end, as it is a final "else" case
+# Default configurations if not specified
+NUM_SAMPLES_PER_TASK = 20  # n
+EVAL_MODELS = [
+    "gpt3.5",
+    "gpt4",
+    "gemini-1.0-pro",
+    "codellama-7b",
+    "codellama-13b",
+    "codellama-34b",
+    "Magicoder_S_CL_7B",
+    "Wizardcoder33b",
+    "Wizardcoder34b",
+]  # default to all available models
+PROMPT_ENHANCEMENT_STRATS = ["RAG", "COT", "FSP", "multi-turn", ""]
+class CustomFormatter(logging.Formatter):
+    # https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
+    grey = "\x1b[38;20m"
+    cyan = "\x1b[36;20m"
+    blue = "\x1b[34:20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = (
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    )
+    FORMATS = {
+        logging.DEBUG: cyan + format + reset,
+        logging.INFO: blue + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset,
+    }
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+logger = logging.getLogger("iac-eval")  # get logger
+# https://stackoverflow.com/questions/12507206/how-to-completely-traverse-a-complex-dictionary-of-unknown-depth
+def dict_generator(indict, pre=None):
+    pre = pre[:] if pre else []
+    if isinstance(indict, dict):
+        for key, value in indict.items():
+            if isinstance(value, dict):
+                for d in dict_generator(value, pre + [key]):
+                    yield d
+            elif isinstance(value, list) or isinstance(value, tuple):
+                for v in value:
+                    for d in dict_generator(v, pre + [key]):
+                        yield d
+            else:
+                yield pre + [key, value]
+    else:
+        yield pre + [indict]
+def rag_knowledge(Retriever, query):
+    knowledge = ""
+    questions = Retriever.generate_prompt_for_index(query)
+    context = Retriever.query_documents(questions)
+    for i, c in enumerate(context):
+        if i >= 4:
+            break
+        knowledge += f"Context {i}: \n"
+        knowledge += c
+    return knowledge
+# remove unwanted text for output
+def remove_unwanted_characters(text):
+    if text is None:
+        return None
+    ansi_escape = re.compile(r"\x1B[@-_][0-?]*[ -/]*[@-~]")
+    text = ansi_escape.sub("", text)
+    unwanted_pattern = re.compile(r"[^\x00-\x7F]+")  # Non-ASCII characters
+    text = unwanted_pattern.sub("", text)
+    return text
+def delete_all_files_in_directory(folder):
+    if not os.path.isdir(folder):
+        return
+    for filename in os.listdir(folder):
+        file_path = os.path.join(folder, filename)
+        try:
+            if os.path.isfile(file_path) or os.path.islink(file_path):
+                os.unlink(file_path)
+            elif os.path.isdir(file_path):
+                shutil.rmtree(file_path)
+        except Exception as e:
+            print("Failed to delete %s. Reason: %s" % (file_path, e))
+# setup aws credential
+def set_aws_credentials():
+    # prompt the user for AWS credentials
+    # set the credentials as environment variables
+    if "AWS_ACCESS_KEY_ID" not in os.environ:
+        aws_access_key_id = input("Enter AWS Access Key ID: ")
+        os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key_id
+    if "AWS_SECRET_ACCESS_KEY" not in os.environ:
+        aws_secret_access_key = getpass.getpass("Enter AWS Secret Access Key: ")
+        os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_access_key
+    if "AWS_ROLE_NAME" not in os.environ:
+        aws_role_name = input("Enter AWS Role Name to be used (press Enter to use the default value 'default'): " or "default")
+        os.environ["AWS_ROLE_NAME"] = aws_role_name
+def set_google_credentials():
+    # For gemini:
+    if "GOOGLE_API_KEY" not in os.environ:
+        gemini_secret_access_key = getpass.getpass(
+            "Enter Google API Key (for Gemini): "
+        )
+        os.environ["GOOGLE_API_KEY"] = gemini_secret_access_key
+def set_replicate_credentials():
+    # For Replicate:
+    if "REPLICATE_API_TOKEN" not in os.environ:
+        replicate_secret_access_key = getpass.getpass(
+            "Enter Replicate API Key (for various models): "
+        )
+        os.environ["REPLICATE_API_TOKEN"] = replicate_secret_access_key
+def set_huggingface_credentials():
+    # For gemini:
+    if "HF_API_TOKEN" not in os.environ:
+        hf_secret_access_key = getpass.getpass(
+            "Enter Huggingface API Token (for use of various models): "
+        )
+        os.environ["HF_API_TOKEN"] = hf_secret_access_key
+# split the code for results
+def separate_answer_and_code(text, delimiters=["```hcl"]):
+    for delimiter in delimiters:
+        # split the text at the point where the code block starts
+        parts = text.split(delimiter)
+        # print(len(parts))
+        if len(parts) < 2:
+            # delimiter not found, return original text and empty code
+            answer = text.strip()
+            code = ""
+            continue
+        # the first part is the answer
+        answer = parts[0].strip()
+        # the second part is the code, re-adding the "```hcl" and removing the trailing "```"
+        code = parts[1].strip()
+        code = code.rsplit("```", 1)[0].strip()
+        if code != "":
+            return answer, code
+    return answer, code
+# find each subdirectory
+def list_all_subdirectories_and_eval(
+    data_dir, base_eval_dir, final_eval_dir, PROMPT_ENHANCEMENT_STRAT, Retriever
+):
+    for path, _, _ in os.walk(data_dir):
+        subdir = path.removeprefix(
+            data_dir + "/"
+        )  # FIX?: temp fix for now, the way to go is prob using pathlib
+        create_evaluation_directories(subdir, base_eval_dir=base_eval_dir, final_eval_dir=final_eval_dir)
+        file_dir = os.listdir(path)
+        for file in file_dir:
+            if file.endswith(".csv"):
+                file_path = os.path.abspath(os.path.join(path, file))
+                print(file_path)
+                # Perform evaluation:
+                for model in EVAL_MODELS:
+                    # Note: Do not overwrite existing files, and do not evaluate if file exists already
+                    eval_filepath, final_file_path, file_exists, NUM_EXISTING_SAMPLES = (
+                        copy_csv_to_evaluation(
+                            file_path,
+                            subdir,
+                            model,
+                            PROMPT_ENHANCEMENT_STRAT,
+                            base_eval_dir=base_eval_dir,
+                            final_eval_dir=final_eval_dir,
+                        )
+                    )
+                    if file_exists:
+                        continue
+                    read_models(
+                        model,
+                        PROMPT_ENHANCEMENT_STRAT,
+                        NUM_EXISTING_SAMPLES,
+                        eval_filepath,
+                        final_file_path,
+                        Retriever,
+                    )
+# function to create evaluation directories based on a given subdirectory
+def create_evaluation_directories(subdir, base_eval_dir="evaluation/tmp", final_eval_dir="results"):
+    for model in EVAL_MODELS:
+        # construct the new directory path
+        eval_dir_path = os.path.join(base_eval_dir, model, subdir)
+        final_eval_dir_path = os.path.join(final_eval_dir, model, subdir)
+        # create the directory if it does not exist
+        os.makedirs(eval_dir_path, exist_ok=True)
+        os.makedirs(final_eval_dir_path, exist_ok=True)
+def make_column_names_unique(df):
+    cols = pd.Series(df.columns)
+    for dup in cols[cols.duplicated()].unique():
+        cols[cols[cols == dup].index.values.tolist()] = [
+            dup + "." + str(i) if i != 0 else dup for i in range(sum(cols == dup))
+        ]
+    df.columns = cols
+    # print(cols.tolist())
+    # while True:
+    #     x=1
+    return df
+def fix_duplicate_columns(dest_file_path):
+    """
+    Deduplicated csv is written to original file path
+    """
+    # FIX?: this is ignoring the header in the original file and manually extracting the first line???
+    df = pd.read_csv(dest_file_path, header=None)
+    new_header = df.iloc[0]
+    df = df[1:]
+    df.columns = new_header
+    df.reset_index(drop=True, inplace=True)
+    if not df.columns.is_unique:  # First check if there are duplicate columns:
+        df = make_column_names_unique(df)
+        df.to_csv(dest_file_path, index=False, encoding="utf-8")
+        logger.info(
+            f"Evaluation file {dest_file_path} had duplicate columns, deduplicated them."
+        )
+def determine_eval_samples(dest_file_path):
+    """
+    Determine the number of samples currently present in a given evaluated dataset file.
+    Also determines columns to remove (i.e., which are empty, because a previous evaluation run was not complete, which can only occur if copy_csv was successful but read_models was interrupted)
+    Note: this is a variant of the same function used in llm-judge-eval.py
+    """
+    drop_cols = []
+    df = pd.read_csv(dest_file_path, header=None)
+    new_header = df.iloc[0]
+    df = df[1:]
+    df.columns = new_header
+    df.reset_index(drop=True, inplace=True)
+    num_samples = 0
+    for col in df.columns:
+        if "LLM Correct?" in col:
+            if not pd.isnull(
+                df[col].iloc[0]
+            ):  # this means that the column is not empty (i.e., prev evaluation passed through successfully)
+                num_samples += 1
+            else:
+                cols_to_drop = [
+                    "LLM Output #",
+                    "LLM Plannable? #",
+                    "LLM Correct? #",
+                    "LLM Plan Phase Error #",
+                    "LLM OPA match phase Error #",
+                    "LLM Notes #",
+                ]  # drop all columns for this sample
+                drop_cols.extend(
+                    [col_base + str(col.split("#")[1]) for col_base in cols_to_drop]
+                )
+    return num_samples, drop_cols
+# function to copy CSV to the new evaluation directory and rename it
+def copy_csv_to_evaluation(
+    src_file_path,
+    subdir,
+    model,
+    PROMPT_ENHANCEMENT_STRAT,
+    base_eval_dir="evaluation/tmp",
+    final_eval_dir="results",
+):
+    # FIX?: this should be passed in as Path? if we are using Path, we should use it outside instead of os.
+    # dataset_file_name = os.path.basename(src_file_path)
+    dataset_file_name = Path(
+        src_file_path
+    ).stem  # https://stackoverflow.com/questions/678236/how-do-i-get-the-filename-without-the-extension-from-a-path-in-python
+    eval_filename_prefix = "evaluation-dataset-for-{}".format(dataset_file_name)
+    # eval_filename = eval_file_name_prefix + "-" + dataset_file_name
+    eval_filename = (
+        "{}-{}.csv".format(eval_filename_prefix, PROMPT_ENHANCEMENT_STRAT)
+        if PROMPT_ENHANCEMENT_STRAT != ""
+        else "{}.csv".format(eval_filename_prefix)
+    )
+    dest_file_path = os.path.join(base_eval_dir, model, subdir, eval_filename)
+    final_file_path = os.path.join(final_eval_dir, model, subdir, eval_filename)
+    df = pd.read_csv(src_file_path, header=None)
+    # set the third row as the header
+    # FIX?: if this is the case for every file, why are they even saved?
+    new_header = df.iloc[0]
+    df = df[1:]
+    df.columns = new_header
+    # reset the index of the DataFrame
+    df.reset_index(drop=True, inplace=True)
+    num_eval_samples = 0  # current eval samples in the evaluated dataset file.
+    # Skip if file already exists and contains enough samples:
+    if os.path.isfile(dest_file_path):
+        fix_duplicate_columns(dest_file_path)
+        num_eval_samples, drop_cols = determine_eval_samples(dest_file_path)
+        if num_eval_samples >= NUM_SAMPLES_PER_TASK:
+            logger.info(
+                f"Skipping evaluation for {dest_file_path} as file already exists, and it has enough samples."
+            )
+            return dest_file_path, None, True, num_eval_samples
+        logger.info(
+            f"Evaluation file {dest_file_path} already exists, but has not enough samples (required: {NUM_SAMPLES_PER_TASK}, existing: {num_eval_samples}), will continue evaluation."
+        )
+        # Replace df with existing evaluated dataset file df:
+        # FIX?: this is ignoring the header in the original file and manually extracting the first line??? why?????
+        df = pd.read_csv(dest_file_path, header=None)
+        new_header = df.iloc[0]
+        df = df[1:]
+        df.columns = new_header
+        # reset the index of the DataFrame
+        df.reset_index(drop=True, inplace=True)
+        if len(drop_cols) > 0:
+            df.drop(columns=drop_cols, inplace=True)
+    logger.info(f"Performing evaluation on {dest_file_path}.")
+    # read the rest of the file starting from the fourth row without a header
+    # add new columns only to df
+    for i in range(num_eval_samples, NUM_SAMPLES_PER_TASK):
+        for col_base in [
+            "LLM Output #",
+            "LLM Plannable? #",
+            "LLM Correct? #",
+            "LLM Plan Phase Error #",
+            "LLM OPA match phase Error #",
+            "LLM Notes #",
+        ]:
+            df[col_base + str(i)] = ""
+    df.to_csv(dest_file_path, index=False, encoding="utf-8")
+    return dest_file_path, final_file_path, False, num_eval_samples
+# gpt result
+def read_models(
+    model,
+    PROMPT_ENHANCEMENT_STRAT,
+    NUM_EXISTING_SAMPLES,
+    eval_filepath,
+    final_filepath,
+    Retriever,
+):
+    # read the first four lines to determine the header
+    uuid_1 = get_unique_uuid()
+    with open("prompt-templates/system-prompt.txt", "r") as file2:
+        preprompt = file2.read()
+    # Read from evaluation dataset file:
+    df = pd.read_csv(eval_filepath, header=0)
+    for index, row in df.iterrows():
+        # iterate every row
+        # find specific column
+        model_evaluation(
+            row,
+            preprompt,
+            df,
+            index,
+            model,
+            PROMPT_ENHANCEMENT_STRAT,
+            NUM_EXISTING_SAMPLES,
+            Retriever,
+            uuid_1,
+        )
+    df.to_csv(eval_filepath, index=False, encoding="utf-8")
+    df.to_csv(final_filepath, index=False, encoding="utf-8")
+    logger.info(f"Finished evaluation for {model}")
+def get_plan_result_template():
+    return {
+        "terraform_plan_success": False,
+        "terraform_output": "No output",
+        "terraform_plan_error": "No error",
+        "opa_evaluation_result": "No opa_result",
+        "opa_evaluation_error": "None",
+        "notes": "",
+    }
+def empty_code_error():
+    logger.info("Plan considered failed since answer contains no code output.")
+    plan_result = get_plan_result_template()
+    plan_result["terraform_plan_success"] = False
+    plan_result["terraform_output"] = "No output"
+    plan_result["terraform_plan_error"] = "Empty code"
+    plan_result["notes"] = (
+        "Terraform plan considered failed since answer contains no code output."
+    )
+    return plan_result
+def prompt_enhancements(prompt, PROMPT_ENHANCEMENT_STRAT, Retriever):
+    if PROMPT_ENHANCEMENT_STRAT == "RAG":
+        knowledge = rag_knowledge(Retriever, prompt)
+        prompt = prompt_templates.RAG_prompt(knowledge, prompt)
+    elif PROMPT_ENHANCEMENT_STRAT == "COT":
+        prompt = prompt_templates.CoT_prompt(prompt)
+    elif PROMPT_ENHANCEMENT_STRAT == "FSP":
+        prompt = prompt_templates.FSP_prompt(prompt)
+    else:
+        prompt = "Here is the actual prompt: " + prompt
+    return prompt
+def model_evaluation(
+    row,
+    preprompt,
+    df,
+    index,
+    model,
+    PROMPT_ENHANCEMENT_STRAT,
+    NUM_EXISTING_SAMPLES,
+    Retriever,
+    uuid_1,
+):
+    """
+    Note: Multi-turn implies 2 turns only
+    """
+    prompt = row["Prompt"]
+    # Skip empty rows
+    if isinstance(row["Prompt"], float):
+        if math.isnan(row["Prompt"]):
+            return
+    prompt = prompt_enhancements(prompt, PROMPT_ENHANCEMENT_STRAT, Retriever)
+    policy_file = row["Rego intent"]
+    num_correct = 0
+    logger.info(f"Begin testing model: {model}")
+    for i in range(NUM_EXISTING_SAMPLES, NUM_SAMPLES_PER_TASK):
+        multi_turn_count = 1
+        while True:
+            is_empty_code = False
+            logger.info(f"Sample {i} for model {model}")
+            logger.info(f"Preprompt: {preprompt}")
+            logger.info(f"Prompt: {prompt}")
+            if model == "gpt4":
+                text = models.GPT4(preprompt, prompt, gpt_client)
+            elif model == "gpt3.5":
+                text = models.GPT3_5(preprompt, prompt, gpt_client)
+            elif model == "gemini-1.0-pro":
+                text = models.gemini(preprompt, prompt)
+            elif model == "codellama-13b":
+                text = models.Codellama13b(preprompt, prompt)
+            elif model == "codellama-7b":
+                text = models.Codellama7b(preprompt, prompt)
+            elif model == "codellama-34b":
+                text = models.Codellama34b(preprompt, prompt)
+            elif model == "Magicoder_S_CL_7B":
+                text = models.Magicoder_S_CL_7B(preprompt, prompt)
+            elif model == "Wizardcoder33b":
+                text = models.Wizardcoder33b(preprompt, prompt)
+            elif model == "Wizardcoder34b":
+                text = models.Wizardcoder34b(preprompt, prompt)
+            logger.info(f"Model raw output: {text}")
+            answer, code = separate_answer_and_code(text, DELIMITERS)
+            if code == "":
+                logger.error("Error: Answer contains no code, skipping eval_pipeline.")
+                is_empty_code = True
+            logger.info("Answer is: {}".format(answer))
+            logger.info("Code is: {}".format(code))
+            df.at[index, "LLM Output #" + str(i)] = text
+            if is_empty_code:
+                x = empty_code_error()
+            else:
+                x = eval_pipeline(code, policy_file, prompt, uuid_1)
+            df.at[index, "LLM Plannable? #" + str(i)] = x["terraform_plan_success"]
+            df.at[index, "LLM Correct? #" + str(i)] = x["opa_evaluation_result"]
+            df.at[index, "LLM Plan Phase Error #" + str(i)] = x["terraform_plan_error"]
+            df.at[index, "LLM OPA match phase Error #" + str(i)] = x[
+                "opa_evaluation_error"
+            ]
+            df.at[index, "LLM Notes #" + str(i)] = x["notes"]
+            logging.info("Plan Result Summary:")
+            for key, value in x.items():
+                logging.info(f"{key}: {value}")
+            if x["opa_evaluation_result"] == "success":
+                num_correct += 1
+                break
+            elif PROMPT_ENHANCEMENT_STRAT == "multi-turn":
+                if multi_turn_count == 2:  # only do 2 turns
+                    break
+                multi_turn_count += 1
+                if code == "":
+                    continue
+                preprompt = prompt_templates.multi_turn_system_prompt()
+                if not x["terraform_plan_success"]:
+                    prompt = prompt_templates.multi_turn_plan_error_prompt(
+                        row["Prompt"], code, x["terraform_plan_error"]
+                    )
+                elif x["opa_evaluation_result"] == "Failure":
+                    prompt = prompt_templates.multi_turn_rego_error_prompt(
+                        row["Prompt"], code, policy_file, x["opa_evaluation_error"]
+                    )
+                continue
+            else:
+                break
+# used to modify main.tf
+def write_to_terraform(result, terraform_dir="./terraform_config"):
+    # define the path to the main.tf file
+    os.makedirs(terraform_dir, exist_ok=True)
+    terraform_file_path = terraform_dir + "/main.tf"
+    # open the file in write mode ('w') and write the result to it
+    # print("CWD", os.getcwd())
+    logger.debug("CWD: {}".format(os.getcwd()))
+    with open(terraform_file_path, "w+", encoding="utf-8", errors="ignore") as file:
+        file.write(result)
+    # print(f"Updated main.tf at {terraform_file_path}")
+    logger.info(f"Updated main.tf at {terraform_file_path}")
+# used for modify policy.rego
+def write_to_rego(policy_content, rego_policy_filepath):
+    # define the path to the policy.rego file
+    # rego_file_path = "./rego_config/policy.rego"
+    # ensure the rego_config directory exists
+    os.makedirs(os.path.dirname(rego_policy_filepath), exist_ok=True)
+    # open the file in write mode ('w') and write the policy content to it
+    with open(rego_policy_filepath, "w", encoding="utf-8", errors="ignore") as file:
+        file.write(policy_content)
+    logger.info(f"Updated policy.rego at {rego_policy_filepath}")
+def get_unique_uuid():
+    terraform_dir_prefix = "./tmp/terraform_config/"
+    uuid_1 = ""
+    while True:
+        uuid_1 = str(uuid.uuid4())
+        terraform_dir = terraform_dir_prefix + uuid_1
+        if os.path.isfile(terraform_dir):
+            continue
+        else:
+            break
+    return uuid_1
+def eval_pipeline(result, policy_file, prompt, uuid_1):
+    """
+    TF Plan -> OPA Rego
+    """
+    # object to store the results
+    plan_result = get_plan_result_template()
+    # Clear the terraform_config directory
+    # Generate unique filename suffix:
+    terraform_dir_prefix = "./tmp/terraform_config/"
+    terraform_dir = terraform_dir_prefix + uuid_1
+    delete_all_files_in_directory(terraform_dir)
+    # write result to main.tf
+    write_to_terraform(result, terraform_dir)
+    # run terraform plan and capture the output and errors
+    plan_file = "plan.out"
+    plan_output, plan_error, plan_success = run_terraform_plan(
+        terraform_dir, plan_file, prompt
+    )
+    # print("plan output: ", plan_output)
+    logger.info("plan_output: {}".format(plan_output))
+    # print("plan_error: ", plan_error)
+    logger.error("plan_error occurred: {}".format(plan_error), exc_info=True)
+    # print("plan_success: ", plan_success)
+    logger.debug("plan_success: {}".format(plan_success))
+    plan_output = remove_unwanted_characters(plan_output)
+    plan_error = remove_unwanted_characters(plan_error)
+    plan_result["terraform_plan_success"] = plan_success
+    plan_result["terraform_output"] = plan_output
+    plan_result["terraform_plan_error"] = plan_error
+    if plan_success:
+        # print("Plan succeeded.")
+        logger.info("Plan succeeded.")
+        # go to opa rego check
+        rego_dir = "./tmp/rego_config/" + uuid_1
+        rego_policy_filepath = rego_dir + "/policy.rego"
+        write_to_rego(policy_file, rego_policy_filepath)
+        generate_terraform_plan_json("plan.json", plan_file, terraform_dir)
+        tf_json_plan_filepath = os.path.join(terraform_dir, "plan.json")
+        # run OPA evaluation and capture the result
+        opa_result, opa_error = OPA_Rego_evaluation(
+            tf_json_plan_filepath, rego_policy_filepath
+        )
+        # print("OPA result: ", opa_result)
+        logger.info("OPA result: {}".format(opa_result))
+        # print("OPA current directory: ", os.getcwd())
+        # print("OPA error: ", opa_error)
+        logger.error("OPA error occurred: {}".format(opa_error), exc_info=True)
+        plan_result["opa_evaluation_result"] = opa_result
+        plan_result["opa_evaluation_error"] = opa_error
+    else:
+        # print("Plan failed.")
+        logger.info("Plan failed.")
+        plan_result["notes"] = "Terraform plan failed."
+    return plan_result
+def run_terraform_plan(terraform_directory, plan_file, prompt):
+    cur_dir = os.getcwd()
+    # change to the Terraform directory
+    os.chdir(terraform_directory)
+    # run init before plan
+    subprocess.run(["terraform", "init"], capture_output=True, text=True)
+    # run 'terraform plan'
+    # result = subprocess.run(["terraform", "plan"], capture_output=True, text=True)
+    result_returned = False
+    # generate Terraform plan with the -no-color flag
+    for i in range(2):  # try twice
+        try:
+            result = subprocess.run(
+                ["terraform", "plan", "-out", plan_file, "-no-color"],
+                capture_output=True,
+                text=True,
+                timeout=100,  # 5 minutes timeout (assume failed if timeout)
+            )
+            if "Inconsistent dependency lock file" in result.stderr:
+                subprocess.run(["terraform", "init"], capture_output=True, text=True)
+                time.sleep(10)
+                continue
+            result_returned = True
+            break
+        except Exception as e:
+            logging.error(
+                'Error occurred for prompt "{}": {}'.format(prompt, e), exc_info=True
+            )
+    # Return to parent directory
+    os.chdir(cur_dir)
+    if not result_returned:
+        return "Plan timed-out. No output", "Plan timed-out. No error", False
+    # check the exit code and return the output, error message, and success flag
+    success = result.returncode == 0
+    output = result.stdout if not success else "success"
+    error = result.stderr if not success else "No error"
+    return output, error, success
+def check_if_rego_v1(policy_file):
+    with open(policy_file, "r") as file:
+        lines = file.readlines()
+        for line in lines:
+            # if "package" in line:
+            if "import rego.v1" in line:
+                return True
+    return False
+def OPA_Rego_evaluation(plan_file, policy_file):
+    # print("opa current directory: ", os.getcwd())
+    # assumes the current working directory is correct
+    try:
+        is_rego_v1 = check_if_rego_v1(policy_file)
+        if is_rego_v1:
+            result = subprocess.run(
+                [
+                    "opa",
+                    "eval",
+                    "--v1-compatible",
+                    "-i",
+                    plan_file,
+                    "-d",
+                    policy_file,
+                    "data",
+                ],
+                capture_output=True,
+                text=True,
+            )
+        else:
+            result = subprocess.run(
+                [
+                    "opa",
+                    "eval",
+                    "-i",
+                    plan_file,
+                    "-d",
+                    policy_file,
+                    "data",
+                ],
+                capture_output=True,
+                text=True,
+            )
+    except Exception as e:
+        opa_result = "OPA exception occurred."
+        opa_error = "OPA exception occurred: {}".format(e)
+        return opa_result, opa_error
+    # check the exit code and return the result and error message
+    # success = result.returncode == 0
+    # key_val = next(iter( json.loads(result.stdout)["result"][0]["expressions"][0]["value"].items() ))
+    # get the first key-value pair: https://stackoverflow.com/a/39292086/13336187
+    # key_val = key_val[1]
+    # print(key_val)
+    results = [
+        i[-1]
+        for i in dict_generator(
+            json.loads(result.stdout)["result"][0]["expressions"][0]["value"]
+        )
+    ]
+    # print(results)
+    # print(key_val)
+    success = False if False in results else True
+    opa_result = "Success" if success else "Failure"
+    opa_error = "No error"
+    if not success:
+        opa_error = "Rule violation found. OPA complete output logged here: " + str(
+            json.loads(result.stdout)
+        )
+    # print("OPA error: ", opa_error)
+    return opa_result, opa_error
+def generate_terraform_plan_json(
+    output_json_file, plan_file="plan.out", terraform_dir="./terraform_config"
+):
+    try:
+        cur_dir = os.getcwd()
+        os.chdir(terraform_dir)
+        # init_result = subprocess.run(["terraform", "init"], check=True)
+        # # generate Terraform plan with the -no-color flag
+        # plan_file = "plan.out"
+        # plan_result = subprocess.run(
+        #     ["terraform", "plan", "-out", plan_file, "-no-color"], check=True
+        # )
+        # convert the plan to JSON and store it
+        with open(
+            output_json_file, "w", encoding="utf-8", errors="ignore"
+        ) as json_file:
+            subprocess.run(
+                ["terraform", "show", "-json", plan_file], check=True, stdout=json_file
+            )
+        os.chdir(cur_dir)
+    except subprocess.CalledProcessError as e:
+        # print(f"An error occurred: {e}")
+        logger.error("An error occurred: {}".format(e), exc_info=True)
+        return None
+def read_eval_models(ctx: click.Context, _, arg: str) -> List[str]:
+    return arg.split(sep=",")
+def read_config_file(path: Path) -> Tuple[int, List[str]]:
+    try:
+        with path.open("r") as file:
+            config = json.load(file)
+            return config.get("samples", NUM_SAMPLES_PER_TASK), config.get(
+                "models", EVAL_MODELS
+            )
+    except BaseException:
+        print("Invalid config file.", file=sys.stderr)
+        sys.exit(1)
+def set_logger(log_file: Path):
+    """
+    Set global logger with log file
+    """
+    logger.setLevel(logging.DEBUG)
+    # Setup File handler: https://stackoverflow.com/a/24507130/13336187
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setFormatter(CustomFormatter())
+    file_handler.setLevel(logging.DEBUG)
+    # Setup Stream Handler (i.e. console)
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.DEBUG)
+    ch.setFormatter(CustomFormatter())
+    # Log to both file and console:
+    logger.addHandler(ch)
+    logger.addHandler(file_handler)
+def setup_gpt_client():
+    global gpt_client
+    global embeddings_model
+    if "OPENAI_API_KEY" not in os.environ:
+        api_key = input("Enter OpenAI API key:")
+        os.environ["OPENAI_API_KEY"] = api_key
+    api_key = os.environ["OPENAI_API_KEY"]
+    gpt_client= OpenAI(api_key=api_key)
+def setup_magicoder_params():
+    if "MAGICODER_SAGEMAKER_ENDPOINT" not in os.environ:
+        endpoint = input("Enter Magicoder Sagemaker endpoint:") # E.g., "huggingface-pytorch-tgi-inference-2024-05-09-15-37-08-362"
+        os.environ["MAGICODER_SAGEMAKER_ENDPOINT"] = endpoint
+@click.command()
+@click.option(
+    "--samples",
+    "-s",
+    type=int,
+    help="Number of samples per task.",
+    default=NUM_SAMPLES_PER_TASK,
+)
+@click.option(
+    "--quick-test",
+    "-q",
+    "quick_test",
+    is_flag=True,
+    help="Perform quick evaluation on only 2 rows within the main dataset.",
+    default=False,
+)
+@click.option(
+    "--models",
+    "-m",
+    type=str,
+    help=f"List of evaluation models. Available models: {' '.join(EVAL_MODELS)}",
+    callback=read_eval_models,
+    default=EVAL_MODELS,
+)
+@click.option(
+    "--config",
+    "--file",
+    "-c",
+    "-f",
+    type=click.Path(path_type=Path, exists=True),
+    help="Path to config file for command line options.",
+)
+@click.option(
+    "--log-file",
+    "-l",
+    "log_file",
+    type=click.Path(path_type=Path),
+    help="Path to log file.",
+    default=DEFAULT_LOG_FILE,
+)
+@click.option(
+    "--enhance-strat",
+    "-e",
+    "enhance_strat",
+    type=click.Choice(PROMPT_ENHANCEMENT_STRATS),
+    help=f"Prompt enhancement strategy. Available strategies: {' '.join(PROMPT_ENHANCEMENT_STRATS)}",
+    default="",
+)
+# @click.argument("enhance_strat", nargs=1, type=str, default="")
+def main(
+    samples: int, models: List[str], config: Path, log_file: Path, enhance_strat: str, quick_test: bool
+):
+    """
+    Evaluate models.
+    Available enhancement strategy: "RAG", "COT", "FSP", or "multi-turn".
+    Config file takes precedence over command line options.
+    """  # FIX
+    if config is not None:
+        samples, models = read_config_file(config)
+    # changing config variables basing on command line options
+    global NUM_SAMPLES_PER_TASK
+    NUM_SAMPLES_PER_TASK = samples
+    global EVAL_MODELS
+    EVAL_MODELS = models
+    set_logger(log_file)
+    print(samples)
+    print(models)
+    PROMPT_ENHANCEMENT_STRAT = (
+        enhance_strat
+        # FIX?: should this be changed to an option instead of argument
+    )
+    # Setup environment variables:
+    set_aws_credentials()
+    set_replicate_credentials()
+    # set_huggingface_credentials()
+    if "gemini-1.0-pro" in models:
+        set_google_credentials()
+    if "gpt3.5" in models or "gpt4" in models:
+        setup_gpt_client()
+    if "Magicoder_S_CL_7B" in models:
+        setup_magicoder_params()
+    # Setup retriever:
+    if "RAG" in PROMPT_ENHANCEMENT_STRAT:
+        Retriever = llama_index_retriever.Retriever(
+            stored_index="../retriever/aws-index",
+            path="../retriever/terraform-provider-aws/website/docs/r",
+        )
+    else:
+        Retriever = None
+    # Import dataset:
+    if not quick_test:
+        data.import_dataset()
+    else:
+        data.import_dataset(quick_test=True)
+    # specify the directory you want to search
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    data_dir = os.path.join(script_dir, "..", "data")
+    base_eval_dir = os.path.join(
+        data_dir, "..", "evaluation/tmp"
+    )  # should be the same as script_dir
+    final_eval_dir = os.path.join(data_dir, "..", "evaluation/results")
+    # Create evaluation directories for each data directory
+    # and perform model evaluation:
+    list_all_subdirectories_and_eval(
+        data_dir, base_eval_dir, final_eval_dir, PROMPT_ENHANCEMENT_STRAT, Retriever
+    )
+if __name__ == "__main__":
+    main()

human_reference_dataset/iac-eval/evaluation/llm-judge-eval.py ADDED Viewed

	@@ -0,0 +1,263 @@

+# Conceptual Reference: https://arxiv.org/pdf/2306.05685
+import os
+from pathlib import Path
+from openai import OpenAI
+import sys
+import pandas as pd
+import logging
+from os import listdir
+from os.path import isfile, join
+import numpy as np
+import math
+import json
+import metrics
+import eval
+import models
+NUM_SAMPLES_PER_TASK = 1 # number of times we want to run the LLM judge for each eval output (i.e., LLM output # X) from the dataset
+LOG_FILE = "logs/metrics_eval.log"
+DELIMITERS = ["```hcl", "```json", "```HCL", "```Terraform", "```terraform", "```"] # ``` needs to be in the end, as it is a final "else" case
+class CustomFormatter(logging.Formatter):
+    # https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
+    grey = "\x1b[38;20m"
+    cyan = "\x1b[36;20m"
+    blue = "\x1b[34:20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    FORMATS = {
+        logging.DEBUG: cyan + format + reset,
+        logging.INFO: blue + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset
+    }
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+logger = logging.getLogger("iac-eval-metric")
+logger.setLevel(logging.DEBUG)
+#Setup File handler: https://stackoverflow.com/a/24507130/13336187
+file_handler = logging.FileHandler(LOG_FILE)
+file_handler.setFormatter(CustomFormatter())
+file_handler.setLevel(logging.DEBUG)
+#Setup Stream Handler (i.e. console)
+ch = logging.StreamHandler()
+ch.setLevel(logging.DEBUG)
+ch.setFormatter(CustomFormatter())
+# Log to both file and console:
+logger.addHandler(ch)
+logger.addHandler(file_handler)
+def setup_gpt_client():
+    global gpt_client
+    global embeddings_model
+    if "OPENAI_API_KEY" not in os.environ:
+        api_key = input("Enter OpenAI API key:")
+        os.environ["OPENAI_API_KEY"] = api_key
+    api_key = os.environ["OPENAI_API_KEY"]
+    gpt_client= OpenAI(api_key=api_key)
+# split the code for results
+def extract_rating_from_answer(text):
+    rating_str = text.splitlines()[-1]
+    if "Correct" or "Incorrect" in rating_str:
+        return rating_str
+    else:
+        logger.error("Error: Answer contains no code, skipping eval_pipeline.")
+        return rating_str
+# Take our existing dataset, iterate through each row, add a new column with the LLM generated response, and a new column for the extracted verdict, and save the new dataset to a new file with a filename that is prefixed with the llm model-name.
+def list_all_subdirectories(data_dir):
+    onlyfiles = [os.path.join(dirpath,f) for (dirpath, dirnames, filenames) in os.walk(data_dir) for f in filenames]
+    onlyfilescsv = [f for f in onlyfiles if f.endswith(".csv")]
+    return onlyfilescsv
+def create_new_dirs_for_metric(base_eval_files, new_base_metric_dir="llm-judge-evaluation-metric"):
+    for file in base_eval_files:
+        # create the directory if it does not exist
+        new_dir_path = os.path.join(os.path.dirname(file), new_base_metric_dir)
+        os.makedirs(new_dir_path, exist_ok=True)
+def determine_eval_samples(df_columns):
+    """
+        Determine the number of samples per task
+    """
+    num_samples = 0
+    for col in df_columns:
+        if "LLM Correct?" in col:
+            num_samples += 1
+    return num_samples
+def copy_csv_to_metric(base_eval_files, new_base_metric_dir, llm="gpt4"):
+    """
+        Example:
+            base_eval_files: ["../results-for-iac-eval (backup)/george-existing/evaluation-dataset-george-gpt3.5.csv"]
+            llm_base_eval_dir: "../results-for-iac-eval (backup)/george-existing/llm-judge-evaluation-metric"
+    """
+    dst_filenames = []
+    dst_filenames_skipped = []
+    llm_single_filename_prefix = "{}-single".format(llm)
+    llm_reference_filename_prefix = "{}-reference".format(llm)
+    for file in base_eval_files:
+        file_stem = Path(file).stem # https://stackoverflow.com/questions/678236/how-do-i-get-the-filename-without-the-extension-from-a-path-in-python
+        filename = llm_single_filename_prefix + "-" + file_stem + ".csv"
+        dest_file_path = os.path.join(os.path.dirname(file), new_base_metric_dir, filename)
+        # print(dest_file_path)
+        # Check if llm-judge file is already evaluated: skip if true
+        if os.path.isfile(dest_file_path) and os.stat(dest_file_path).st_size != 0: # if file is not empty
+            dst_df = pd.read_csv(dest_file_path, header=None)
+            new_header = dst_df.iloc[0]
+            dst_df = dst_df[1:]
+            dst_df.columns = new_header
+            dst_df.reset_index(drop=True, inplace=True)
+            # print(dst_df['gpt4 Judge Output #0 for LLM output #0'].iloc[0])
+            if not pd.isnull(dst_df['gpt4 Judge Output #0 for LLM output #0'].iloc[0]):
+                # print("hi: ", dest_file_path)
+                # while True:
+                #     x=1
+                dst_filenames_skipped.append(dest_file_path)
+                continue
+        # print("no hi", dest_file_path)
+        # while True:
+        #     x=1
+        dst_filenames.append(dest_file_path)
+        df = pd.read_csv(file, header=None)
+        new_header = df.iloc[0]
+        df = df[1:]
+        df.columns = new_header
+        NUM_EVAL_SAMPLES = determine_eval_samples(df.columns)
+        # reset the index of the DataFrame
+        df.reset_index(drop=True, inplace=True)
+        # add new columns only to df
+        for i in range(NUM_SAMPLES_PER_TASK):
+            for col_base in [
+                "{} Judge Output #{} for LLM output #{}".format(llm, str(i), str(0)),
+                "{} Judge verdict #{} for LLM output #{}".format(llm, str(i), str(0)),
+            ]:
+                df[col_base] = ""
+        df.to_csv(dest_file_path, index=False, encoding="utf-8")
+        # print(f"Copied and modified CSV to: {dest_file_path}")
+    return dst_filenames, dst_filenames_skipped
+def llm_judge_eval_loop(dst_filenames, llm="", METRIC="llm-single"):
+    for file in dst_filenames:
+        df = pd.read_csv(file)
+        logger.info(f"Begin extracting metric from dataset {file}")
+        # while True:
+        #     x=1
+        # iterate through each row
+        for index, row in df.iterrows():
+        # iterate every row
+        # find specific column
+            llm_judge_eval(row, df, index, llm, METRIC)
+        df.to_csv(file, index=False, encoding="utf-8")
+        logger.info(f"Finished extracting metric from dataset {file}")
+def get_prompt_from_metric(prompt, candidate, reference, llm="", METRIC="llm-single"):
+    if METRIC == "llm-single":
+        prompt = metrics.llm_as_judge_single(prompt, candidate)
+    else:
+        assert 1 == 0, "Invalid METRIC"
+    return prompt
+def llm_judge_eval(row, df, index, model="", METRIC="llm-single"):
+    """
+        Note: Multi-turn implies 2 turns only
+    """
+    prompt = row["Prompt"]
+    if isinstance(prompt, float):
+        if math.isnan(prompt):
+            return
+    reference = row["Reference output"]
+    preprompt = ""
+    # prompt = prompt_enhancements(prompt, PROMPT_ENHANCEMENT_STRAT)
+    # while True:
+    #     x=1
+    policy_file = row["Rego intent"]
+    # num_correct = 0
+    # logger.info(f"Begin extracting metric {METRIC} from dataset:")
+    NUM_EVAL_SAMPLES = determine_eval_samples(df.columns)
+    for i in range(NUM_SAMPLES_PER_TASK):
+        eval_answer = row["LLM Output #{}".format(str(0))]
+        if isinstance(eval_answer, float) and math.isnan(eval_answer):
+            text = "LLM output in dataset is Nan"
+            rating_str = "No output"
+        else:
+            logger.info(f"Model raw output (already in the dataset itself, for when evaluating a model on the dataset): {eval_answer}")
+            answer, candidate = eval.separate_answer_and_code(eval_answer, DELIMITERS)
+            logger.info(f"Candidate config: {candidate}")
+            prompt = get_prompt_from_metric(prompt, candidate=candidate, reference=reference, llm=model, METRIC=METRIC)
+            logger.info(f"Sample {i} for metric {METRIC}")
+            logger.info(f"Preprompt: {preprompt}")
+            logger.info(f"Prompt: {prompt}")
+            if model == "gpt4":
+                text = models.GPT4(preprompt, prompt, gpt_client)
+            elif model == "gpt3.5":
+                text = models.GPT3_5(preprompt, prompt, gpt_client)
+            elif model == "gemini-1.0-pro":
+                text = models.gemini(preprompt, prompt)
+            elif model == "codellama-13b":
+                text = models.Codellama13b(preprompt, prompt)
+            elif model == "codellama-7b":
+                text = models.Codellama7b(preprompt, prompt)
+            elif model == "codellama-34b":
+                text = models.Codellama34b(preprompt, prompt)
+            rating_str = extract_rating_from_answer(text)
+            logger.info("Answer is: {}".format(text))
+            logger.info("Rating is: {}".format(rating_str))
+        df.at[index, "{} Judge Output #{} for LLM output #{}".format(model, str(i), str(0))] = text
+        df.at[index, "{} Judge verdict #{} for LLM output #{}".format(model, str(i), str(0))] = rating_str
+    # return text
+# main:
+def main(): # E.g.,: python3 llm-judge-eval.py gpt4 llm-single
+    llm = sys.argv[1] # options: gpt4
+    metric = sys.argv[2] # options: "llm-single"
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    eval_data_dir = os.path.join(script_dir, "results")
+    base_eval_files = list_all_subdirectories(eval_data_dir)
+    base_eval_files = [f for f in base_eval_files if "-single" not in f and "-reference" not in f]
+    print(base_eval_files)
+    base_eval_files = [f for f in base_eval_files if "COT" not in f and "FSP" not in f and "RAG" not in f and "multi-turn" not in f] # temporarily to save time...
+    print(base_eval_files)
+    # base_eval_files = ['/home/ubuntu/autoiac-tasks/evaluation/../results-for-iac-eval (backup)/multi-turn/gpt4/lei-existing/evaluation-dataset-multi-turn-lei-gpt4-test-1.csv'] # just for debugging purposes
+    create_new_dirs_for_metric(base_eval_files, new_base_metric_dir="llm-judge-evaluation-metric")
+    dst_filenames, dst_filenames_skipped = copy_csv_to_metric(base_eval_files, new_base_metric_dir="llm-judge-evaluation-metric", llm="gpt4")
+    print("Filenames to evaluate: ", dst_filenames)
+    print("------------------------------")
+    print("Filenames skipped (since they have already been evaluated): ", dst_filenames_skipped)
+    # Write dst_filenames to a file:
+    # with open("delete-soon-archived/dst_filenames.txt", "w") as f:
+    #     for item in dst_filenames:
+    #         f.write("%s\n" % item)
+    # while True:
+    #     x=1
+    llm_judge_eval_loop(dst_filenames, llm=llm, METRIC=metric)
+    # At the end, get a correctness percentage across all rows in the dataset (across all files).
+if __name__ == "__main__":
+    setup_gpt_client()
+    main()

human_reference_dataset/iac-eval/evaluation/logs/README.md ADDED Viewed

	@@ -0,0 +1 @@


1	+ Stores log files for various evaluation tasks.

human_reference_dataset/iac-eval/evaluation/metrics.py ADDED Viewed

	@@ -0,0 +1,213 @@

+# BLEU
+from nltk.translate.bleu_score import sentence_bleu, corpus_bleu, SmoothingFunction
+import code_bert_score
+# reference = [['this', 'is', 'a', 'test'], ['this', 'is' 'test']]
+# candidate = ['this', 'is', 'a', 'test']
+# score = sentence_bleu(reference, candidate)
+# print(score)
+# Exact match:
+def bleu_score(reference, candidate):
+    reference_tokens = reference.split()
+    result_tokens = candidate.split()
+    if len(reference_tokens) < 4:
+        print("Reference code has less than 4 tokens:".format(reference))
+        return 0
+    if len(result_tokens) < 4:
+        print("Result code has less than 4 tokens:".format(candidate))
+        return 0
+    score = corpus_bleu([[reference_tokens]], [result_tokens], weights=(0.25, 0.25, 0.25, 0.25), smoothing_function=SmoothingFunction().method3)
+    # A perfect match results in a score of 1.0, whereas a perfect mismatch results in a score of 0.0. Standard implementation from NLTK based on the actual paper.
+    # return sentence_bleu(reference, candidate)
+    return score
+def get_code_bert_score(reference, candidate, prompt):
+    # https://github.com/neulab/code-bert-score
+    pred_results = code_bert_score.score(cands=[candidate], refs=[reference], lang='python', sources=[prompt]) # returns a 4-tuple of (precision, recall, F1, F3), where each is a 1-D tensor of scores for each prediction-reference pair
+    return {
+        "precision": pred_results[0].item(),
+        "recall": pred_results[1].item(),
+        "f1": pred_results[2].item(),
+        "f3": pred_results[3].item()
+    }
+def exact_match(reference, candidate):
+    return reference.strip() == candidate.strip()
+def llm_as_judge_single(prompt, candidate):
+    # Fig 6 of the paper: https://arxiv.org/pdf/2306.05685
+    template = """
+Please act as an impartial judge and evaluate the correctness of the code provided by an AI assistant to the user question displayed below. Begin your evaluation by providing a short explanation. Be as objective as possible. After providing your explanation, please rate the response as either correct or incorrect by strictly following this format: "Rating: Correct" or "Rating: Incorrect".
+[Question]
+{}
+[The Start of Assistant’s Answer]
+{}
+[The End of Assistant’s Answer]
+""".format(prompt, candidate)
+    # return bleu_score(reference, candidate)
+    return template
+def llm_as_judge_reference(reference, candidate, llm="gpt4"):
+    # Fig 8 of the paper: https://arxiv.org/pdf/2306.05685. Edited to not have an "assistant B".
+    template = """
+Please act as an impartial judge and evaluate the correctness of the code provided by an AI assistant to the user question displayed below. You will be given a reference answer, and the assistant's answer. Your job is to evaluate if the assistant's answer is correct or incorrect, in comparison to the reference answer. Begin your evaluation by comparing the assistant's answer with the reference answer. Identify and correct any mistakes. Avoid any position biases and ensure that the order in which the responses were presented does not influence your decision. Do not allow the length of the responses to influence your evaluation. Be as objective as possible. After providing your explanation, output your final verdict by strictly following this format: "Rating: Correct" or "Rating: Incorrect".
+[User Question]
+{}
+[The Start of Reference Answer]
+{}
+[The End of Reference Answer]
+[The Start of Assistant’s Answer]
+{}
+[The End of Assistant’s Answer]
+""".format(prompt, reference, candidate)
+    # return bleu_score(reference, candidate)
+    return template
+# reference = """
+# terraform {
+#   required_providers {
+#     aws = {
+#       source  = "hashicorp/aws"
+#       version = "~> 4.16"
+#     }
+#   }
+#   required_version = ">= 1.2.0"
+# }
+# provider "aws" {
+#   region = "us-west-2"
+# }
+# resource "aws_iam_role" "test_role" {
+#   name = "test_role"
+#   assume_role_policy = jsonencode({
+#     Version = "2012-10-17"
+#     Statement = [
+#       {
+#         Action = "sts:AssumeRole"
+#         Effect = "Allow"
+#         Sid    = ""
+#         Principal = {
+#           Service = "codebuild.amazonaws.com"
+#         }
+#       },
+#     ]
+#   })
+#   tags = {
+#     tag-key = "test_role"
+#   }
+# }
+# resource "aws_codebuild_project" "example" {
+#   name          = "test-project"
+#   service_role  = aws_iam_role.test_role.arn
+#   artifacts {
+#     type = "NO_ARTIFACTS"
+#   }
+#   environment {
+#     compute_type                = "BUILD_GENERAL1_SMALL"
+#     image                       = "aws/codebuild/amazonlinux2-x86_64-standard:4.0"
+#     type                        = "LINUX_CONTAINER"
+#     image_pull_credentials_type = "CODEBUILD"
+#   }
+#   source {
+#     type            = "GITHUB"
+#     location        = "https://github.com/neilbalch/SimplePythonTutorial.git"
+#     git_clone_depth = 1
+#   }
+# }terraform {
+#   required_providers {
+#     aws = {
+#       source  = "hashicorp/aws"
+#       version = "~> 4.16"
+#     }
+#   }
+#   required_version = ">= 1.2.0"
+# }
+# provider "aws" {
+#   region = "us-west-2"
+# }
+# """
+# candidate = """
+# resource "aws_codebuild_project" "example" {
+#   name = "example"
+#   description = "Example CodeBuild project"
+#   source {
+#     type = "GITHUB"
+#     location = "https://github.com/hashicorp/example-codebuild"
+#   }
+#   artifacts {
+#     type = "CODEPIPELINE"
+#     location = "codepipeline"
+#     path = "output"
+#     namespace_type = "NONE"
+#   }
+#   environment {
+#     type = "LINUX_CONTAINER"
+#     image = "aws/codebuild/standard:5.0"
+#     compute_type = "BUILD_GENERAL1_SMALL"
+#   }
+#   service_role = "arn:aws:iam::111122223333:role/example-codebuild-role"
+# }
+# resource "aws_iam_role" "example" {
+#   name = "example-codebuild-role"
+#   assume_role_policy = jsonencode({
+#     Version = "2012-10-17"
+#     Statement = [{
+#       Action = "sts:AssumeRole"
+#       Effect = "Allow"
+#       Principal = {
+#         Service = "codebuild.amazonaws.com"
+#       }
+#     }]
+#   })
+#   inline_policy {
+#     name = "example"
+#     policy = jsonencode({
+#       Version = "2012-10-17"
+#       Statement = [{
+#         Action = ["codebuild:BatchGetBuilds", "codebuild:StartBuild"],
+#         Effect = "Allow"
+#         Resource = "*"
+#       }, {
+#         Action = ["ecr:GetAuthorizationToken", "ecr:PutImage"],
+#         Effect = "Allow"
+#         Resource = "arn:aws:ecr:us-west-2:111122223333:repository/example"
+#       }, {
+#         Action = ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
+#         Effect = "Allow"
+#         Resource = "arn:aws:logs:us-west-2:111122223333:log-group:/aws/codebuild/*"
+#       }, {
+#         Action = ["s3:GetObject", "s3:GetObjectVersion", "s3:PutObject"],
+#         Effect = "Allow"
+#         Resource = "arn:aws:s3:::example/*"
+#       }, {
+#         Action = ["secretsmanager:GetSecretValue"],
+#         Effect = "Allow"
+#         Resource = "arn:aws:secretsmanager:us-west-2:111122223333:secret:example"
+#       }]
+#     })
+#   }
+# }
+# """
+# print(bleu_score(reference, candidate))

human_reference_dataset/iac-eval/evaluation/misc/ablation-judge/ablation-llm-judge.py ADDED Viewed

	@@ -0,0 +1,604 @@

+# Assumption: single file for each evaluated dataset. (e.g., no -pass5 and -pass1 in the same folder.)
+import csv
+import pandas as pd
+import logging
+import os
+from pathlib import Path
+from openai import AzureOpenAI
+import pandas as pd
+import json
+import subprocess
+import copy
+from io import StringIO
+import re
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
+import eval
+import metrics
+import math
+DELIMITERS = ["```hcl", "```json", "```HCL", "```Terraform", "```terraform", "```"] # ``` needs to be in the end, as it is a final "else" case
+LOG_FILE = "logs/eval-repair.log"
+class CustomFormatter(logging.Formatter):
+    # https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
+    grey = "\x1b[38;20m"
+    cyan = "\x1b[36;20m"
+    blue = "\x1b[34:20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    FORMATS = {
+        logging.DEBUG: cyan + format + reset,
+        logging.INFO: blue + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset
+    }
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+logger = logging.getLogger("iac-eval-repair")
+logger.setLevel(logging.DEBUG)
+#Setup File handler: https://stackoverflow.com/a/24507130/13336187
+file_handler = logging.FileHandler(LOG_FILE)
+file_handler.setFormatter(CustomFormatter())
+file_handler.setLevel(logging.DEBUG)
+#Setup Stream Handler (i.e. console)
+ch = logging.StreamHandler()
+ch.setLevel(logging.DEBUG)
+ch.setFormatter(CustomFormatter())
+# Log to both file and console:
+logger.addHandler(ch)
+logger.addHandler(file_handler)
+def pretty_json(obj):
+    return json.dumps(obj, sort_keys=True, indent=4, default=str)
+def estimator(n: int, c: int, k: int) -> float:
+    """
+    Calculates 1 - comb(n - c, k) / comb(n, k).
+    """
+    if n - c < k:
+        return 1.0
+    return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
+def list_all_subdirectories(composition_dict, data_dir, excluded_dirs, strats=["multi-turn", "RAG", "COT", "FSP"], mandatory_substring="llm-judge-evaluation-metric"):
+    onlyfiles = []
+    for dirpath, dirnames, filenames in os.walk(data_dir):
+        skip_dirname = False
+        # Skip eval directories that were used to evaluate custom strats (e.g., RAG...), i.e., only keep standard
+        for dir1 in strats:
+            if dir1 in dirpath:
+                skip_dirname = True
+        # Keep only LLM-judge output directories
+        if not skip_dirname:
+            if mandatory_substring not in dirpath:
+                skip_dirname = True
+        if not skip_dirname:
+            for f in filenames:
+                skip_file = False
+                for exc in excluded_dirs:
+                    if exc in f:
+                        skip_file = True
+                if not skip_file:
+                    onlyfiles.append(os.path.join(dirpath, f))
+    onlyfilescsv = [f for f in onlyfiles if f.endswith(".csv")]
+    # print(onlyfilescsv)
+    # while True:
+    #     x=1
+    # Append to composition dict:
+    for file1 in onlyfilescsv:
+        dirname = os.path.dirname(file1)
+        # print(os.path.dirname(file1))
+        # while True:
+        #     x=1
+        included = False
+        is_standard = True
+        for i in strats:
+            if i in dirname:
+                is_standard = False
+        for model, model_dict in composition_dict.items():
+            for strat, student_dict in model_dict.items():
+                if is_standard:
+                    if strat != "Standard":
+                        continue
+                for student, dataset_list in student_dict.items():
+                    is_file = False
+                    if is_standard:
+                        if student in dirname and model in dirname:
+                            is_file = True
+                    else:
+                        if student in dirname and strat in dirname and model in dirname:
+                            is_file = True
+                    if is_file:
+                        if not included:
+                            composition_dict[model][strat][student].append(file1)
+                            included = True
+                        else:
+                            print("WARNING: This file attempted to be included multiple times: ", file1)
+        if not included:
+            print("WARNING: This file was excluded: ", file1)
+    return onlyfilescsv, composition_dict
+def create_new_dirs_for_metric(new_base_difficulty_dir, base_dataset_files):
+    os.makedirs(new_base_difficulty_dir, exist_ok=True)
+    for file in base_dataset_files:
+        containing_folder = os.path.basename(os.path.dirname(file)) # e.g., weijun
+        filename = os.path.basename(file) # e.g., plain-dataset.csv
+        # create the directory if it does not exist
+        new_dir_path = os.path.join(new_base_difficulty_dir, containing_folder)
+        # print(new_dir_path)
+        os.makedirs(new_dir_path, exist_ok=True)
+def metric_calculation_loop(composition_dict, dataset_dir, output_composition_dict_filepath):
+    """
+    Output format example (added in place to composition_dict): {
+        "gpt4": {
+            "Standard": {
+                ..., # whatever that is already in composition_dict
+                "llm-judge": {
+                    "accuracy": 0.8,
+                    "precision": 0.5,
+                    "recall": 0.3
+                },
+                "iac_eval_accuracy": XYZ, # copied from ablation/output_composition_dict.json
+            },
+            "COT": <current implementation not supported>
+        },
+        "gpt3.5": {
+            ...
+        },
+        ...
+    }
+    """
+    output_composition_dict = copy.deepcopy(composition_dict) # https://stackoverflow.com/questions/5105517/deep-copy-of-a-dict-in-python
+    for model, model_dict in composition_dict.items():
+        for strat, student_dict in model_dict.items():
+            num_success = 0 # row considered correct by LLM-judge pipeline correctly
+            num_rows = 0
+            true_positive_count = 0
+            false_positive_count = 0
+            false_negative_count = 0
+            passed_once = False
+            iac_eval_complexity_accuracy = {
+                "1": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "2": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "3": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "4": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "5": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "6": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                }
+            }
+            for student, dataset_list in student_dict.items():
+                # n_total = 0 # number of trials that this student has been evaluated for. Used for pass@k's n parameter
+                for file1 in dataset_list:
+                    # Go through each row
+                    df = pd.read_csv(file1)
+                    print(f"Begin calc metrics for dataset {file1}")
+                    # iterate through each row
+                    for index, row in df.iterrows():
+                        # Skip empty rows
+                        if isinstance(row["Prompt"], float):
+                            if math.isnan(row["Prompt"]):
+                                continue
+                        print("Current Prompt: ", row["Prompt"])
+                        passed_once = True
+                        num_rows += 1
+                        # TODO: May add this back in later if need it for appendix evaluation
+                        # dataset_df, dataset_row = extract_dataset_row(row, index, df, dataset_dir, file1) # extract the corresponding row from the "data" dataset file
+                        # complexity = difficulty_retrieval(dataset_row)
+                        iac_eval_success = False
+                        if row["LLM Plannable? #0"] == True: # we use #0 even if it is possible that a mistake was made somewhere and we evaluated e.g., FSP twice.
+                            if row["LLM Correct? #0"] == "Success":
+                                iac_eval_success = True
+                                # iac_eval_complexity_accuracy[complexity]["num_success_both"] += 1
+                        edge_case = False
+                        if isinstance(row["gpt4 Judge verdict #0 for LLM output #0"], float):
+                            edge_case = True
+                        else:
+                            if "Incorrect" in row["gpt4 Judge verdict #0 for LLM output #0"]:
+                                if iac_eval_success:
+                                    false_negative_count += 1
+                            elif "Correct" in row["gpt4 Judge verdict #0 for LLM output #0"]:
+                                num_success += 1
+                                if not iac_eval_success:
+                                    false_positive_count += 1
+                                else:
+                                    true_positive_count += 1
+                            else:
+                                edge_case = True
+                        if edge_case:
+                            # in the rare edge case that this happens, we retrieve our original results and try and extract a line containing: "Rating: X":
+                            found_rating = False
+                            print(row["Prompt"])
+                            print(row["gpt4 Judge Output #0 for LLM output #0"])
+                            if "Rating: " in row["gpt4 Judge Output #0 for LLM output #0"]:
+                                judgement_str = row["gpt4 Judge Output #0 for LLM output #0"].split("\n")
+                                for line in judgement_str:
+                                    if "Rating: Incorrect" in line or "Rating: Correct" in line:
+                                        if "Incorrect" in line:
+                                            if iac_eval_success:
+                                                false_negative_count += 1
+                                        elif "Correct" in line:
+                                            num_success += 1
+                                            if not iac_eval_success:
+                                                false_positive_count += 1
+                                            else:
+                                                true_positive_count += 1
+                                        found_rating = True
+                                        break
+                            if not found_rating:
+                                # log it but continue. Currently, we observe that GPT4 rarely does not follow our instruction to output the line "Rating: Incorrect" or "Rating: Correct".
+                                print("WARNING: Unexpected value in gpt4 Judge verdict #0 for LLM output #0: ", row["gpt4 Judge verdict #0 for LLM output #0"])
+                            # assert False
+                    print(f"Finished calc metrics for dataset {file1}")
+            if not passed_once:
+                continue
+            # Calculate metrics
+            if true_positive_count + false_positive_count == 0:
+                precision = 0
+            else:
+                precision = true_positive_count / (true_positive_count + false_positive_count)
+            if true_positive_count + false_negative_count == 0:
+                recall = 0
+            else:
+                recall = true_positive_count / (true_positive_count + false_negative_count)
+            output_composition_dict[model][strat]["llm-judge"] = {
+                "accuracy": num_success / num_rows, # in terms of the perspective of the LLM-judge, what it deems to be correct. Not the same as calculating confusion matrix accuracy
+                "precision": precision,
+                "recall": recall
+            }
+            # Copy over the IAC eval accuracy from the ablation output composition dict:
+            with open(os.path.join(os.path.dirname(output_composition_dict_filepath), "../ablation", "output_composition_dict.json"), 'r') as fp:
+                ablation_output_composition_dict = json.load(fp)
+                output_composition_dict[model][strat]["iac_eval_accuracy"] = ablation_output_composition_dict[model][strat]["iac_eval_accuracy"]
+            # for level, attrs in iac_eval_complexity_accuracy.items():
+            #     output_composition_dict[model][strat]["iac_eval_complexity_accuracy"][level] = attrs["num_success_both"]/attrs["num_rows"]
+            with open(output_composition_dict_filepath, 'w') as fp: # incremental updates
+                json.dump(output_composition_dict, fp)
+    return output_composition_dict
+def extract_dataset_row(eval_row, eval_index, eval_df, dataset_dir, eval_filename, strats=["multi-turn", "RAG", "COT", "FSP"]):
+    """
+    Example eval_filename: '/home/ubuntu/autoiac-tasks/evaluation/misc/ablation/../../../results-for-iac-eval (backup)/multi-turn/codellama-34b/george/evaluation-dataset-for-plain-dataset-george-existing-multi-turn.csv'
+    """
+    # Extract corresponding "data" dataset file name:
+    file_stem = Path(eval_filename).stem # https://stackoverflow.com/questions/678236/how-do-i-get-the-filename-without-the-extension-from-a-path-in-python
+    file_stem = file_stem.split("evaluation-dataset-for-")[1]
+    filename = ""
+    for i in strats:
+        if i in file_stem:
+            filename = file_stem.split("-{}".format(i))[0] + ".csv"
+    if filename == "":
+        filename = file_stem + ".csv"
+    filename = "completed-" + filename
+    containing_folder = os.path.basename(os.path.dirname(eval_filename)) # e.g., weijun
+    dataset_filename = os.path.join(dataset_dir, containing_folder, filename)
+    # Access dataset file and extract required row
+    df = pd.read_csv(dataset_filename, header=None)
+    # set the third row as the header
+    new_header = df.iloc[0]
+    df = df[1:]
+    df.columns = new_header
+    # # reset the index of the DataFrame
+    df.reset_index(drop=True, inplace=True)
+    # print(df.at[eval_index, "Prompt"])
+    # while True:
+    #     x=1
+    # print(df)
+    # assert df.at[eval_index, "Prompt"] == eval_row["Prompt"] # add this back in as needed. Removed for now since I might have updated some dataset rows after some eval was performed on the old version of the dataset..
+    return df, df.iloc[eval_index]
+def difficulty_retrieval(row, difficulty_header="Complexity"):
+    prompt = row["Prompt"]
+    if isinstance(prompt, float):
+        if math.isnan(prompt):
+            return
+    reference = row["Reference output"]
+    policy = row["Rego intent"]
+    print("Prompt:", prompt)
+    return row[difficulty_header]
+def findkeys(node, kv):
+    # Modified from: https://stackoverflow.com/a/19871956/13336187
+    if isinstance(node, list):
+        for i in node:
+            for x in findkeys(i, kv):
+               yield x
+    elif isinstance(node, dict):
+        if kv in node:
+            yield kv
+        for j in node.values():
+            for x in findkeys(j, kv):
+                yield x
+# print(list(findkeys(d, 'id')))
+def write_to_terraform(result, terraform_dir="./misc/ablation/terraform_config"):
+    # define the path to the main.tf file
+    terraform_file_path = terraform_dir + "/metric-measurement-main.tf"
+    # open the file in write mode ('w') and write the result to it
+    # print("CWD", os.getcwd())
+    # print("CWD: {}".format(os.getcwd()))
+    with open(terraform_file_path, "w+", encoding="utf-8", errors="ignore") as file:
+        file.write(result)
+    # print(f"Updated main.tf at {terraform_file_path}")
+    # print(f"Updated main.tf at {terraform_file_path}")
+def generate_terraform_plan_json(prompt, terraform_dir="./misc/ablation/terraform_config", plan_file="plan.out", output_json_file="plan.json"):
+    cwd = os.getcwd()
+    # change to the Terraform directory
+    os.chdir(terraform_dir)
+    # run init before plan
+    init_result = subprocess.run(["terraform", "init"], capture_output=True, text=True)
+    # run 'terraform plan'
+    # result = subprocess.run(["terraform", "plan"], capture_output=True, text=True)
+    result_returned = False
+    # generate Terraform plan with the -no-color flag
+    for i in range(2): # try twice
+        try:
+            result = subprocess.run(
+                ["terraform", "plan", "-out", plan_file, "-no-color"], capture_output=True, text=True, timeout=300 # 5 minutes timeout (assume failed if timeout)
+            )
+            with open(
+                output_json_file, "w", encoding="utf-8", errors="ignore"
+            ) as json_file:
+                show_result = subprocess.run(
+                    ["terraform", "show", "-json", plan_file], check=True, stdout=json_file
+                )
+            result_returned = True
+            break
+        except Exception as e:
+            print("Error occurred for prompt \"{}\": {}".format(prompt, e))
+    # Return to parent directory
+    os.chdir(cwd)
+    if result_returned == False:
+        return "Plan timed-out. No output", "Plan timed-out. No error", False
+def main():
+    # Find dataset files:
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    eval_dataset_dir = os.path.join(script_dir, "../..", "results")
+    dataset_dir = os.path.join(script_dir, "../complete-dataset-measurement/complete-dataset")
+    # print()
+    excluded_dirs = ["pass"] # skip filenames containing "pass". will merge them into a regular file once done with eval..
+    composition_dict = {
+        "gpt4": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "gpt3.5": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "gemini-1.0-pro": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-34b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-13b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-7b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "Magicoder_S_CL_7B": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "Wizardcoder33b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        }
+    }
+    eval_dataset_files, composition_dict = list_all_subdirectories(composition_dict, eval_dataset_dir, excluded_dirs)
+    eval_dataset_files = [f for f in eval_dataset_files if "test" not in f]
+    with open(os.path.join(script_dir, 'input_composition_dict.json'), 'w') as fp:
+        json.dump(composition_dict, fp)
+    print(composition_dict)
+    output_composition_dict_filepath = os.path.join(script_dir, 'llm_judge_output_composition_dict.json')
+    # Calculate regular metrics
+    output_composition_dict = metric_calculation_loop(composition_dict, dataset_dir, output_composition_dict_filepath)
+    print("Output composition dict: ", pretty_json(output_composition_dict))
+    # print("complexity_distribution: ", pretty_json(complexity_distribution))
+    with open(output_composition_dict_filepath, 'w') as fp:
+        json.dump(output_composition_dict, fp)
+    # with open(os.path.join(script_dir, 'complexity_distribution.json'), 'w') as fp:
+    #     json.dump(complexity_distribution, fp)
+    # Calculate pass@k metric:
+    # print(metric_calculation_loop(composition_dict, pass_k_parameters))
+    # Display number of rows for each complexity level:
+if __name__ == "__main__":
+    main()

human_reference_dataset/iac-eval/evaluation/misc/ablation-multiple-sample/ablation-multiple-sample.py ADDED Viewed

	@@ -0,0 +1,731 @@

+# Assumption: potentially multiple files within the same eval folder (e.g.,results-for-iac-eval (backup)/standard/codellama-7b/george), where each file must contains n (or more) number of evaluation passes
+# Task: combines all "output" related columns and combines them into one single dataframe, saving it to a new folder within pass_k_calculation/combined_eval_dataset/ with a folder layout of (pass_k_calculation/combined_eval_dataset/standard/codellama-7b/george/), then passes through each file and calculates pass@k metrics for various k assuming some fixed N. And constructs an output_composition_dict.json similar to that used in ablation/
+import csv
+import pandas as pd
+import logging
+import os
+from pathlib import Path
+from openai import AzureOpenAI
+import pandas as pd
+import json
+import subprocess
+import copy
+from io import StringIO
+import re
+import sys
+import math
+import click
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
+import eval
+import numpy as np
+import metrics
+DELIMITERS = ["```hcl", "```json", "```HCL", "```Terraform", "```terraform", "```"] # ``` needs to be in the end, as it is a final "else" case
+LOG_FILE = "logs/eval-repair.log"
+class CustomFormatter(logging.Formatter):
+    # https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
+    grey = "\x1b[38;20m"
+    cyan = "\x1b[36;20m"
+    blue = "\x1b[34:20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    FORMATS = {
+        logging.DEBUG: cyan + format + reset,
+        logging.INFO: blue + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset
+    }
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+logger = logging.getLogger("iac-eval-repair")
+logger.setLevel(logging.DEBUG)
+#Setup File handler: https://stackoverflow.com/a/24507130/13336187
+file_handler = logging.FileHandler(LOG_FILE)
+file_handler.setFormatter(CustomFormatter())
+file_handler.setLevel(logging.DEBUG)
+#Setup Stream Handler (i.e. console)
+ch = logging.StreamHandler()
+ch.setLevel(logging.DEBUG)
+ch.setFormatter(CustomFormatter())
+# Log to both file and console:
+logger.addHandler(ch)
+logger.addHandler(file_handler)
+def pretty_json(obj):
+    return json.dumps(obj, indent=4, default=str)
+def estimator(n: int, c: int, k: int) -> float:
+    """
+    Calculates 1 - comb(n - c, k) / comb(n, k).
+    """
+    if n - c < k:
+        return 1.0
+    return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
+def make_column_names_unique(df):
+    for i in range(2): # repeat twice, since after the first time we may still have duplicates: e.g., if #0.1 already exists, and in the initial run we have duplicate #0
+        cols = pd.Series(df.columns)
+        for dup in cols[cols.duplicated()].unique():
+            cols[cols[cols == dup].index.values.tolist()] = [dup + '.' + str(i) if i != 0 else dup for i in range(sum(cols == dup))]
+        df.columns = cols
+    # print(cols.tolist())
+    # while True:
+    #     x=1
+    return df
+def fix_duplicate_columns(dest_file_path):
+    """
+        Deduplicated dataframe is returned to the user. dest_file_path is not overwritten.
+    """
+    df = pd.read_csv(dest_file_path, header=None)
+    new_header = df.iloc[0]
+    df = df[1:]
+    df.columns = new_header
+    df.reset_index(drop=True, inplace=True)
+    if not df.columns.is_unique: # First check if there are duplicate columns:
+        df = make_column_names_unique(df)
+        logger.info(f"Evaluation file {dest_file_path} had duplicate columns, deduplicated them. evaluation file not overwritten.")
+    return df
+def list_all_subdirectories(composition_dict, data_dir, excluded_dirs, strats=["multi-turn", "RAG", "COT", "FSP"]):
+    # onlyfiles = [os.path.join(dirpath,f) for (dirpath, dirnames, filenames) if dirpath not in excluded_dirs in os.walk(data_dir) for f in filenames]
+    onlyfiles = []
+    for dirpath, dirnames, filenames in os.walk(data_dir):
+        # print(dirpath)
+        skip_dirname = False
+        # if "standard" in dirpath:
+        #     print(dirpath)
+        for dir1 in excluded_dirs:
+            if dir1 in dirpath:
+                skip_dirname = True
+        if not skip_dirname:
+            for f in filenames:
+                skip_file = False
+                for exc in excluded_dirs:
+                    if exc in f:
+                        skip_file = True
+                if not skip_file:
+                    onlyfiles.append(os.path.join(dirpath, f))
+    # onlyfiles = [os.path.join(dirpath,f) for (dirpath, dirnames, filenames) in os.walk(data_dir) for f in filenames]
+    # print(onlyfiles)
+    onlyfilescsv = [f for f in onlyfiles if f.endswith(".csv")]
+    # composition_dict = {
+    #     "gpt4": {
+    #         "COT": {
+    #             "weijun": [],
+    # Append to composition dict:
+    for file1 in onlyfilescsv:
+        included = False
+        is_standard = True
+        for i in strats:
+            if i in file1:
+                is_standard = False
+        for model, model_dict in composition_dict.items():
+            for strat, student_dict in model_dict.items():
+                if is_standard:
+                    if strat != "Standard":
+                        continue
+                for student, dataset_list in student_dict.items():
+                    is_file = False
+                    if is_standard:
+                        if student in file1 and model in file1:
+                            is_file = True
+                    else:
+                        if student in file1 and strat in file1 and model in file1:
+                            is_file = True
+                    if is_file:
+                        if not included:
+                            composition_dict[model][strat][student].append(file1)
+                            included = True
+                        else:
+                            print("WARNING: This file attempted to be included multiple times: ", file1)
+        if not included:
+            print("WARNING: This file was excluded: ", file1)
+    return onlyfilescsv, composition_dict
+def create_new_dirs_for_metric(new_base_difficulty_dir, base_dataset_files):
+    os.makedirs(new_base_difficulty_dir, exist_ok=True)
+    for file in base_dataset_files:
+        containing_folder = os.path.basename(os.path.dirname(file)) # e.g., weijun
+        filename = os.path.basename(file) # e.g., plain-dataset.csv
+        # create the directory if it does not exist
+        new_dir_path = os.path.join(new_base_difficulty_dir, containing_folder)
+        # print(new_dir_path)
+        os.makedirs(new_dir_path, exist_ok=True)
+def metric_calculation_loop(composition_dict, dataset_dir, output_composition_dict_filepath, pass_k_parameters):
+    """
+    NOTE: pass@k calculation is limited to standard only for now.
+    NOTE: if pass_k_parameters is not None, then we will only calculate pass@k scores, and for standard only.
+    pass_k_parameters format example: {
+        "n" = 5,
+        "k" = [1,2,5],
+    }
+    Output format example (added in place to composition_dict): {
+        "gpt4": {
+            "Standard": {
+                ..., # whatever that is already in composition_dict
+                "iac_eval_accuracy": 0.3,
+                "pass@k" : { # iac-eval
+                    "n": 5 # just for record
+                    "1": 0.5,
+                    "2": 0.6,
+                    "5": 0.7,
+                },
+                "pass@k-tf-plan" : {
+                    "n": 5 # just for record
+                    "1": 0.5,
+                    "2": 0.6,
+                    "5": 0.7,
+                },
+            },
+            "COT": ...
+        },
+        "gpt3.5": {
+            ...
+        },
+        ...
+    }
+    """
+    output_composition_dict = copy.deepcopy(composition_dict) # https://stackoverflow.com/questions/5105517/deep-copy-of-a-dict-in-python
+    for model, model_dict in composition_dict.items():
+        for strat, student_dict in model_dict.items():
+            pass_k_scores = {}
+            pass_k_scores_tf_plan = {}
+            for i in pass_k_parameters["k"]:
+                pass_k_scores[i] = {
+                    "score_now": 0,
+                    "num_rows": 0
+                }
+                pass_k_scores_tf_plan[i] = {
+                    "score_now": 0,
+                    "num_rows": 0
+                }
+            # pass_k_score_now = 0
+            # num_rows = 0
+            passed_once = False
+            iac_eval_complexity_accuracy = {
+                "1": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "2": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "3": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "4": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "5": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                },
+                "6": {
+                    "num_success_both": 0,
+                    "num_rows": 0,
+                }
+            }
+            for student, dataset_list in student_dict.items():
+                # n_total = 0 # number of trials that this student has been evaluated for. Used for pass@k's n parameter
+                for file1 in dataset_list:
+                    # Go through each row
+                    df = pd.read_csv(file1) # this is now redundant since the next line also reads the file
+                    df = fix_duplicate_columns(file1)
+                    print(f"Begin calc metrics for dataset {file1}")
+                    # iterate through each row
+                    for index, row in df.iterrows():
+                        passed_once = True
+                        # find specific column
+                        # print(index)
+                        # while True:
+                        #     x=1
+                        if isinstance(row["Prompt"], float):
+                            continue
+                        # dataset_df, dataset_row = extract_dataset_row(row, index, df, dataset_dir, file1) # extract the corresponding row from the "data" dataset file
+                        # complexity = difficulty_retrieval(dataset_row)
+                        # Check all samples: Loop through columns whose names match the substring
+                        num_samples = 0
+                        num_correct = 0
+                        num_tf_plan_correct = 0
+                        for column in df.filter(like="LLM Output #"):
+                            num_samples += 1
+                            # print(f"Processing column: {column}")
+                            sample_count = column.split("#")[1]
+                            plannable = row["LLM Plannable? #{}".format(sample_count)]
+                            correct = row["LLM Correct? #{}".format(sample_count)]
+                            if plannable == "True" or plannable == True or plannable == "TRUE": # needed these extra conditions because fixing duplicate columns causes for example TRUE which would normally be evaluated into the boolean True, to be evaluated as a string TRUE instead..
+                                num_tf_plan_correct += 1
+                                if correct == "Success":
+                                    num_correct += 1
+                                    # iac_eval_complexity_accuracy[complexity]["num_success_both"] += 1
+                            if num_samples == pass_k_parameters["n"]: # only evaluate up till n samples, even if there are more
+                                break
+                        if "Wizard" in file1:
+                            print(num_correct)
+                        # if "Wizard" in file1:
+                        #     while True:
+                        #         x=1
+                        assert num_samples == pass_k_parameters["n"] # prereq: must have at least n samples
+                        for k, attrs in pass_k_scores.items():
+                            attrs["score_now"] += estimator(
+                                        pass_k_parameters["n"], num_correct, k
+                                    )
+                            attrs["num_rows"] += 1
+                        for k, attrs in pass_k_scores_tf_plan.items():
+                            attrs["score_now"] += estimator(
+                                        pass_k_parameters["n"], num_tf_plan_correct, k
+                                    )
+                            attrs["num_rows"] += 1
+                    print(f"Finished calc metrics for dataset {file1}")
+            if not passed_once:
+                # print(strat)
+                # while True:
+                #     x=1
+                continue
+            # Calculate pass@k scores
+            output_composition_dict[model][strat]["pass@k"] = {
+                                                                "n": str(pass_k_parameters["n"])
+                                                            }
+            output_composition_dict[model][strat]["pass@k-tf-plan"] = {
+                                                                "n": str(pass_k_parameters["n"])
+                                                            }
+            for k, attrs in pass_k_scores.items():
+                output_composition_dict[model][strat]["pass@k"][k] = str(attrs["score_now"]/attrs["num_rows"])
+            for k, attrs in pass_k_scores_tf_plan.items():
+                output_composition_dict[model][strat]["pass@k-tf-plan"][k] = str(attrs["score_now"]/attrs["num_rows"])
+            # Copy over the IAC eval accuracy from the ablation output composition dict: (for plotting purposes)
+            with open(os.path.join(os.path.dirname(output_composition_dict_filepath), "../ablation", "output_composition_dict.json"), 'r') as fp:
+                ablation_output_composition_dict = json.load(fp)
+                output_composition_dict[model][strat]["iac_eval_accuracy"] = str(ablation_output_composition_dict[model][strat]["iac_eval_accuracy"])
+            with open(output_composition_dict_filepath, 'w') as fp: # incremental updates
+                json.dump(output_composition_dict, fp)
+    return output_composition_dict
+def extract_dataset_row(eval_row, eval_index, eval_df, dataset_dir, eval_filename, strats=["multi-turn", "RAG", "COT", "FSP"]):
+    """
+    Example eval_filename: '/home/ubuntu/autoiac-tasks/evaluation/misc/ablation/../../../results-for-iac-eval (backup)/multi-turn/codellama-34b/george/evaluation-dataset-for-plain-dataset-george-existing-multi-turn.csv'
+    """
+    # Extract corresponding "data" dataset file name:
+    file_stem = Path(eval_filename).stem # https://stackoverflow.com/questions/678236/how-do-i-get-the-filename-without-the-extension-from-a-path-in-python
+    file_stem = file_stem.split("evaluation-dataset-for-")[1]
+    filename = ""
+    for i in strats:
+        if i in file_stem:
+            filename = file_stem.split("-{}".format(i))[0] + ".csv"
+    if filename == "":
+        filename = file_stem + ".csv"
+    filename = "difficulty-included-" + filename
+    containing_folder = os.path.basename(os.path.dirname(eval_filename)) # e.g., weijun
+    dataset_filename = os.path.join(dataset_dir, containing_folder, filename)
+    # Access dataset file and extract required row
+    df = pd.read_csv(dataset_filename, header=None)
+    # set the third row as the header
+    new_header = df.iloc[0]
+    df = df[1:]
+    df.columns = new_header
+    # # reset the index of the DataFrame
+    df.reset_index(drop=True, inplace=True)
+    # print(df.at[eval_index, "Prompt"])
+    # while True:
+    #     x=1
+    # print(df)
+    # assert df.at[eval_index, "Prompt"] == eval_row["Prompt"] # add this back in as needed. Removed for now since I might have updated some dataset rows after some eval was performed on the old version of the dataset..
+    return df, df.iloc[eval_index]
+def difficulty_retrieval(row, difficulty_header="Calculated Complexity"):
+    prompt = row["Prompt"]
+    if isinstance(prompt, float):
+        if math.isnan(prompt):
+            return
+    reference = row["Desired output"]
+    policy = row["Rego intent"]
+    print("Prompt:", prompt)
+    return row[difficulty_header]
+def difficulty_calculation(row, df, index, new_difficulty_headers=["Calculated Complexity"]):
+    prompt = row["Prompt"]
+    if isinstance(prompt, float):
+        if math.isnan(prompt):
+            return
+    reference = row["Desired output"]
+    policy = row["Rego intent"]
+    print("Prompt:", prompt)
+    complexity_level = calc_complexity(reference, prompt)
+    # ambiguity_level = calc_ambiguity(policy, prompt)
+    # print(complexity_level, ambiguity_level)
+    # print("Complexity level: ", complexity_level)
+    # print("Ambiguity level: ", ambiguity_level)
+    for header in new_difficulty_headers:
+        if "Complexity" in header:
+            df.at[index, header] = complexity_level
+        # elif "Ambiguity" in header:
+        #     df.at[index, header] = ambiguity_level
+    return complexity_level
+def calc_complexity(reference, prompt):
+    """
+        Calculate complexity based on LOC, num resources, and number of interconnections.
+    """
+    # Calculate LOC:
+    LOC = sum(not line.isspace() for line in StringIO(reference))
+    # print("LOC", LOC)
+    # Calculate number of resources:
+    # Count the number of occurences of the word "resource" in the reference string
+    num_resources = reference.count("resource")
+    # print("num_resources", num_resources)
+    # Calculate number of interconnections:
+    write_to_terraform(reference)
+    # run terraform plan and capture the output and errors
+    plan_file = "plan.out"
+    terraform_dir = "./misc/ablation/terraform_config"
+    output_json_file = "plan.json"
+    output_json_filepath = os.path.join(terraform_dir, output_json_file)
+    generate_terraform_plan_json(prompt, terraform_dir, plan_file, output_json_file)
+    # read the json file
+    # print("about to read json..")
+    with open(output_json_filepath, "r") as json_file:
+        data = json.load(json_file)
+        # extract the number of interconnections from the json file
+        config_graph = data["configuration"]["root_module"]["resources"]
+        references_list = list(findkeys(config_graph, "references")) # just a list with the word "references" repeated
+        # print(references_list)
+        num_interconnections = len(references_list)
+        # print("num_interconnections", num_interconnections)
+    # Determine complexity:
+    return get_complexity_level(LOC, num_resources, num_interconnections)
+def get_complexity_level(LOC, num_resources, num_interconnections):
+    if LOC < 10 and num_resources < 2 and num_interconnections < 2:
+        return "1"
+    if LOC < 20 and num_resources < 4 and num_interconnections < 4:
+        return "2"
+    if LOC < 40 and num_resources < 6 and num_interconnections < 6:
+        return "3"
+    if LOC < 60 and num_resources < 8 and num_interconnections < 8:
+        return "4"
+    if LOC < 80 and num_resources < 10 and num_interconnections < 10:
+        return "5"
+    if LOC >= 80 or num_resources >= 10 or num_interconnections >= 10:
+        return "6"
+def findkeys(node, kv):
+    # Modified from: https://stackoverflow.com/a/19871956/13336187
+    if isinstance(node, list):
+        for i in node:
+            for x in findkeys(i, kv):
+               yield x
+    elif isinstance(node, dict):
+        if kv in node:
+            yield kv
+        for j in node.values():
+            for x in findkeys(j, kv):
+                yield x
+# print(list(findkeys(d, 'id')))
+def write_to_terraform(result, terraform_dir="./misc/ablation/terraform_config"):
+    # define the path to the main.tf file
+    terraform_file_path = terraform_dir + "/metric-measurement-main.tf"
+    # open the file in write mode ('w') and write the result to it
+    # print("CWD", os.getcwd())
+    # print("CWD: {}".format(os.getcwd()))
+    with open(terraform_file_path, "w+", encoding="utf-8", errors="ignore") as file:
+        file.write(result)
+    # print(f"Updated main.tf at {terraform_file_path}")
+    # print(f"Updated main.tf at {terraform_file_path}")
+def generate_terraform_plan_json(prompt, terraform_dir="./misc/ablation/terraform_config", plan_file="plan.out", output_json_file="plan.json"):
+    cwd = os.getcwd()
+    # change to the Terraform directory
+    os.chdir(terraform_dir)
+    # run init before plan
+    init_result = subprocess.run(["terraform", "init"], capture_output=True, text=True)
+    # run 'terraform plan'
+    # result = subprocess.run(["terraform", "plan"], capture_output=True, text=True)
+    result_returned = False
+    # generate Terraform plan with the -no-color flag
+    for i in range(2): # try twice
+        try:
+            result = subprocess.run(
+                ["terraform", "plan", "-out", plan_file, "-no-color"], capture_output=True, text=True, timeout=300 # 5 minutes timeout (assume failed if timeout)
+            )
+            with open(
+                output_json_file, "w", encoding="utf-8", errors="ignore"
+            ) as json_file:
+                show_result = subprocess.run(
+                    ["terraform", "show", "-json", plan_file], check=True, stdout=json_file
+                )
+            result_returned = True
+            break
+        except Exception as e:
+            print("Error occurred for prompt \"{}\": {}".format(prompt, e))
+    # Return to parent directory
+    os.chdir(cwd)
+    if result_returned == False:
+        return "Plan timed-out. No output", "Plan timed-out. No error", False
+@click.command()
+@click.option(
+    "--samples",
+    "-n",
+    "samples",
+    type=int,
+    help="Number of samples per task.",
+    default=20,
+)
+def main(samples: int):
+    # Find dataset files:
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    eval_dataset_dir = os.path.join(script_dir, "../..", "results")
+    dataset_dir = os.path.join(script_dir, "../complete-dataset-measurement/complete-dataset")
+    # print()
+    excluded_dirs = ["llm-judge-evaluation-metric", "pass", # skip filenames containing "pass". will merge them into a regular file once done with eval..
+    "multi-turn", "RAG", "COT", "FSP"] # also skip these for now since we don't have the data: just add these back in once the data is ready and we're good to go
+    composition_dict = {
+        "gpt4": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "gpt3.5": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "gemini-1.0-pro": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-34b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-13b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-7b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "Magicoder_S_CL_7B": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "Wizardcoder33b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        }
+    }
+    eval_dataset_files, composition_dict = list_all_subdirectories(composition_dict, eval_dataset_dir, excluded_dirs)
+    eval_dataset_files = [f for f in eval_dataset_files if "test" not in f]
+    # print(eval_dataset_files)
+    with open(os.path.join(script_dir, 'input_composition_dict.json'), 'w') as fp:
+        json.dump(composition_dict, fp)
+    # while True:
+    #     x=1
+    print(composition_dict)
+    # metrics_included_dataset_dir = script_dir + "/ablation-dataset"
+    # create_new_dirs_for_metric(metrics_included_dataset_dir, dataset_files)
+    # dst_filenames = copy_csv_to_metric(dataset_files, difficulty_included_dataset_dir)
+    # # print(dst_filenames)
+    pass_k_parameters = {
+        "n": samples,
+        "k": [x for x in range(1, samples+1)]
+    }
+    output_composition_dict_filepath = os.path.join(script_dir, 'pass-k-output_composition_dict.json')
+    # Calculate regular metrics
+    output_composition_dict = metric_calculation_loop(composition_dict, dataset_dir, output_composition_dict_filepath, pass_k_parameters)
+    print("Output composition dict: ", pretty_json(output_composition_dict))
+    # print("complexity_distribution: ", pretty_json(complexity_distribution))
+    with open(output_composition_dict_filepath, 'w') as fp:
+        json.dump(output_composition_dict, fp)
+    # with open(os.path.join(script_dir, 'complexity_distribution.json'), 'w') as fp:
+    #     json.dump(complexity_distribution, fp)
+    # Calculate pass@k metric:
+    # print(metric_calculation_loop(composition_dict, pass_k_parameters))
+    # Display number of rows for each complexity level:
+if __name__ == "__main__":
+    main()

human_reference_dataset/iac-eval/evaluation/misc/ablation/ablation-iac-eval-pipeline.py ADDED Viewed

	@@ -0,0 +1,667 @@

+# Assumption: single file for each evaluated dataset. (e.g., no -pass5 and -pass1 in the same folder.)
+import csv
+import pandas as pd
+import logging
+import os
+from pathlib import Path
+from openai import AzureOpenAI
+import pandas as pd
+import json
+import math
+import subprocess
+import copy
+from io import StringIO
+import re
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
+import eval
+import metrics
+DELIMITERS = ["```hcl", "```json", "```HCL", "```Terraform", "```terraform", "```"] # ``` needs to be in the end, as it is a final "else" case
+LOG_FILE = "logs/eval-repair.log"
+class CustomFormatter(logging.Formatter):
+    # https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
+    grey = "\x1b[38;20m"
+    cyan = "\x1b[36;20m"
+    blue = "\x1b[34:20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    FORMATS = {
+        logging.DEBUG: cyan + format + reset,
+        logging.INFO: blue + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset
+    }
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+logger = logging.getLogger("iac-eval-repair")
+logger.setLevel(logging.DEBUG)
+#Setup File handler: https://stackoverflow.com/a/24507130/13336187
+file_handler = logging.FileHandler(LOG_FILE)
+file_handler.setFormatter(CustomFormatter())
+file_handler.setLevel(logging.DEBUG)
+#Setup Stream Handler (i.e. console)
+ch = logging.StreamHandler()
+ch.setLevel(logging.DEBUG)
+ch.setFormatter(CustomFormatter())
+# Log to both file and console:
+logger.addHandler(ch)
+logger.addHandler(file_handler)
+def pretty_json(obj):
+    return json.dumps(obj, sort_keys=True, indent=4, default=str)
+def estimator(n: int, c: int, k: int) -> float:
+    """
+    Calculates 1 - comb(n - c, k) / comb(n, k).
+    """
+    if n - c < k:
+        return 1.0
+    return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
+def list_all_subdirectories(composition_dict, data_dir, excluded_dirs, strats=["multi-turn", "RAG", "COT", "FSP"]):
+    # onlyfiles = [os.path.join(dirpath,f) for (dirpath, dirnames, filenames) if dirpath not in excluded_dirs in os.walk(data_dir) for f in filenames]
+    onlyfiles = []
+    for dirpath, dirnames, filenames in os.walk(data_dir):
+        # print(dirpath)
+        skip_dirname = False
+        for dir1 in excluded_dirs:
+            if dir1 in dirpath:
+                skip_dirname = True
+        if not skip_dirname:
+            for f in filenames:
+                skip_file = False
+                for exc in excluded_dirs:
+                    if exc in f:
+                        skip_file = True
+                if not skip_file:
+                    onlyfiles.append(os.path.join(dirpath, f))
+    # onlyfiles = [os.path.join(dirpath,f) for (dirpath, dirnames, filenames) in os.walk(data_dir) for f in filenames]
+    # print(onlyfiles)
+    onlyfilescsv = [f for f in onlyfiles if f.endswith(".csv")]
+    # composition_dict = {
+    #     "gpt4": {
+    #         "COT": {
+    #             "weijun": [],
+    # Append to composition dict:
+    for file1 in onlyfilescsv:
+        included = False
+        is_standard = True
+        for i in strats:
+            if i in file1:
+                is_standard = False
+        for model, model_dict in composition_dict.items():
+            for strat, student_dict in model_dict.items():
+                if is_standard:
+                    if strat != "Standard":
+                        continue
+                for student, dataset_list in student_dict.items():
+                    is_file = False
+                    if is_standard:
+                        if student in file1 and model in file1:
+                            is_file = True
+                    else:
+                        if student in file1 and strat in file1 and model in file1:
+                            is_file = True
+                    if is_file:
+                        if not included:
+                            composition_dict[model][strat][student].append(file1)
+                            included = True
+                        else:
+                            print("WARNING: This file attempted to be included multiple times: ", file1)
+        if not included:
+            print("WARNING: This file was excluded: ", file1)
+    return onlyfilescsv, composition_dict
+def create_new_dirs_for_metric(new_base_difficulty_dir, base_dataset_files):
+    os.makedirs(new_base_difficulty_dir, exist_ok=True)
+    for file in base_dataset_files:
+        containing_folder = os.path.basename(os.path.dirname(file)) # e.g., weijun
+        filename = os.path.basename(file) # e.g., plain-dataset.csv
+        # create the directory if it does not exist
+        new_dir_path = os.path.join(new_base_difficulty_dir, containing_folder)
+        # print(new_dir_path)
+        os.makedirs(new_dir_path, exist_ok=True)
+def metric_calculation_loop(composition_dict, dataset_dir, output_composition_dict_filepath, pass_k_parameters=None):
+    """
+    NOTE: pass@k calculation is limited to standard only for now.
+    NOTE: if pass_k_parameters is not None, then we will only calculate pass@k scores, and for standard only.
+    pass_k_parameters format example: {
+        "n" = 5,
+        "k" = [1,2,5],
+    }
+    Output format example (added in place to composition_dict): {
+        "gpt4": {
+            "Standard": {
+                ..., # whatever that is already in composition_dict
+                "iac_eval_accuracy": 0.3,
+                "tf_plan_only_accuracy": 0.4
+                "iac_eval_complexity_accuracy" : {
+                    "1": 0,
+                    "2": 0,
+                    "3": 0,
+                    "4": 0,
+                    "5": 0,
+                    "6": 0,
+                },
+                "pass@k" : {
+                    "n": 5 # just for record
+                    "1": 0.5,
+                    "2": 0.6,
+                    "5": 0.7,
+                }
+                "bleu_accuracy": 0.8,
+                "exact_match_accuracy": 0.5
+                # will add this in later once patch up llm-judge-eval.py:
+                # "llm-judge": {
+                #     "accuracy": 0.8,
+                #     "precision": 0.5,
+                #     "recall": 0.3
+                # }
+            },
+            "COT": ...
+        },
+        "gpt3.5": {
+            ...
+        },
+        ...
+    }
+    """
+    output_composition_dict = copy.deepcopy(composition_dict) # https://stackoverflow.com/questions/5105517/deep-copy-of-a-dict-in-python
+    # complexity_distribution = {
+    #     "level-1": 0,
+    #     "level-2": 0,
+    #     "level-3": 0,
+    #     "level-4": 0,
+    #     "level-5": 0,
+    #     "level-6": 0,
+    # }
+    for model, model_dict in composition_dict.items():
+            for strat, student_dict in model_dict.items():
+                if strat != "Standard":
+                    continue
+                num_success_both = 0 # pass iac_eval pipeline correctly
+                num_rows = 0
+                num_plan_success = 0
+                bleu_score_total = 0
+                bleu_score_total_correct = 0
+                bleu_score_total_incorrect = 0
+                exact_match_count = 0
+                false_positive_count = 0
+                false_negative_count = 0
+                codebert_metrics_total = {
+                    "precision": 0,
+                    "recall": 0,
+                    "f1": 0,
+                    "f3": 0,
+                    "f1-correct": 0,
+                    "f1-incorrect": 0,
+                }
+                passed_once = False
+                iac_eval_complexity_accuracy = {
+                    "1": {
+                        "num_success_both": 0,
+                        "num_rows": 0,
+                    },
+                    "2": {
+                        "num_success_both": 0,
+                        "num_rows": 0,
+                    },
+                    "3": {
+                        "num_success_both": 0,
+                        "num_rows": 0,
+                    },
+                    "4": {
+                        "num_success_both": 0,
+                        "num_rows": 0,
+                    },
+                    "5": {
+                        "num_success_both": 0,
+                        "num_rows": 0,
+                    },
+                    "6": {
+                        "num_success_both": 0,
+                        "num_rows": 0,
+                    }
+                }
+                if strat == "Standard" and pass_k_parameters:
+                    pass_at_k_scores = {}
+                    for i in pass_k_parameters:
+                        pass_at_k_scores[i] = {
+                            "score_now": 0,
+                            "num_rows": 0
+                        }
+                for student, dataset_list in student_dict.items():
+                    # n_total = 0 # number of trials that this student has been evaluated for. Used for pass@k's n parameter
+                    for file1 in dataset_list:
+                        # Go through each row
+                        df = pd.read_csv(file1)
+                        print(f"Begin calc metrics for dataset {file1}")
+                        # iterate through each row
+                        for index, row in df.iterrows():
+                            if isinstance(row["Prompt"], float):
+                                if math.isnan(row["Prompt"]):
+                                    continue
+                            passed_once = True
+                            # find specific column
+                            # print(index)
+                            # while True:
+                            #     x=1
+                            dataset_df, dataset_row = extract_dataset_row(row, index, df, dataset_dir, file1) # extract the corresponding row from the "data" dataset file
+                            complexity = difficulty_retrieval(dataset_row)
+                            # Calculate pass@k scores.
+                            if strat == "Standard" and pass_k_parameters:
+                                num_correct = 0
+                                columns = df.columns
+                                n_now = [c for c in columns if "LLM Plannable" in c]
+                                assert n_now == pass_k_parameters["n"]
+                                for i in range(n_now):
+                                    if row["LLM Plannable? #{}".format(i)] == True:
+                                        # num_plan_success += 1
+                                        if row["LLM Correct? #{}".format(i)] == "Success":
+                                            num_correct += 1
+                                for k, attrs in pass_at_k_scores.items():
+                                    attrs["score_now"] += estimator(
+                                                pass_k_parameters["n"], num_correct, k
+                                            )
+                                    attrs["num_rows"] += 1
+                            else: # this includes strat == "Standard" but pass_k_parameters is not provided
+                                # print(row)
+                                # if row["LLM Plannable? #0"] != False:
+                                #     while True:
+                                #         x=1
+                                reference = row["Reference output"]
+                                try:
+                                    answer, candidate = eval.separate_answer_and_code(row["LLM Output #0"], DELIMITERS)
+                                except Exception as e:
+                                    s = str(e)
+                                    print(s)
+                                    if "'float' object has no attribute 'split'" in s:
+                                        candidate = ""
+                                # print(complexity)
+                                iac_eval_complexity_accuracy[complexity]["num_rows"] += 1
+                                num_rows += 1
+                                bleu_score_total += metrics.bleu_score(reference, candidate)
+                                exact_match_count += 1 if metrics.exact_match(reference, candidate) else 0
+                                codebert_metrics = metrics.get_code_bert_score(reference, candidate, row["Prompt"])
+                                codebert_metrics_total["precision"] += codebert_metrics["precision"]
+                                codebert_metrics_total["recall"] += codebert_metrics["recall"]
+                                codebert_metrics_total["f1"] += codebert_metrics["f1"]
+                                codebert_metrics_total["f3"] += codebert_metrics["f3"]
+                                is_correct = False
+                                if row["LLM Plannable? #0"] == True: # we use #0 even if it is possible that a mistake was made somewhere and we evaluated e.g., FSP twice.
+                                    num_plan_success += 1
+                                    print("num_plan_success: ", num_plan_success)
+                                    if row["LLM Correct? #0"] == "Success":
+                                            num_success_both += 1
+                                            is_correct = True
+                                            # while True:
+                                            #     x=1
+                                            print("num_success_both: ", num_success_both)
+                                            iac_eval_complexity_accuracy[complexity]["num_success_both"] += 1
+                                if is_correct:
+                                    bleu_score_total_correct += metrics.bleu_score(reference, candidate)
+                                    codebert_metrics_total["f1-correct"] += codebert_metrics["f1"]
+                                else:
+                                    bleu_score_total_incorrect += metrics.bleu_score(reference, candidate)
+                                    codebert_metrics_total["f1-incorrect"] += codebert_metrics["f1"]
+                            # complexity_distribution = update_complexity_distribution(complexity, complexity_distribution)
+                            # print(f"Complexity distribution now: {complexity_distribution}")
+                        # df.to_csv(file1, index=False, encoding="utf-8")
+                        print(f"Finished calc metrics for dataset {file1}")
+                if not passed_once:
+                    continue
+                # Calculate pass@k scores
+                if strat == "Standard" and pass_k_parameters:
+                    output_composition_dict[model][strat]["pass@k"] = {
+                                                                        "n": pass_k_parameters["n"]
+                                                                    }
+                    for k, attrs in pass_at_k_scores.items():
+                        output_composition_dict[model][strat]["pass@k"][k] = attrs["score_now"]/attrs["num_rows"]
+                else: # Calculate metric scores
+                    output_composition_dict[model][strat]["iac_eval_accuracy"] = num_success_both / num_rows
+                    output_composition_dict[model][strat]["tf_plan_only_accuracy"] = num_plan_success / num_rows
+                    output_composition_dict[model][strat]["iac_eval_complexity_accuracy"] = {}
+                    for level, attrs in iac_eval_complexity_accuracy.items():
+                        # print("iac_eval_complexity_accuracy: ", iac_eval_complexity_accuracy)
+                        # print("level: ", level)
+                        # print("attrs: ", attrs)
+                        # print("output_composition_dict[model][strat][iac_eval_complexity_accuracy] :", output_composition_dict[model][strat]["iac_eval_complexity_accuracy"])
+                        # print(output_composition_dict[model][strat]["iac_eval_complexity_accuracy"][level])
+                        # print(attrs["num_success_both"])
+                        # print(attrs["num_rows"])
+                        if attrs["num_rows"] == 0:
+                            output_composition_dict[model][strat]["iac_eval_complexity_accuracy"][level] = 0
+                        else:
+                            output_composition_dict[model][strat]["iac_eval_complexity_accuracy"][level] = attrs["num_success_both"]/attrs["num_rows"]
+                    output_composition_dict[model][strat]["bleu_accuracy"] = bleu_score_total / num_rows
+                    if num_success_both == 0:
+                        output_composition_dict[model][strat]["bleu_accuracy_correct"] = 0
+                    else:
+                        output_composition_dict[model][strat]["bleu_accuracy_correct"] = bleu_score_total_correct / num_success_both
+                    output_composition_dict[model][strat]["bleu_accuracy_incorrect"] = bleu_score_total_incorrect / (num_rows - num_success_both)
+                    output_composition_dict[model][strat]["exact_match_accuracy"] = exact_match_count / num_rows
+                    output_composition_dict[model][strat]["codebert_metrics"] = {
+                        "precision": codebert_metrics_total["precision"] / num_rows,
+                        "recall": codebert_metrics_total["recall"] / num_rows,
+                        "f1": codebert_metrics_total["f1"] / num_rows,
+                        "f3": codebert_metrics_total["f3"] / num_rows,
+                        "f1-incorrect": codebert_metrics_total["f1-incorrect"] / (num_rows - num_success_both)
+                    }
+                    if num_success_both == 0:
+                        output_composition_dict[model][strat]["codebert_metrics"]["f1-correct"] = 0
+                    else:
+                        output_composition_dict[model][strat]["codebert_metrics"]["f1-correct"] = codebert_metrics_total["f1-correct"] / num_success_both
+                with open(output_composition_dict_filepath, 'w') as fp: # incremental updates
+                    json.dump(output_composition_dict, fp)
+    return output_composition_dict
+def extract_dataset_row(eval_row, eval_index, eval_df, dataset_dir, eval_filename, strats=["multi-turn", "RAG", "COT", "FSP"]):
+    """
+    Example eval_filename: '/home/ubuntu/autoiac-tasks/evaluation/misc/ablation/../../../results-for-iac-eval (backup)/multi-turn/codellama-34b/george/evaluation-dataset-for-plain-dataset-george-existing-multi-turn.csv'
+    """
+    # Extract corresponding "data" dataset file name:
+    file_stem = Path(eval_filename).stem # https://stackoverflow.com/questions/678236/how-do-i-get-the-filename-without-the-extension-from-a-path-in-python
+    file_stem = file_stem.split("evaluation-dataset-for-")[1]
+    filename = ""
+    for i in strats:
+        if i in file_stem:
+            filename = file_stem.split("-{}".format(i))[0] + ".csv"
+    if filename == "":
+        filename = file_stem + ".csv"
+    # filename = "completed-" + filename
+    containing_folder = os.path.basename(os.path.dirname(eval_filename)) # e.g., weijun
+    dataset_filename = os.path.join(dataset_dir, containing_folder, filename)
+    # Access dataset file and extract required row
+    df = pd.read_csv(dataset_filename, header=None)
+    # set the third row as the header
+    new_header = df.iloc[0]
+    df = df[1:]
+    df.columns = new_header
+    # # reset the index of the DataFrame
+    df.reset_index(drop=True, inplace=True)
+    # print(df.at[eval_index, "Prompt"])
+    # while True:
+    #     x=1
+    # print(df)
+    # assert df.at[eval_index, "Prompt"] == eval_row["Prompt"] # add this back in as needed. Removed for now since I might have updated some dataset rows after some eval was performed on the old version of the dataset..
+    return df, df.iloc[eval_index]
+def difficulty_retrieval(row, difficulty_header="Difficulty"):
+    prompt = row["Prompt"]
+    reference = row["Reference output"]
+    policy = row["Rego intent"]
+    print("Prompt:", prompt)
+    return str(int(float(row[difficulty_header])))
+def write_to_terraform(result, terraform_dir="./misc/ablation/terraform_config"):
+    # define the path to the main.tf file
+    terraform_file_path = terraform_dir + "/metric-measurement-main.tf"
+    # open the file in write mode ('w') and write the result to it
+    # print("CWD", os.getcwd())
+    # print("CWD: {}".format(os.getcwd()))
+    with open(terraform_file_path, "w+", encoding="utf-8", errors="ignore") as file:
+        file.write(result)
+    # print(f"Updated main.tf at {terraform_file_path}")
+    # print(f"Updated main.tf at {terraform_file_path}")
+def generate_terraform_plan_json(prompt, terraform_dir="./misc/ablation/terraform_config", plan_file="plan.out", output_json_file="plan.json"):
+    cwd = os.getcwd()
+    # change to the Terraform directory
+    os.chdir(terraform_dir)
+    # run init before plan
+    init_result = subprocess.run(["terraform", "init"], capture_output=True, text=True)
+    # run 'terraform plan'
+    # result = subprocess.run(["terraform", "plan"], capture_output=True, text=True)
+    result_returned = False
+    # generate Terraform plan with the -no-color flag
+    for i in range(2): # try twice
+        try:
+            result = subprocess.run(
+                ["terraform", "plan", "-out", plan_file, "-no-color"], capture_output=True, text=True, timeout=300 # 5 minutes timeout (assume failed if timeout)
+            )
+            with open(
+                output_json_file, "w", encoding="utf-8", errors="ignore"
+            ) as json_file:
+                show_result = subprocess.run(
+                    ["terraform", "show", "-json", plan_file], check=True, stdout=json_file
+                )
+            result_returned = True
+            break
+        except Exception as e:
+            print("Error occurred for prompt \"{}\": {}".format(prompt, e))
+    # Return to parent directory
+    os.chdir(cwd)
+    if result_returned == False:
+        return "Plan timed-out. No output", "Plan timed-out. No error", False
+def main():
+    # Find dataset files:
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    eval_dataset_dir = os.path.join(script_dir, "../..", "results")
+    dataset_dir = os.path.join(script_dir, "../../../data")
+    # print()
+    excluded_dirs = ["llm-judge-evaluation-metric", "pass"] # skip filenames containing "pass". will merge them into a regular file once done with eval..
+    composition_dict = {
+        "gpt4": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "gpt3.5": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "gemini-1.0-pro": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-34b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-13b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "codellama-7b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "Magicoder_S_CL_7B": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        },
+        "Wizardcoder33b": {
+            "COT": {
+                "complete": [],
+            },
+            "FSP": {
+                "complete": [],
+            },
+            "multi-turn": {
+                "complete": [],
+            },
+            "RAG": {
+                "complete": [],
+            },
+            "Standard": {
+                "complete": [],
+            },
+        }
+    }
+    eval_dataset_files, composition_dict = list_all_subdirectories(composition_dict, eval_dataset_dir, excluded_dirs)
+    eval_dataset_files = [f for f in eval_dataset_files if "test" not in f]
+    # print(eval_dataset_files)
+    with open(os.path.join(script_dir, 'input_composition_dict.json'), 'w') as fp:
+        json.dump(composition_dict, fp)
+    print(composition_dict)
+    output_composition_dict_filepath = os.path.join(script_dir, 'output_composition_dict.json')
+    # Calculate regular metrics
+    output_composition_dict = metric_calculation_loop(composition_dict, dataset_dir, output_composition_dict_filepath)
+    print("Output composition dict: ", pretty_json(output_composition_dict))
+    with open(output_composition_dict_filepath, 'w') as fp:
+        json.dump(output_composition_dict, fp)
+if __name__ == "__main__":
+    main()

human_reference_dataset/iac-eval/evaluation/misc/complete-dataset-measurement/complete-dataset-measurement.py ADDED Viewed

	@@ -0,0 +1,606 @@

+# Complexity: LOC, num resources, and number of interconnections.
+# Ambiguity: LLM-judge
+import os
+from pathlib import Path
+import pandas as pd
+import json
+import math
+import statistics
+import time
+import subprocess
+import numpy
+from io import StringIO
+import re
+from collections import defaultdict
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", "evaluation")))
+import models
+import eval
+def extract_filename(input_string):
+    # Define the regular expression pattern to match filenames within quotes that end with .html or .js
+    pattern = r'"([^"]+\.(html|js|txt|csv|zip|py|pub|yml|yaml))"'
+    # Search for the pattern in the input string
+    match = re.search(pattern, input_string)
+    # Return the matched filename without quotes or None if no match is found
+    return match.group(1) if match else None
+def list_all_subdirectories(data_dir):
+    onlyfiles = [os.path.join(dirpath,f) for (dirpath, dirnames, filenames) in os.walk(data_dir) for f in filenames]
+    onlyfilescsv = [f for f in onlyfiles if f.endswith(".csv")]
+    return onlyfilescsv
+def create_new_dirs_for_metric(new_base_difficulty_dir, base_dataset_files):
+    os.makedirs(new_base_difficulty_dir, exist_ok=True)
+    for file in base_dataset_files:
+        containing_folder = os.path.basename(os.path.dirname(file)) # e.g., weijun
+        filename = os.path.basename(file) # e.g., plain-dataset.csv
+        # create the directory if it does not exist
+        new_dir_path = os.path.join(new_base_difficulty_dir, containing_folder)
+        # print(new_dir_path)
+        os.makedirs(new_dir_path, exist_ok=True)
+def copy_csv_to_metric(base_files, new_base_difficulty_dir):
+    """
+        Example:
+            base_files: ["../data/george/evaluation-dataset-george-gpt3.5.csv"]
+    """
+    dst_filenames = []
+    for file in base_files:
+        file_stem = Path(file).stem # https://stackoverflow.com/questions/678236/how-do-i-get-the-filename-without-the-extension-from-a-path-in-python
+        containing_folder = os.path.basename(os.path.dirname(file)) # e.g., weijun
+        filename =  "completed-" + file_stem + ".csv"
+        dest_file_path = os.path.join(new_base_difficulty_dir, containing_folder, filename)
+        # print(dest_file_path)
+        dst_filenames.append(dest_file_path)
+        df = pd.read_csv(file, header=None)
+        new_header = df.iloc[0]
+        df = df[1:]
+        df.columns = new_header
+        # reset the index of the DataFrame
+        df.reset_index(drop=True, inplace=True)
+        # add new columns only to df
+        # for header in new_difficulty_headers:
+        #     df[header] = ""
+        df.to_csv(dest_file_path, index=False, encoding="utf-8")
+        print(f"Copied and modified CSV to: {dest_file_path}")
+    return dst_filenames
+def difficulty_and_resource_calculation_loop(dst_filenames, script_dir):
+    actual_resource_distribution = defaultdict(int)  # e.g., "aws_linux_virtual_machine..." : 1
+    complexity_distribution = {
+        "level-1": 0,
+        "level-2": 0,
+        "level-3": 0,
+        "level-4": 0,
+        "level-5": 0,
+        "level-6": 0,
+    }
+    ambiguity_distribution = {
+        "level-1": 0,
+        "level-2": 0,
+        "level-3": 0,
+        "level-4": 0,
+        "level-5": 0,
+        "level-6": 0,
+    }
+    intent_loc_list = []
+    config_metrics = {
+        "loc_list": [],  # LOC for each row's config
+        "interconnections_list": [], # num of interconnections for each row's config
+        "resources_list": [] # num of resources for each row's config
+    }
+    for file in dst_filenames:
+        df = pd.read_csv(file)
+        print(f"Begin calc difficulty for dataset {file}")
+        # iterate through each row
+        for index, row in df.iterrows():
+            # iterate every row
+            # find specific column
+            complexity, resources, intent_loc, config_metric = difficulty_and_resources_calculation(row, df, index)
+            if complexity is None:
+                continue
+            intent_loc_list.append(intent_loc)
+            config_metrics["loc_list"].append(config_metric[0])
+            config_metrics["resources_list"].append(config_metric[1])
+            config_metrics["interconnections_list"].append(config_metric[2])
+            for resource in resources:
+                actual_resource_distribution[resource] += 1
+            complexity_distribution = update_complexity_distribution(complexity, complexity_distribution)
+            # ambiguity_distribution = update_ambiguity_distribution(ambiguity, ambiguity_distribution)
+            print(f"Complexity distribution now: {complexity_distribution}")
+            print("Raw resource distribution: ", actual_resource_distribution)
+            # print(f"Ambiguity distribution now: {ambiguity_distribution}")
+        df.to_csv(file, index=False, encoding="utf-8")
+        print(f"Finished calc difficulty for dataset {file}")
+    print(f"Final Complexity distribution: {complexity_distribution}")
+    with open(os.path.join(script_dir, 'complexity_distribution.json'), 'w') as fp:
+        json.dump(complexity_distribution, fp)
+    print("Final Raw resource distribution: ", actual_resource_distribution)
+    with open(os.path.join(script_dir, 'actual_resource_distribution.json'), 'w') as fp:
+        json.dump(actual_resource_distribution, fp)
+    get_statistics(intent_loc_list, "Intent LOC")
+    get_statistics(config_metrics["loc_list"], "Config LOC")
+    get_statistics(config_metrics["resources_list"], "Config resource count")
+    get_statistics(config_metrics["interconnections_list"], "Config interconnection count")
+    refined_resource_distribution = get_refined_resource_distribution(actual_resource_distribution)
+    print("Final refined resource distribution: ", refined_resource_distribution)
+    with open(os.path.join(script_dir, 'refined_resource_distribution.json'), 'w') as fp:
+        json.dump(refined_resource_distribution, fp)
+def get_refined_resource_distribution(raw_dist):
+    """
+        raw_dist format: {
+            "aws_lightsail_instance": 1,
+            "aws_s3": 1,
+            ...
+        }
+    """
+    refined_dist = defaultdict(int)
+    for resource, count in raw_dist.items():
+        if "aws_lightsail" in resource:
+            refined_dist["aws_lightsail"] += count
+        elif "aws_s3" in resource or "aws_glacier" in resource:
+            refined_dist["aws_s3"] += count
+        elif "aws_sns" in resource:
+            refined_dist["aws_sns"] += count
+        elif "aws_iam" in resource:
+            refined_dist["aws_iam"] += count
+        elif "aws_instance" in resource or "aws_ec2" in resource or "aws_ami" in resource or "aws_launch_template" in resource or "aws_placement_group" in resource or "aws_key_pair" in resource:
+            refined_dist["aws_ec2"] += count
+        elif "aws_lb" in resource or "aws_elb" in resource:
+            refined_dist["aws_elb"] += count
+        elif "aws_vpc" in resource or "aws_subnet" in resource or "aws_eip" in resource or "aws_egress_only_internet_gateway" in resource or "aws_default_network_acl" in resource or "aws_internet_gateway" in resource or "aws_route_table" in resource or "aws_network_acl" in resource or "aws_vpc_peering_connection" in resource or "aws_nat_gateway" in resource:
+            refined_dist["aws_vpc"] += count
+        elif "aws_db" in resource or "aws_rds_cluster" in resource:
+            refined_dist["aws_rds"] += count
+        elif "aws_security_group" in resource:
+            refined_dist["aws_security_group"] += count
+        elif "aws_cognito" in resource:
+            refined_dist["aws_cognito"] += count
+        elif "aws_secretsmanager" in resource:
+            refined_dist["aws_secretsmanager"] += count
+        elif "aws_backup" in resource:
+            refined_dist["aws_backup"] += count
+        elif "aws_dynamodb" in resource or "aws_dax" in resource:
+            refined_dist["aws_dynamodb"] += count
+        elif "aws_kms" in resource:
+            refined_dist["aws_kms"] += count
+        elif "aws_efs" in resource:
+            refined_dist["aws_efs"] += count
+        elif "aws_msk" in resource:
+            refined_dist["aws_msk"] += count
+        elif "aws_cloudwatch" in resource:
+            refined_dist["aws_cloudwatch"] += count
+        elif "aws_kinesis" in resource:
+            refined_dist["aws_kinesis"] += count
+        elif "aws_autoscaling_group" in resource:
+            refined_dist["aws_autoscaling_group"] += count
+        elif "aws_elasticache" in resource:
+            refined_dist["aws_elasticache"] += count
+        elif "aws_redshift" in resource:
+            refined_dist["aws_redshift"] += count
+        elif "aws_lambda" in resource:
+            refined_dist["aws_lambda"] += count
+        elif "aws_sagemaker" in resource:
+            refined_dist["aws_sagemaker"] += count
+        elif "aws_eks" in resource:
+            refined_dist["aws_eks"] += count
+        elif "aws_codebuild" in resource:
+            refined_dist["aws_codebuild"] += count
+        elif "aws_api_gateway" in resource:
+            refined_dist["aws_api_gateway"] += count
+        elif "aws_cloudfront" in resource:
+            refined_dist["aws_cloudfront"] += count
+        elif "aws_route53" in resource:
+            refined_dist["aws_route53"] += count
+        elif "aws_lex" in resource:
+            refined_dist["aws_lex"] += count
+        elif "aws_connect" in resource:
+            refined_dist["aws_connect"] += count
+        elif "aws_elasticsearch" in resource or "aws_opensearch" in resource:
+            refined_dist["aws_elasticsearch"] += count
+        elif "aws_kendra" in resource:
+            refined_dist["aws_kendra"] += count
+        elif "aws_elastic_beanstalk" in resource:
+            refined_dist["aws_elastic_beanstalk"] += count
+        elif "aws_sqs" in resource:
+            refined_dist["aws_sqs"] += count
+        elif "aws_neptune" in resource:
+            refined_dist["aws_neptune"] += count
+        elif "aws_chime" in resource:
+            refined_dist["aws_chime"] += count
+        else:
+            refined_dist[resource] += count
+    return refined_dist
+def get_statistics(list1, list1_name):
+    list1 = sorted(list1)
+    x = numpy.quantile(list1, [0,0.25,0.5,0.75,1])
+    min1 = x[0]
+    max1 = x[4]
+    median = x[2]
+    q1 = x[1]
+    q3 = x[3]
+    print(list1_name + " three quartiles: ", q1, median, q3)
+    print(list1_name + " mean: ", statistics.mean(list1))
+    print(list1_name + " min: ", min1)
+    print(list1_name + " max: ", max1)
+def update_complexity_distribution(complexity, complexity_distribution):
+    if complexity == "1":
+        complexity_distribution["level-1"] += 1
+    elif complexity == "2":
+        complexity_distribution["level-2"] += 1
+    elif complexity == "3":
+        complexity_distribution["level-3"] += 1
+    elif complexity == "4":
+        complexity_distribution["level-4"] += 1
+    elif complexity == "5":
+        complexity_distribution["level-5"] += 1
+    elif complexity == "6":
+        complexity_distribution["level-6"] += 1
+    return complexity_distribution
+def difficulty_and_resources_calculation(row, df, index):
+    prompt = row["Prompt"]
+    if isinstance(prompt, float):
+        if math.isnan(prompt):
+            return None, None, None, None
+    reference = row["Reference output"]
+    policy = row["Rego intent"]
+    print("Prompt:", prompt)
+    difficulty_level, resource_list, intent_loc, config_metric = calc_difficulty_and_resources(reference, policy, prompt)
+    print("Difficulty level: ", difficulty_level)
+    df.at[index, "Difficulty"] = difficulty_level
+    df.at[index, "Resource"] = ', '.join(resource_list)
+    return difficulty_level, resource_list, intent_loc, config_metric
+def calc_difficulty_and_resources(reference, intent, prompt):
+    """
+        (1) Calculate difficulty based on LOC, num resources, and number of interconnections.
+        (2) Obtain all resources, and returns a resource list
+        (3) calculate intent loc
+    """
+    # Calculate LOC:
+    LOC = sum(not line.isspace() for line in StringIO(reference))
+    print("LOC", LOC)
+    # Calculate intent LOC:
+    intent_loc = sum(not line.isspace() for line in StringIO(intent))
+    print("Intent LOC: ", intent_loc)
+    # Calculate number of resources:
+    # Count the number of occurences of the word "resource" in the reference string
+    num_resources = reference.count("resource")
+    print("num_resources", num_resources)
+    terraform_dir = "./misc/complete-dataset-measurement/terraform_config"
+    eval.delete_all_files_in_directory(terraform_dir)
+    # Calculate number of interconnections:
+    write_to_terraform(reference)
+    # run terraform plan and capture the output and errors
+    plan_file = "plan.out"
+    output_json_file = "plan.json"
+    output_json_filepath = os.path.join(terraform_dir, output_json_file)
+    generate_terraform_plan_json(prompt, terraform_dir, plan_file, output_json_file)
+    # Check that Rego intents are correct/parsable:
+    rego_dir = "./misc/complete-dataset-measurement/rego_config"
+    rego_policy_filepath = rego_dir + "/policy.rego"
+    eval.write_to_rego(intent, rego_policy_filepath)
+    opa_result, opa_error = eval.OPA_Rego_evaluation(output_json_filepath, rego_policy_filepath)
+    if "OPA exception occurred" in opa_error:
+        sys.exit(opa_error)
+    # read the json file
+    # print("about to read json..")
+    resource_list = []
+    with open(output_json_filepath, "r") as json_file:
+        data = json.load(json_file)
+        # extract the number of interconnections from the json file
+        config_graph = data["configuration"]["root_module"]["resources"]
+        for i in config_graph:
+            resource_list.append(i["type"])
+        references_list = list(findkeys(config_graph, "references")) # just a list with the word "references" repeated
+        # print(references_list)
+        num_interconnections = len(references_list)
+        print("num_interconnections", num_interconnections)
+    print("Resources found: ", resource_list)
+    # Determine difficulty:
+    return get_difficulty_level(LOC, num_resources, num_interconnections), resource_list, intent_loc, [LOC, num_resources, num_interconnections]
+def get_difficulty_level(LOC, num_resources, num_interconnections):
+    if LOC < 10 and num_resources < 2 and num_interconnections < 2:
+        return "1"
+    if LOC < 20 and num_resources < 4 and num_interconnections < 4:
+        return "2"
+    if LOC < 40 and num_resources < 6 and num_interconnections < 6:
+        return "3"
+    if LOC < 60 and num_resources < 8 and num_interconnections < 8:
+        return "4"
+    if LOC < 80 and num_resources < 10 and num_interconnections < 10:
+        return "5"
+    if LOC >= 80 or num_resources >= 10 or num_interconnections >= 10:
+        return "6"
+def findkeys(node, kv):
+    # Modified from: https://stackoverflow.com/a/19871956/13336187
+    if isinstance(node, list):
+        for i in node:
+            for x in findkeys(i, kv):
+               yield x
+    elif isinstance(node, dict):
+        if kv in node:
+            yield kv
+        for j in node.values():
+            for x in findkeys(j, kv):
+                yield x
+# print(list(findkeys(d, 'id')))
+def write_to_terraform(result, terraform_dir="./misc/complete-dataset-measurement/terraform_config"):
+    # define the path to the main.tf file
+    terraform_file_path = terraform_dir + "/complete-measurement-main.tf"
+    os.makedirs(terraform_dir, exist_ok=True)
+    # open the file in write mode ('w') and write the result to it
+    # print("CWD", os.getcwd())
+    print("CWD: {}".format(os.getcwd()))
+    with open(terraform_file_path, "w+", encoding="utf-8", errors="ignore") as file:
+        file.write(result)
+    # print(f"Updated main.tf at {terraform_file_path}")
+    print(f"Updated main.tf at {terraform_file_path}")
+def plan_error_handling(result):
+    error_handled = False
+    if "Inconsistent dependency lock file" in result.stderr:
+        init_result = subprocess.run(["terraform", "init"], capture_output=True, text=True)
+        time.sleep(5)
+        error_handled = True
+    # assumes only one missing file, at least per iteration..
+    elif "archive missing file: " in result.stderr: # error seen in data "archive_file"
+        print("Missing archive file... trying again. Result stderr is: ")
+        print(result.stderr)
+        for item in result.stderr.split("\n"): # Get line containing string: https://stackoverflow.com/questions/2557808/search-and-get-a-line-in-python
+            missing_filename = extract_filename(item)
+            if missing_filename is not None:
+                with open(missing_filename, "w") as file:
+                    print("Creating missing archive file: ", missing_filename)
+                    file.write("random")
+                    error_handled = True
+    elif "no file exists at" in result.stderr: # error seen in file("sagemaker-human-task-ui-template.html") attribute value
+        print("Missing file... trying again. Result stderr is: ")
+        print(result.stderr)
+        for item in result.stderr.split("\n"): # Get line containing string: https://stackoverflow.com/questions/2557808/search-and-get-a-line-in-python
+            missing_filename = extract_filename(item)
+            if missing_filename is not None:
+                with open(missing_filename, "w") as file:
+                    print("Creating missing file: ", missing_filename)
+                    file.write("random")
+                    error_handled = True
+    return error_handled
+def generate_terraform_plan_json(prompt, terraform_dir="./misc/complete-dataset-measurement/terraform_config", plan_file="plan.out", output_json_file="plan.json"):
+    cwd = os.getcwd()
+    # change to the Terraform directory
+    os.chdir(terraform_dir)
+    for i in range(3): # try twice
+        try:
+            # run init before plan
+            result = subprocess.run(["terraform", "init"], capture_output=True, text=True)
+            error_handled = plan_error_handling(result)
+            if error_handled:
+                continue
+            # generate Terraform plan with the -no-color flag
+            result = subprocess.run(
+                ["terraform", "plan", "-out", plan_file, "-no-color"], capture_output=True, text=True, timeout=60
+            )
+            error_handled = plan_error_handling(result)
+            if error_handled:
+                continue
+            with open(
+                output_json_file, "w", encoding="utf-8", errors="ignore"
+            ) as json_file:
+                result = subprocess.run(
+                    ["terraform", "show", "-json", plan_file], check=True, stdout=json_file
+                )
+            break
+        except Exception as e:
+            print("Error occurred for prompt \"{}\": {}".format(prompt, e))
+    # Return to parent directory
+    os.chdir(cwd)
+def main():
+    # Find dataset files:
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    dataset_dir = os.path.join(script_dir, "../../..", "data")
+    # dataset_dir = os.path.join(script_dir, "../../..", "delete-later-fake-complete")
+    # print()
+    dataset_files = list_all_subdirectories(dataset_dir)
+    dataset_files = [f for f in dataset_files if "test" not in f]
+    print(dataset_files)
+    difficulty_included_dataset_dir = script_dir + "/complete-dataset"
+    create_new_dirs_for_metric(difficulty_included_dataset_dir, dataset_files)
+    dst_filenames = copy_csv_to_metric(dataset_files, difficulty_included_dataset_dir)
+    # print(dst_filenames)
+    difficulty_and_resource_calculation_loop(dst_filenames, script_dir)
+    # Display number of rows for each complexity level:
+if __name__ == "__main__":
+    main()
+#     reference = """
+# terraform {
+#   required_providers {
+#     aws = {
+#       source  = "hashicorp/aws"
+#       version = "~> 4.16"
+#     }
+#   }
+#   required_version = ">= 1.2.0"
+# }
+# # Define the provider block for AWS
+# provider "aws" {
+#   region = "us-east-2" # Set your desired AWS region
+# }
+# variable "vpc_id" {
+#   type        = string
+#   description = "The VPC to deploy the components within"
+#   default    = "vpc-12345678"
+# }
+# variable "pg_port" {
+#   type        = number
+#   description = "Postgres connection port"
+#   default     = 5432
+# }
+# variable "pg_superuser_username" {
+#   type        = string
+#   description = "Username for the 'superuser' user in the Postgres instance"
+#   default     = "superuser"
+# }
+# variable "pg_superuser_password" {
+#   type        = string
+#   sensitive   = true
+#   description = "Password for the 'superuser' user in the Postgres instance"
+#   default = "random-password"
+# }
+# resource "aws_db_subnet_group" "postgres" {
+#   name       = "pgsubnetgrp"
+#   subnet_ids = [aws_subnet.main1.id, aws_subnet.main2.id]
+# }
+# resource "aws_subnet" "main1" {
+#   vpc_id     = var.vpc_id
+#   cidr_block = "10.0.1.0/24"
+#   tags = {
+#     Name = "Main"
+#   }
+# }
+# resource "aws_subnet" "main2" {
+#   vpc_id     = var.vpc_id
+#   cidr_block = "10.0.1.0/24"
+#   tags = {
+#     Name = "Main"
+#   }
+# }
+# resource "aws_db_parameter_group" "postgres" {
+#   name   = "pgparamgrp15"
+#   family = "postgres15"
+#   parameter {
+#     name  = "password_encryption"
+#     value = "scram-sha-256"
+#   }
+#   parameter {
+#     name  = "rds.force_ssl"
+#     value = "0"
+#   }
+#   lifecycle {
+#     create_before_destroy = true
+#   }
+# }
+# resource "aws_security_group" "pg" {
+#   name   = "pg"
+#   vpc_id = var.vpc_id
+#   ingress {
+#     description = "Postgres from internet"
+#     from_port   = 5432
+#     to_port     = 5432
+#     cidr_blocks = ["0.0.0.0/0"]
+#     protocol    = "TCP"
+#     self        = false
+#   }
+#   egress {
+#     description = "Postgres to internet"
+#     from_port   = 5432
+#     to_port     = 5432
+#     cidr_blocks = ["0.0.0.0/0"]
+#     protocol    = "TCP"
+#     self        = false
+#   }
+# }
+# resource "aws_kms_key" "rds_key" {
+#   description             = "kmsrds"
+#   deletion_window_in_days = 14
+#   tags                    = { Name = "kmsrds" }
+# }
+# resource "aws_db_instance" "postgres" {
+#   identifier                      = "pg"
+#   final_snapshot_identifier       = "pgsnapshot"
+#   allocated_storage               = 20
+#   apply_immediately               = true
+#   backup_retention_period         = 7
+#   db_subnet_group_name            = aws_db_subnet_group.postgres.name
+#   parameter_group_name            = aws_db_parameter_group.postgres.name
+#   enabled_cloudwatch_logs_exports = ["postgresql", "upgrade"]
+#   engine                          = "postgres"
+#   engine_version                  = "15"
+#   allow_major_version_upgrade     = true
+#   instance_class                  = "db.t3.micro"
+#   db_name                         = "postgres" # Initial database name
+#   username                        = var.pg_superuser_username
+#   port                            = var.pg_port
+#   password                        = var.pg_superuser_password
+#   vpc_security_group_ids          = [aws_security_group.pg.id]
+#   # Other security settings
+#   publicly_accessible = false
+#   multi_az            = true
+#   storage_encrypted   = true
+#   kms_key_id          = aws_kms_key.rds_key.arn
+#   # Default daily backup window
+#   # https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html#USER_WorkingWithAutomatedBackups.BackupWindow
+# }
+# """
+#     prompt = "provisions a secure PostgreSQL database instance within a specified AWS VPC, leveraging AWS services like RDS, subnets, and KMS for encryption. It sets up two subnets within the VPC for the database, a custom parameter group for PostgreSQL settings, and a security group to manage access. The database instance is configured with specifics storage size is 20GB, engine version is 15,  multi-AZ deployment for high availability, and encryption using a KMS key."
+#     print(calc_complexity(reference, prompt))

human_reference_dataset/iac-eval/evaluation/misc/sagemaker_setup/sagemaker-magicoder-s-cl-7b-deploy.py ADDED Viewed

	@@ -0,0 +1,90 @@

+# Partial reference (incredibly bad documentation and outdated to top it off): https://github.com/huggingface/notebooks/blob/main/sagemaker/11_deploy_model_from_hf_hub/deploy_transformer_model_from_hf_hub.ipynb
+import json
+import sagemaker
+import boto3
+import time
+from sagemaker.huggingface import HuggingFaceModel, get_huggingface_llm_image_uri
+try:
+	role_name = input("Enter the AWS role name, of the AWS account which you will use to create a Sagemaker model/endpoint: ")
+	sagemaker_execution_role = input("Enter the AWS SageMaker execution role, which will be used to create a Sagemaker model/endpoint: ") # e.g., AmazonSageMaker-ExecutionRole-20240504T121584
+	my_session = boto3.session.Session(profile_name=role_name)
+	sagemaker_session = sagemaker.Session(my_session)
+	# print(sagemaker_session.boto_session.region_name)
+	# role = sagemaker.get_execution_role(sagemaker_session=sagemaker_session)
+	iam = my_session.client('iam')
+	role = iam.get_role(RoleName=sagemaker_execution_role)['Role']['Arn']
+	# print(sagemaker_session.get_caller_identity_arn())
+	print(role)
+	# role = sagemaker.get_execution_role()
+	print("Finished sagemaker session setup.")
+except ValueError:
+	my_session = boto3.session.Session(profile_name=role_name)
+	# sagemaker.Session(my_session)
+	# sagemaker_session = 1
+	iam = my_session.client('iam')
+	role = iam.get_role(RoleName=sagemaker_execution_role)['Role']['Arn']
+	print(role)
+# Hub Model configuration. https://huggingface.co/models
+hub = {
+	'HF_MODEL_ID':'ise-uiuc/Magicoder-S-CL-7B', # https://huggingface.co/ise-uiuc/Magicoder-S-CL-7B
+	# 'HF_MODEL_ID':'ise-uiuc/Magicoder-S-DS-6.7B', # https://huggingface.co/ise-uiuc/Magicoder-S-DS-6.7B?sagemaker_deploy=true
+	# 'HF_MODEL_ID':'Salesforce/codegen-16B-multi', # https://huggingface.co/Salesforce/codegen-16B-multi?sagemaker_deploy=true
+	'SM_NUM_GPUS': json.dumps(1), # add back later. for bert testing. # Only 1 GPU is avail for g5.2xlarge instance https://aws.amazon.com/ec2/instance-types/g5/
+	'HF_TASK':'text-generation',
+	# 'HF_TASK':'question-answering' # NLP task you want to use for predictions
+	# "region": "us-east-1",
+	# https://datamagiclab.com/input-validation-error-inputs-tokens-max_new_tokens-must-be-2048/ # https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1/discussions/199
+	"MAX_INPUT_LENGTH": '4000', # put here any value upto 32768 as per your requirement.
+	"MAX_TOTAL_TOKENS": '5000',
+	"MAX_BATCH_PREFILL_TOKENS": '5000',
+	"MAX_BATCH_TOTAL_TOKENS": '5000',
+}
+# create Hugging Face Model Class
+huggingface_model = HuggingFaceModel(
+	image_uri=get_huggingface_llm_image_uri("huggingface",version="1.4.2",
+	session=sagemaker_session
+	),
+	env=hub,
+	role=role,
+	sagemaker_session=sagemaker_session,
+	# Remove later, for bert testing:
+	# transformers_version='4.37.0',
+	# pytorch_version='2.1.0',
+	# py_version='py310',
+)
+# deploy model to SageMaker Inference
+predictor = huggingface_model.deploy(
+	initial_instance_count=1,
+	instance_type="ml.g5.2xlarge",
+	# instance_type="ml.g5.4xlarge",
+	# instance_type="ml.m5.xlarge",
+	container_startup_health_check_timeout=300, # add back later. for bert testing.
+  )
+MAGICODER_PROMPT = """You are an exceptionally intelligent coding assistant that consistently delivers accurate and reliable responses to user instructions.
+@@ Instruction
+{}
+@@ Response
+""".format("You are TerraformAI, an AI agent that builds and deploys Cloud Infrastructure written in Terraform HCL. Generate a description of the Terraform program you will define, followed by a single Terraform HCL program in response to each of my Instructions. Make sure the configuration is deployable. Create IAM roles as needed. If variables are used, make sure default values are supplied. \n Here is the actual prompt: Create an AWS VPC resource with an Internet Gateway attached to it")
+# send request
+print(predictor.predict({
+	"inputs": MAGICODER_PROMPT,
+}))
+time.sleep(60)
+print(predictor.predict({
+	"inputs": "My name is Julien and I like to",
+}))
+# # Cleanup:
+# predictor.delete_model()
+# predictor.delete_endpoint()

human_reference_dataset/iac-eval/evaluation/models.py ADDED Viewed

	@@ -0,0 +1,338 @@

+import replicate
+import google.generativeai as genai
+import os
+import requests
+import boto3
+import sagemaker
+import json
+import subprocess
+import time
+# GPT evaluation generation
+# set your API key here, need to be hided
+def GPT3_5(preprompt, prompt, client):
+    # message = query_message(prompt) if KNOWLEDGE_EMBEDDING_FLAG else prompt
+    messages = [
+        {"role": "system", "content": preprompt},
+        {"role": "user", "content": prompt},
+    ]
+    while True:
+        try:
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=messages,
+            )
+            # print(response.choices[0].message.content)
+            # print("GPT3.5 eval done")
+            return response.choices[0].message.content
+        except Exception as e:
+            s = str(e)
+            if "Rate limit is exceeded" in s:
+                time.sleep(30)
+                continue
+            else:
+                return ""
+def GPT4(preprompt, prompt, client):
+    # print("current GPT4 working directory is",os.getcwd())
+    # message = query_message(prompt) if KNOWLEDGE_EMBEDDING_FLAG else prompt
+    messages = [
+        {"role": "system", "content": preprompt},
+        {"role": "user", "content": prompt},
+    ]
+    while True:
+        try:
+            response = client.chat.completions.create(
+                model="gpt-4-turbo",
+                messages=messages,
+            )
+            # print(response.choices[0].message.content)
+            # print("GPT4 eval done")
+            return response.choices[0].message.content
+        except Exception as e:
+            s = str(e)
+            if "Rate limit is exceeded" in s:
+                time.sleep(30)
+                continue
+            else:
+                return ""
+def Codellama7b(preprompt, prompt):
+    for i in range(2):
+        try:
+            output = replicate.run(
+                "meta/codellama-7b-instruct:aac3ab196f8a75729aab9368cd45ea6ad3fc793b6cda93b1ded17299df369332",
+                input={
+                    "top_k": 250,
+                    "top_p": 0.95,
+                    "prompt": prompt,
+                    "max_tokens": 500,
+                    "temperature": 0.95,
+                    "system_prompt": preprompt,
+                    "repeat_penalty": 1.1,
+                    "presence_penalty": 0,
+                    "frequency_penalty": 0,
+                },
+            )
+            output_string = ""
+            for item in output:
+                output_string += item
+            print(output_string)
+            return output_string
+        except Exception as e:
+            s = str(e)
+            print(s)
+            if "status: 502" in s or "Prediction interrupted" in s:
+                time.sleep(10)
+    return ""
+def Codellama13b(preprompt, prompt):
+    for i in range(2):
+        try:
+            output = replicate.run(
+                "meta/codellama-13b-instruct:a5e2d67630195a09b96932f5fa541fe64069c97d40cd0b69cdd91919987d0e7f",
+                input={
+                    "top_k": 250,
+                    "top_p": 0.95,
+                    "prompt": prompt,
+                    "max_tokens": 500,
+                    "temperature": 0.95,
+                    "system_prompt": preprompt,
+                    "repeat_penalty": 1.1,
+                    "presence_penalty": 0,
+                    "frequency_penalty": 0,
+                },
+            )
+            output_string = ""
+            for item in output:
+                output_string += item
+            print(output_string)
+            return output_string
+        except Exception as e:
+            s = str(e)
+            print(s)
+            if "status: 502" in s or "Prediction interrupted" in s:
+                time.sleep(10)
+    return ""
+def Codellama34b(preprompt, prompt):
+    for i in range(2):
+        try:
+            output = replicate.run(
+                "meta/codellama-34b-instruct:eeb928567781f4e90d2aba57a51baef235de53f907c214a4ab42adabf5bb9736",
+                input={
+                    "top_k": 250,
+                    "top_p": 0.95,
+                    "prompt": prompt,
+                    "max_tokens": 500,
+                    "temperature": 0.95,
+                    "system_prompt": preprompt,
+                    "repeat_penalty": 1.1,
+                    "presence_penalty": 0,
+                    "frequency_penalty": 0,
+                },
+            )
+            output_string = ""
+            for item in output:
+                output_string += item
+            print(output_string)
+            return output_string
+        except Exception as e:
+            s = str(e)
+            print(s)
+            if "status: 502" in s or "Prediction interrupted" in s:
+                time.sleep(10)
+    return ""
+# Codegen model variants: https://replicate.com/andreasjansson/codegen
+def Codegen16b(preprompt, prompt):
+    API_URL = "https://api-inference.huggingface.co/models/gpt2"
+    HF_API_TOKEN = os.environ['HF_API_TOKEN ']
+    headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+    response = requests.post(API_URL, headers=headers, json=prompt)
+    return response.json()
+# https://replicate.com/rhamnett/wizardcoder-34b-v1.0
+def Wizardcoder34b(preprompt, prompt):
+    for i in range(2):
+        try:
+            output = replicate.run(
+                "rhamnett/wizardcoder-34b-v1.0:bae902bd8a4032fcf2295523b38da90aae7cc8ca2260e7ca9b8434a981d32278",
+                input={
+                    "top_k": 250,
+                    "top_p": 0.95,
+                    "prompt": prompt,
+                    "max_tokens": 500,
+                    "temperature": 0.95,
+                    "system_prompt": preprompt,
+                    "repeat_penalty": 1.1,
+                    "presence_penalty": 0,
+                    "frequency_penalty": 0,
+                },
+            )
+            output_string = ""
+            for item in output:
+                output_string += item
+            print(output_string)
+            return output_string
+        except Exception as e:
+            s = str(e)
+            print(s)
+            if "status: 502" in s or "Prediction interrupted" in s:
+                time.sleep(10)
+    return ""
+# WizardCoder-Python-34B-V1.0	https://replicate.com/lucataco/wizardcoder-python-34b-v1.0
+# WizardCoder-33B-V1.1	: https://replicate.com/lucataco/wizardcoder-33b-v1.1-gguf
+def Wizardcoder33b(preprompt, prompt):
+    for i in range(2):
+        try:
+            output = replicate.run(
+                "lucataco/wizardcoder-33b-v1.1-gguf:bbf93cee2c2b446f0ff426ae81a9b61c5ebd8972a21f734fe035513b6fafe615",
+                input={
+                    "top_k": 250,
+                    "top_p": 0.95,
+                    "prompt": prompt,
+                    "max_tokens": 500,
+                    "temperature": 0.95,
+                    "system_prompt": preprompt,
+                    "repeat_penalty": 1.1,
+                    "presence_penalty": 0,
+                    "frequency_penalty": 0,
+                },
+            )
+            output_string = ""
+            for item in output:
+                output_string += item
+            print(output_string)
+            return output_string
+        except Exception as e:
+            s = str(e)
+            print(s)
+            if "status: 502" in s or "Prediction interrupted" in s:
+                time.sleep(10)
+    return ""
+def Magicoder_S_CL_7B(preprompt, prompt):
+    while True:
+        try:
+            my_session = boto3.session.Session(profile_name=os.environ["AWS_ROLE_NAME"])
+            session = sagemaker.Session(my_session)
+            # endpoint_name = "huggingface-pytorch-tgi-inference-2024-05-06-03-21-48-837" # ise-uiuc/Magicoder-S-CL-7B endpoint
+            endpoint_name = os.environ["MAGICODER_SAGEMAKER_ENDPOINT"] # ise-uiuc/Magicoder-S-CL-7B endpoint with 5000 MAX_TOTAL_TOKENS
+            predictor = sagemaker.predictor.RealTimePredictor(endpoint_name=endpoint_name, sagemaker_session=session)
+            MAGICODER_PROMPT = """
+You are an exceptionally intelligent coding assistant that consistently delivers accurate and reliable responses to user instructions.
+@@ Instruction
+{}
+@@ Response
+    """.format(preprompt + "\n" + prompt)
+            input_data = {
+                "inputs": MAGICODER_PROMPT,
+                'parameters': {"stop": ["<|endoftext|>", "</s>"], "max_new_tokens": 1000} # https://stackoverflow.com/a/76763217/13336187 # NOTE: 1800 max_new_tokens I initially used
+            }
+            payload = json.dumps(input_data).encode("utf-8")
+            result = predictor.predict(payload, initial_args={'ContentType': 'application/json'}) # https://stackoverflow.com/a/65448063/13336187
+            json_data = json.loads(result.decode('utf-8'))
+            generated_text = json_data[0]['generated_text'].split("@@ Response")[1]
+            return generated_text
+        except Exception as e:
+            s = str(e)
+            if "Your invocation timed out" in s:
+                print("Error encoutered. Considered model unable to output correct answer: ", s)
+                return ""
+            else:
+                print("Error: ", s)
+                raise e
+# WizardCoder-15B-V1.0	https://replicate.com/lucataco/wizardcoder-15b-v1.0
+# def Wizardcoder33b(preprompt, prompt):
+#     output = replicate.run(
+#         "lucataco/wizardcoder-33b-v1.1-gguf:bbf93cee2c2b446f0ff426ae81a9b61c5ebd8972a21f734fe035513b6fafe615",
+#         input={
+#             "top_k": 250,
+#             "top_p": 0.95,
+#             "prompt": prompt,
+#             "max_tokens": 500,
+#             "temperature": 0.95,
+#             "system_prompt": preprompt,
+#             "repeat_penalty": 1.1,
+#             "presence_penalty": 0,
+#             "frequency_penalty": 0,
+#         },
+#     )
+#     output_string = ""
+#     for item in output:
+#         output_string += item
+#     print(output_string)
+#     return output_string
+# Gemini: https://ai.google.dev/gemini-api/docs/quickstart https://github.com/alibaba/CloudEval-YAML/blob/main/models/palm.py
+def gemini(preprompt, prompt):
+    genai.configure(api_key=os.environ['GOOGLE_API_KEY'])
+    # for m in genai.list_models():
+    #     if 'generateContent' in m.supported_generation_methods:
+    #         print(m.name)
+    safety_settings = [
+        {
+            "category": "HARM_CATEGORY_DANGEROUS",
+            "threshold": "BLOCK_NONE",
+        },
+        {
+            "category": "HARM_CATEGORY_HARASSMENT",
+            "threshold": "BLOCK_NONE",
+        },
+        {
+            "category": "HARM_CATEGORY_HATE_SPEECH",
+            "threshold": "BLOCK_NONE",
+        },
+        {
+            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+            "threshold": "BLOCK_NONE",
+        },
+        {
+            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+            "threshold": "BLOCK_NONE",
+        },
+    ]
+    model = genai.GenerativeModel('gemini-pro')
+    # print(preprompt + "\n" + prompt)
+    while True:
+        try:
+            response = model.generate_content(preprompt + "\n" + prompt, safety_settings=safety_settings)
+            break
+        except Exception as e:
+            s = str(e)
+            if "Resource has been exhausted" in s:
+                print(s)
+                print("^ Resource has been exhausted. Please wait for 100 seconds.")
+                time.sleep(100)
+    # print(len(response.candidates))
+    # for candidate in response.candidates:
+    #     print(len(candidate.content.parts))
+        # print ([part.text for part in candidate.content.parts])
+    # return response.text
+    try:
+        res = response.candidates[0].content.parts[0].text # https://github.com/google-gemini/generative-ai-python/issues/170
+        return res
+    except:
+        return ""
+# gemini("You are TerraformAI, an AI agent that builds and deploys Cloud Infrastructure written in Terraform HCL. Generate a description of the Terraform program you will define, followed by a single Terraform HCL program in response to each of my Instructions. Make sure the configuration is deployable. Create IAM roles as needed.", "create a AWS codebuild project resource with example iam role, example GITHUB source, and a logs config")
+# print(Magicoder_S_CL_7B("You are TerraformAI, an AI agent that builds and deploys Cloud Infrastructure written in Terraform HCL. Generate a description of the Terraform program you will define, followed by a single Terraform HCL program in response to each of my Instructions. Make sure the configuration is deployable. Create IAM roles as needed. If variables are used, make sure default values are supplied.", "Here is the actual prompt: Create an AWS VPC resource with an Internet Gateway attached to it"))
+# print(Wizardcoder34b("You are TerraformAI, an AI agent that builds and deploys Cloud Infrastructure written in Terraform HCL. Generate a description of the Terraform program you will define, followed by a single Terraform HCL program in response to each of my Instructions. Make sure the configuration is deployable. Create IAM roles as needed. If variables are used, make sure default values are supplied.", "Here is the actual prompt: Create an AWS VPC resource with an Internet Gateway attached to it"))

human_reference_dataset/iac-eval/evaluation/prompt-templates/CoT.txt ADDED Viewed

	@@ -0,0 +1,66 @@

+Here are a few examples:
+Example prompt 1: Create an AWS RDS instance (with an instance class of db.t2.micro, and don't create a final snapshot before eventual deletion) with randomly generated id and password
+Example output 1: Let's think step by step. First, let's reason about the resources needed: this would be an AWS RDS instance (aws_db_instance), and resources to generate a random id and password. Second, we fill in the attributes of each resource, starting with those explicitly and implicitly mentioned in the prompt, and followed by others: for example, for the aws_db_instance, we need to set the "instance_class" attribute to "db.t2.micro", and the "skip_final_snapshot" attribute to true. Finally, we connect the resources together, as needed: here "identifier" should be connected to the "random_id" resource, and "password" should be connected to the "random_password" resource
+```hcl
+resource "random_id" "suffix" {
+  byte_length = 4
+}
+resource "random_password" "db" {
+  length  = 16
+  special = false
+}
+resource "aws_db_instance" "test" {
+  identifier          = "metricbeat-test-${random_id.suffix.hex}"
+  allocated_storage   = 20 // Gigabytes
+  engine              = "mysql"
+  instance_class      = "db.t2.micro"
+  db_name                = "metricbeattest"
+  username            = "foo"
+  password            = random_password.db.result
+  skip_final_snapshot = true // Required for cleanup
+}
+```
+Example prompt 2: Create an 20GB MySQL instance on aws with randomly generated id and password
+Example output 2: Let's think step by step. First, let's reason about the resources needed: this would be an AWS RDS instance (aws_db_instance), and resources to generate a random id and password. Second, we fill in the attributes of each resource, starting with those explicitly and implicitly mentioned in the prompt, and followed by others: for example, for the aws_db_instance, we need to set the "engine" attribute to "mysql". Finally, we connect the resources together, as needed: here "identifier" should be connected to the "random_id" resource, and "password" should be connected to the "random_password" resource
+```hcl
+resource "random_id" "suffix" {
+  byte_length = 4
+}
+resource "random_password" "db" {
+  length  = 16
+  special = false
+}
+resource "aws_db_instance" "test" {
+  identifier          = "metricbeat-test-${random_id.suffix.hex}"
+  allocated_storage   = 20 // Gigabytes
+  engine              = "mysql"
+  instance_class      = "db.t2.micro"
+  db_name                = "metricbeattest"
+  username            = "foo"
+  password            = random_password.db.result
+  skip_final_snapshot = true // Required for cleanup
+}
+```
+Example prompt 3: create a AWS EFS, and create a replica of an this created EFS file system using regional storage in us-west-2
+Example output 3: Let's think step by step. First, let's reason about the resources needed: this would be an AWS EFS replication resource (aws_efs_replication_configuration), and  the AWS EFS resource itself. Second, we fill in the attributes of each resource, starting with those explicitly and implicitly mentioned in the prompt, and followed by others: for example, for the aws_efs_replication_configuration, we need to set the "availability_zone_name" attribute to an availability zone that will be within the region specificed in the prompt, such as "us-west-2b". Finally, we connect the resources together, as needed: here "source_file_system_id" should be connected to the "aws_efs_file_system" resource
+```hcl
+resource "aws_efs_file_system" "example" {}
+resource "aws_efs_replication_configuration" "example" {
+  source_file_system_id = aws_efs_file_system.example.id
+  destination {
+    availability_zone_name = "us-west-2b"
+    kms_key_id             = "1234abcd-12ab-34cd-56ef-1234567890ab"
+  }
+}
+```
+Here is the actual prompt to answer. Let's think step by step:

human_reference_dataset/iac-eval/evaluation/prompt-templates/few-shot.txt ADDED Viewed

	@@ -0,0 +1,66 @@

+Here are a few examples:
+Example prompt 1: Create an AWS RDS instance with randomly generated id and password
+Example output 1:
+```hcl
+resource "random_id" "suffix" {
+  byte_length = 4
+}
+resource "random_password" "db" {
+  length  = 16
+  special = false
+}
+resource "aws_db_instance" "test" {
+  identifier          = "metricbeat-test-${random_id.suffix.hex}"
+  allocated_storage   = 20 // Gigabytes
+  engine              = "mysql"
+  instance_class      = "db.t2.micro"
+  db_name                = "metricbeattest"
+  username            = "foo"
+  password            = random_password.db.result
+  skip_final_snapshot = true // Required for cleanup
+}
+```
+Example prompt 2: Create an 20GB MySQL instance on aws with randomly generated id and password
+Example output 2:
+```hcl
+resource "random_id" "suffix" {
+  byte_length = 4
+}
+resource "random_password" "db" {
+  length  = 16
+  special = false
+}
+resource "aws_db_instance" "test" {
+  identifier          = "metricbeat-test-${random_id.suffix.hex}"
+  allocated_storage   = 20 // Gigabytes
+  engine              = "mysql"
+  instance_class      = "db.t2.micro"
+  db_name                = "metricbeattest"
+  username            = "foo"
+  password            = random_password.db.result
+  skip_final_snapshot = true // Required for cleanup
+}
+```
+Example prompt 3: create a AWS EFS, and create a replica of an this created EFS file system using regional storage in us-west-3
+Example output 3:
+```hcl
+resource "aws_efs_file_system" "example" {}
+resource "aws_efs_replication_configuration" "example" {
+  source_file_system_id = aws_efs_file_system.example.id
+  destination {
+    availability_zone_name = "us-west-2b"
+    kms_key_id             = "1234abcd-12ab-34cd-56ef-1234567890ab"
+  }
+}
+```
+Here is the actual prompt to answer:

human_reference_dataset/iac-eval/evaluation/prompt-templates/multi-turn-system-prompt.txt ADDED Viewed

	@@ -0,0 +1 @@

+ You are TerraformAI, an AI agent that builds and deploys Cloud Infrastructure written in Terraform HCL. Given an incorrect Terraform program along with an error message, your task is to first describe the error in your own words, followed by a description of the fix you will apply, and ending with a single corrected Terraform HCL program. Make sure the configuration is deployable. Create IAM roles as needed. If variables are used, make sure default values are supplied.

human_reference_dataset/iac-eval/evaluation/prompt-templates/system-prompt.txt ADDED Viewed

	@@ -0,0 +1 @@

+ You are TerraformAI, an AI agent that builds and deploys Cloud Infrastructure written in Terraform HCL. Generate a description of the Terraform program you will define, followed by a single Terraform HCL program in response to each of my Instructions. Make sure the configuration is deployable. Create IAM roles as needed. If variables are used, make sure default values are supplied. Be sure to include a valid provider configuration within a valid region. Make sure there are no undeclared resources (e.g., as references) or variables, that is, all resources and variables needed in the configuration should be fully specified.

human_reference_dataset/iac-eval/evaluation/prompt_templates.py ADDED Viewed

	@@ -0,0 +1,56 @@

+def CoT_prompt(question_prompt):
+    with open('prompt-templates/CoT.txt', 'r') as file:
+        data = file.read()
+    prompt = data + question_prompt # https://www.promptingguide.ai/techniques/cot#zero-shot-cot-prompting
+    return prompt
+def FSP_prompt(question_prompt):
+    with open('prompt-templates/few-shot.txt', 'r') as file:
+        data = file.read()
+    prompt = data + question_prompt
+    return prompt
+def RAG_prompt(context, question_prompt):
+    template = """
+Here is some additional knowledge/context retrieved from Terraform documentation, that may (or may not) potentially help you answer the question:
+{}
+Here is the actual prompt to answer:
+{}
+    """.format(context, question_prompt)
+    return template
+def multi_turn_system_prompt():
+    with open('prompt-templates/multi-turn-system-prompt.txt', 'r') as file:
+        data = file.read()
+    return data
+def multi_turn_plan_error_prompt(question_prompt, candidate_config, error_message):
+    prompt = """
+Here is the original prompt:
+{}
+Here is the incorrect configuration:
+{}
+Here is the Terraform plan error message (potentially empty):
+{}
+""".format(question_prompt, candidate_config, error_message)
+    return prompt
+def multi_turn_rego_error_prompt(question_prompt, candidate_config, rego_policy, error_message):
+    prompt = """
+Here is the original prompt:
+{}
+Here is the incorrect configuration:
+{}
+Here is the Rego OPA policy associated with this configuration:
+{}
+Here is the Rego OPA policy error message:
+{}
+""".format(question_prompt, candidate_config, rego_policy, error_message)
+    return prompt

human_reference_dataset/iac-eval/evaluation/setup.sh ADDED Viewed

	@@ -0,0 +1,3 @@


1	+ #!/bin/bash
2	+
3	+ ../setup.sh

human_reference_dataset/iac-eval/licenses/README.md ADDED Viewed

	@@ -0,0 +1,6 @@

+### Licenses
+- CodeLlama: [LLama 2 Community License](https://github.com/facebookresearch/llama/blob/main/LICENSE)
+- OpenAI: [Apache Software License](https://pypi.org/project/openai/)
+- WizardCoder: [Apache License 2.0](https://github.com/nlpxucan/WizardLM/tree/main/WizardCoder)
+- MagiCoder: [LLama 2 Community License](https://huggingface.co/ise-uiuc/Magicoder-S-CL-7B)
+- Gemini: [Apache Software License](https://pypi.org/project/google-generativeai/)

human_reference_dataset/iac-eval/retriever/README.md ADDED Viewed

	@@ -0,0 +1,27 @@

+# Retriever Setup
+## Requirements
+Please make sure you have `iac-eval` conda environment activated and you are in the `retriever/` folder before executing any of the following commands.
+Note: You can run `./setup.sh` for dependency check/setup and executing the following steps.
+## Download
+```shell
+git clone https://github.com/hashicorp/terraform-provider-aws.git
+```
+## Usage
+The following script will:
+1. Ask LLM to generate a list of prompts to search for (``generate_prompt_for_index``).
+2. Use the generated list of prompts to query database (`query_documents`)
+```shell
+python3 llama_index_retriever.py
+```
+Note: 429 errors will cause retry and delay. This will take a while, but don't worry!

human_reference_dataset/iac-eval/retriever/llama_index_retriever.py ADDED Viewed

	@@ -0,0 +1,108 @@

+import os
+import logging
+import sys
+from llama_index.llms.azure_openai import AzureOpenAI
+from llama_index.embeddings.azure_openai import AzureOpenAIEmbedding
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
+from llama_index.core import Settings
+from llama_index.core import StorageContext, load_index_from_storage
+from llama_index.core.node_parser import TokenTextSplitter
+from llama_index.llms.openai import OpenAI
+from llama_index.embeddings.openai import OpenAIEmbedding
+class Retriever:
+    def __init__(self, stored_index = None, path = None, api_version="2023-03-15-preview"):
+        self.embed_model, self.llm = self.setup_api(api_version)
+        self.index = self.retrieve_documents(stored_index, path)
+    def setup_api(self, api_version):
+        if "OPENAI_API_KEY" not in os.environ:
+            api_key = input("Enter OpenAI API key:")
+            os.environ["OPENAI_API_KEY"] = api_key
+        api_key = os.environ["OPENAI_API_KEY"]
+        embed_model = OpenAIEmbedding(
+            model="text-embedding-ada-002", api_key=api_key
+        )
+        llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo")
+        return embed_model, llm
+    def retrieve_documents(self, stored_index = None, path = None):
+        # if stored_index exists, load it
+        Settings.llm = self.llm
+        Settings.embed_model = self.embed_model
+        if os.path.exists(stored_index):
+            print("Loading index from storage")
+            storage_context = StorageContext.from_defaults(persist_dir=stored_index)
+            index = load_index_from_storage(storage_context)
+        else:
+            print("Building index from scratch")
+            nodes = self.read_docs(path)
+            index = self.build_index(nodes)
+            index.storage_context.persist(persist_dir=stored_index)
+        return index
+    def read_docs(self, path = "terraform-provider-aws/website/docs/r"):
+        documents = SimpleDirectoryReader(
+            path
+        ).load_data()
+        # parser = MarkdownNodeParser()
+        splitter = TokenTextSplitter(
+            chunk_size=400,
+            chunk_overlap=20,
+            separator=" ",
+        )
+        nodes = splitter.get_nodes_from_documents(documents)
+        print(f"Read {len(documents)} documents")
+        print(f"Extracted {len(nodes)} nodes")
+        return nodes
+    def build_index(self, nodes):
+        index = VectorStoreIndex(nodes)
+        return index
+    def generate_prompt_for_index(self, query, num_queries=10):
+        # The prompt is not necessary
+        QUERY_GEN_PROMPT = (
+            "You are a helpful assistant that generates multiple search queries based on a "
+            "single input query. Generate {num_queries} search queries, one on each line, "
+            "related to the following input query:\n"
+            "Query: {query}\n"
+        )
+        formatted_prompt = QUERY_GEN_PROMPT.format(num_queries=num_queries, query=query)
+        query_engine = self.index.as_query_engine()
+        response = query_engine.query(formatted_prompt)
+        questions = response.response.split('\n')
+        print(questions)
+        return questions
+    def query_documents(self, questions):
+        retriever = self.index.as_retriever()
+        context = set()
+        for q in questions:
+            if not isinstance(q, str) or q == "":
+                continue
+            nodes = retriever.retrieve(q)
+            context.add(nodes[0].text)
+        return context
+if __name__ == "__main__":
+    retriever = Retriever(stored_index='aws-index', path='terraform-provider-aws/website/docs/r')
+    query = '''sets up a VPC with public and private subnets, multiple security groups for different components like master, worker, alert, API, standalone, and database services within an AWS region specified as "cn-north-1". It includes a 5.7, 50GB MySQL database instance within the VPC, accessible and secured by a designated security group.'''
+    questions = retriever.generate_prompt_for_index(query)
+    # questions = ['defines an AWS RDS option group named "option-group-pike" with major engine version 11, and use the sqlserver-ee engine. It should have options for "SQLSERVER_AUDIT" and "TDE" ', '', '1. How to create an AWS RDS option group with major engine version 11 and sqlserver-ee engine?', '2. What are the available options for an AWS RDS option group with major engine version 11 and sqlserver-ee engine?', '3. How to add the "SQLSERVER_AUDIT" option to an AWS RDS option group?', '4. How to add the "TDE" option to an AWS RDS option group?', '5. What is the option group description for an AWS RDS option group named "option-group-pike"?', '6. How to set the timezone option for an AWS RDS option group?', '7. How to set the IAM role ARN for the "SQLSERVER_BACKUP_RESTORE" option in an AWS RDS option group?', '8. What are the MariaDB options available for an AWS RDS option group?', '9. What are the Microsoft SQL Server options available for an AWS RDS option group?', '10. What are the MySQL options available for an AWS RDS option group?'] # this caused an error
+    context = retriever.query_documents(questions)
+    for i, c in enumerate(context):
+        print(f'Context {i}:')
+        print(c)

human_reference_dataset/iac-eval/retriever/setup.sh ADDED Viewed

	@@ -0,0 +1,21 @@

+#!/bin/bash
+set -Eeuo pipefail
+eval "$(command conda 'shell.bash' 'hook' 2> /dev/null)"
+# Create the conda environment if it doesn't exist
+if ! conda list --name iac-eval &> /dev/null; then
+    echo -e 'iac-eval conda environment not yet created. Creating the environment...'
+    conda env create -f ../environment.yml
+fi
+# Activate the conda environment
+conda activate iac-eval
+# Clone the git repository if it doesn't exist
+if [ ! -d "terraform-provider-aws" ]; then
+    git clone https://github.com/hashicorp/terraform-provider-aws
+fi
+python3 llama_index_retriever.py

human_reference_dataset/iac-eval/setup.sh ADDED Viewed

	@@ -0,0 +1,29 @@

+#!/bin/bash
+set -Eeuo pipefail
+# This is basically what `conda init` adds to bashrc
+eval "$(command conda 'shell.bash' 'hook' 2> /dev/null)"
+# set -x
+# Check if terraform is installed
+if ! which terraform &> /dev/null; then
+    echo -e 'Make sure you have Terraform installed. Check README for how.' >&2
+    exit 1
+fi
+# Check if opa is installed
+if ! which opa &> /dev/null; then
+    echo -e 'Make sure you have OPA installed. Check REAMD for how.' >&2
+    exit 1
+fi
+# Create the conda environment if it doesn't exist
+if ! conda list --name iac-eval &> /dev/null; then
+    echo -e 'iac-eval conda environment not yet created. Creating the environment...'
+    conda env create -f environment.yml
+fi
+# Activate the conda environment
+conda activate iac-eval

human_reference_dataset/iac-eval/templates/aws_chime_voice_connector/main.tf ADDED Viewed

	@@ -0,0 +1,8 @@

+resource "aws_chime_voice_connector" "test" {
+  name               = "connector-test-1"
+  require_encryption = true
+  aws_region         = "us-east-1"
+  tags = {
+    test-tag = "{insert tag}"
+  }
+}

human_reference_dataset/iac-eval/templates/aws_chime_voice_connector/template.rego ADDED Viewed

	@@ -0,0 +1,21 @@

+package aws_chime_voice_connector
+# name - required
+# require_encryption - required
+# aws_region - optional
+# tags - optional
+import future.keywords.in
+default chime_voice_connector_valid := false
+chime_voice_connector_valid {
+    some chime_v_c in input.configuration.root_module.resources
+    chime_v_c.type == "aws_chime_voice_connector"
+    expressions := chime_v_c.expressions
+    # expressions.name == ""
+    is_boolean(expressions.require_encryption.constant_value)
+    # expressions.aws_region.constant_value == ""
+    # expressions.tags.constant_value.[tag name] == ""
+}

human_reference_dataset/iac-eval/templates/aws_chime_voice_connector/tfplan.json ADDED Viewed

	@@ -0,0 +1,108 @@

+{
+    "format_version": "1.2",
+    "terraform_version": "1.5.7",
+    "planned_values": {
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_chime_voice_connector.test",
+                    "mode": "managed",
+                    "type": "aws_chime_voice_connector",
+                    "name": "test",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "aws_region": "us-east-1",
+                        "name": "connector-test-1",
+                        "require_encryption": true,
+                        "tags": {
+                            "test-tag": "{insert tag}"
+                        },
+                        "tags_all": {
+                            "test-tag": "{insert tag}"
+                        }
+                    },
+                    "sensitive_values": {
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                }
+            ]
+        }
+    },
+    "resource_changes": [
+        {
+            "address": "aws_chime_voice_connector.test",
+            "mode": "managed",
+            "type": "aws_chime_voice_connector",
+            "name": "test",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "aws_region": "us-east-1",
+                    "name": "connector-test-1",
+                    "require_encryption": true,
+                    "tags": {
+                        "test-tag": "{insert tag}"
+                    },
+                    "tags_all": {
+                        "test-tag": "{insert tag}"
+                    }
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "id": true,
+                    "outbound_host_name": true,
+                    "tags": {},
+                    "tags_all": {}
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        }
+    ],
+    "configuration": {
+        "provider_config": {
+            "aws": {
+                "name": "aws",
+                "full_name": "registry.terraform.io/hashicorp/aws"
+            }
+        },
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_chime_voice_connector.test",
+                    "mode": "managed",
+                    "type": "aws_chime_voice_connector",
+                    "name": "test",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "aws_region": {
+                            "constant_value": "us-east-1"
+                        },
+                        "name": {
+                            "constant_value": "connector-test-1"
+                        },
+                        "require_encryption": {
+                            "constant_value": true
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "test-tag": "{insert tag}"
+                            }
+                        }
+                    },
+                    "schema_version": 0
+                }
+            ]
+        }
+    },
+    "timestamp": "2023-12-05T17:15:38Z"
+}

human_reference_dataset/iac-eval/templates/aws_iam_policy/main.tf ADDED Viewed

	@@ -0,0 +1,20 @@

+resource "aws_iam_policy" "policy" {
+  name        = "test_policy"
+  path        = "/"
+  description = "My test policy"
+  # Terraform's "jsonencode" function converts a
+  # Terraform expression result to valid JSON syntax.
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Action = [
+          "ec2:Describe*",
+        ]
+        Effect   = "Allow"
+        Resource = "*"
+      },
+    ]
+  })
+}

human_reference_dataset/iac-eval/templates/aws_iam_policy/template.rego ADDED Viewed

	@@ -0,0 +1,30 @@

+package aws_iam_policy
+import future.keywords.in
+# description - optional
+# name - optional (conflicts with name_prefix)
+# name_prefix - optional (conflicts with name)
+# path - optional
+# policy - required
+# tags - optional
+default iam_policy_valid := false
+iam_policy_valid {
+    some iam_policy in input.resource_changes
+    iam_policy.type == "aws_iam_policy"
+    expressions := iam_policy.change.after
+    # expressions.name == "[name]" # if intended to be specific value
+    # expressions.name_prefix.constant_value == "[name_prefix]" # if intended to be specific value
+    # expressions.path.constant_value == "[path]" # if intended to be specific value
+    # TODO: How to verify if policies are valid
+    # expressions.policy
+    # expressions.tags.[tag name] == "[tag value]" # if a tag is intended to be a specific value
+}

human_reference_dataset/iac-eval/templates/aws_iam_policy/tfplan.json ADDED Viewed

	@@ -0,0 +1,94 @@

+{
+    "format_version": "1.2",
+    "terraform_version": "1.5.7",
+    "planned_values": {
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_iam_policy.policy",
+                    "mode": "managed",
+                    "type": "aws_iam_policy",
+                    "name": "policy",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "description": "My test policy",
+                        "name": "test_policy",
+                        "path": "/",
+                        "policy": "{\"Statement\":[{\"Action\":[\"ec2:Describe*\"],\"Effect\":\"Allow\",\"Resource\":\"*\"}],\"Version\":\"2012-10-17\"}",
+                        "tags": null
+                    },
+                    "sensitive_values": {
+                        "tags_all": {}
+                    }
+                }
+            ]
+        }
+    },
+    "resource_changes": [
+        {
+            "address": "aws_iam_policy.policy",
+            "mode": "managed",
+            "type": "aws_iam_policy",
+            "name": "policy",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "description": "My test policy",
+                    "name": "test_policy",
+                    "path": "/",
+                    "policy": "{\"Statement\":[{\"Action\":[\"ec2:Describe*\"],\"Effect\":\"Allow\",\"Resource\":\"*\"}],\"Version\":\"2012-10-17\"}",
+                    "tags": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "id": true,
+                    "name_prefix": true,
+                    "policy_id": true,
+                    "tags_all": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags_all": {}
+                }
+            }
+        }
+    ],
+    "configuration": {
+        "provider_config": {
+            "aws": {
+                "name": "aws",
+                "full_name": "registry.terraform.io/hashicorp/aws"
+            }
+        },
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_iam_policy.policy",
+                    "mode": "managed",
+                    "type": "aws_iam_policy",
+                    "name": "policy",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "description": {
+                            "constant_value": "My test policy"
+                        },
+                        "name": {
+                            "constant_value": "test_policy"
+                        },
+                        "path": {
+                            "constant_value": "/"
+                        },
+                        "policy": {}
+                    },
+                    "schema_version": 0
+                }
+            ]
+        }
+    },
+    "timestamp": "2023-12-05T19:48:13Z"
+}

human_reference_dataset/iac-eval/templates/aws_iam_role/main.tf ADDED Viewed

	@@ -0,0 +1,28 @@

+resource "aws_iam_role" "test_role" {
+  name = "test_role"
+  description="test role for templating"
+  force_detach_policies = false
+  max_session_duration=3600
+  path="/"
+  # Terraform's "jsonencode" function converts a
+  # Terraform expression result to valid JSON syntax.
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Action = "sts:AssumeRole"
+        Effect = "Allow"
+        Sid    = ""
+        Principal = {
+          Service = "ec2.amazonaws.com"
+        }
+      },
+    ]
+  })
+  tags = {
+    tag-key = "tag-value"
+  }
+}

human_reference_dataset/iac-eval/templates/aws_iam_role/template.rego ADDED Viewed

File without changes

human_reference_dataset/iac-eval/templates/aws_iam_role/tfplan.json ADDED Viewed

	@@ -0,0 +1,131 @@

+{
+    "format_version": "1.2",
+    "terraform_version": "1.5.7",
+    "planned_values": {
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_iam_role.test_role",
+                    "mode": "managed",
+                    "type": "aws_iam_role",
+                    "name": "test_role",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "assume_role_policy": "{\"Statement\":[{\"Action\":\"sts:AssumeRole\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"ec2.amazonaws.com\"},\"Sid\":\"\"}],\"Version\":\"2012-10-17\"}",
+                        "description": "test role for templating",
+                        "force_detach_policies": false,
+                        "max_session_duration": 3600,
+                        "name": "test_role",
+                        "path": "/",
+                        "permissions_boundary": null,
+                        "tags": {
+                            "tag-key": "tag-value"
+                        },
+                        "tags_all": {
+                            "tag-key": "tag-value"
+                        }
+                    },
+                    "sensitive_values": {
+                        "inline_policy": [],
+                        "managed_policy_arns": [],
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                }
+            ]
+        }
+    },
+    "resource_changes": [
+        {
+            "address": "aws_iam_role.test_role",
+            "mode": "managed",
+            "type": "aws_iam_role",
+            "name": "test_role",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "assume_role_policy": "{\"Statement\":[{\"Action\":\"sts:AssumeRole\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"ec2.amazonaws.com\"},\"Sid\":\"\"}],\"Version\":\"2012-10-17\"}",
+                    "description": "test role for templating",
+                    "force_detach_policies": false,
+                    "max_session_duration": 3600,
+                    "name": "test_role",
+                    "path": "/",
+                    "permissions_boundary": null,
+                    "tags": {
+                        "tag-key": "tag-value"
+                    },
+                    "tags_all": {
+                        "tag-key": "tag-value"
+                    }
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "create_date": true,
+                    "id": true,
+                    "inline_policy": true,
+                    "managed_policy_arns": true,
+                    "name_prefix": true,
+                    "tags": {},
+                    "tags_all": {},
+                    "unique_id": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "inline_policy": [],
+                    "managed_policy_arns": [],
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        }
+    ],
+    "configuration": {
+        "provider_config": {
+            "aws": {
+                "name": "aws",
+                "full_name": "registry.terraform.io/hashicorp/aws"
+            }
+        },
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_iam_role.test_role",
+                    "mode": "managed",
+                    "type": "aws_iam_role",
+                    "name": "test_role",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "assume_role_policy": {},
+                        "description": {
+                            "constant_value": "test role for templating"
+                        },
+                        "force_detach_policies": {
+                            "constant_value": false
+                        },
+                        "max_session_duration": {
+                            "constant_value": 3600
+                        },
+                        "name": {
+                            "constant_value": "test_role"
+                        },
+                        "path": {
+                            "constant_value": "/"
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "tag-key": "tag-value"
+                            }
+                        }
+                    },
+                    "schema_version": 0
+                }
+            ]
+        }
+    },
+    "timestamp": "2023-12-20T16:39:10Z"
+}

human_reference_dataset/iac-eval/templates/aws_iam_user/main.tf ADDED Viewed

	@@ -0,0 +1,9 @@

+resource "aws_iam_user" "example" {
+  name = "example_user"
+  path = "/system/"
+  force_destroy = false
+  tags = {
+    tag-key = "tag-value"
+  }
+}

human_reference_dataset/iac-eval/templates/aws_iam_user/template.rego ADDED Viewed

	@@ -0,0 +1,28 @@

+package aws_iam_user
+import future.keywords.in
+# name - required
+# path - optional
+# permissions_boundary - optional
+# force_destroy - optional
+# tags - optional
+default iam_user_valid := false
+iam_user_valid {
+    some iam_user in input.configuration.root_module.resources
+    iam_user.type == "aws_iam_user"
+    expressions := iam_user.expressions
+    # expressions.name == "[name]" # if intended to be specific value
+    # expressions.path.constant_value == "[path]" # if intended to be specific value
+    # TODO: permissions_boundary
+    # expressions.force_destroy.constant_value == [true/false]
+    # expressions.tags.[tag name] == "[tag value]" # if a tag is intended to be a specific value
+}

human_reference_dataset/iac-eval/templates/aws_iam_user/tfplan.json ADDED Viewed

	@@ -0,0 +1,110 @@

+{
+    "format_version": "1.2",
+    "terraform_version": "1.5.7",
+    "planned_values": {
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_iam_user.example",
+                    "mode": "managed",
+                    "type": "aws_iam_user",
+                    "name": "example",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "force_destroy": false,
+                        "name": "example_user",
+                        "path": "/system/",
+                        "permissions_boundary": null,
+                        "tags": {
+                            "tag-key": "tag-value"
+                        },
+                        "tags_all": {
+                            "tag-key": "tag-value"
+                        }
+                    },
+                    "sensitive_values": {
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                }
+            ]
+        }
+    },
+    "resource_changes": [
+        {
+            "address": "aws_iam_user.example",
+            "mode": "managed",
+            "type": "aws_iam_user",
+            "name": "example",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "force_destroy": false,
+                    "name": "example_user",
+                    "path": "/system/",
+                    "permissions_boundary": null,
+                    "tags": {
+                        "tag-key": "tag-value"
+                    },
+                    "tags_all": {
+                        "tag-key": "tag-value"
+                    }
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "id": true,
+                    "tags": {},
+                    "tags_all": {},
+                    "unique_id": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        }
+    ],
+    "configuration": {
+        "provider_config": {
+            "aws": {
+                "name": "aws",
+                "full_name": "registry.terraform.io/hashicorp/aws"
+            }
+        },
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_iam_user.example",
+                    "mode": "managed",
+                    "type": "aws_iam_user",
+                    "name": "example",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "force_destroy": {
+                            "constant_value": false
+                        },
+                        "name": {
+                            "constant_value": "example_user"
+                        },
+                        "path": {
+                            "constant_value": "/system/"
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "tag-key": "tag-value"
+                            }
+                        }
+                    },
+                    "schema_version": 0
+                }
+            ]
+        }
+    },
+    "timestamp": "2023-12-05T20:00:49Z"
+}

human_reference_dataset/iac-eval/templates/aws_lb/template.rego ADDED Viewed

	@@ -0,0 +1,147 @@

+package terraform.validation
+default is_valid_configuration = false
+# has one asw_lb resource
+is_valid_lb {
+        is_valid_app_lb
+        has_valid_subnet
+}
+is_valid_app_lb {
+    resource := input.planned_values.root_module.resources[_]
+    resource.type == "aws_lb"
+    resource.values.load_balancer_type == "application"
+}
+has_valid_subnet {
+        resource := input.planned_values.root_module.resources[_]
+        resource.type == "aws_lb"
+        resource.values.subnet_mapping != null
+}
+has_valid_subnet {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_lb"
+        resource.expressions.subnets
+}
+# has one vpc resource
+is_valid_vpc {
+        have_required_vpc_argument
+}
+have_required_vpc_argument {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_vpc"
+        resource.expressions.cidr_block.constant_value != null
+}
+have_required_vpc_argument {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_vpc"
+        resource.expressions.ipv4_ipam_pool_id.constant_value != null
+}
+# has valid subnet
+is_valid_subnet {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_subnet"
+        resource.expressions.vpc_id != null
+        have_required_subnet_argument
+}
+have_required_subnet_argument {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_subnet"
+        resource.expressions.cidr_block != null
+}
+have_required_subnet_argument {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_subnet"
+        resource.expressions.ipv6_cider_block != null
+}
+# Validate aws_lb_listener with the required arguments
+is_valid_lb_listener {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_lb_listener"
+    resource.expressions.load_balancer_arn
+    has_valid_default_action
+}
+# if type is forward, must have target_group_arn
+has_valid_default_action {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_lb_listener"
+        resource.expressions.default_action[0].type.constant_value == "forward"
+    resource.expressions.default_action[0].target_group_arn != null
+}
+has_valid_default_action {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_lb_listener"
+        resource.expressions.default_action[0].type.constant_value != "forward"
+}
+# if target type is instance, ip, or alb, should have protocol, port, and vpc_id
+is_valid_lb_target_group {
+        resources := input.planned_values.root_module.resources[_]
+    resources.type == "aws_lb_target_group"
+    valid_type := {"instance", "ip", "alb"}
+    type := resources.values.target_type
+    valid_type[type]
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_lb_target_group"
+        resource.expressions.port != null
+        resource.expressions.protocol != null
+        resource.expressions.vpc_id != null
+}
+is_valid_lb_target_group {
+        resource := input.planned_values.root_module.resources[_]
+    resource.type == "aws_lb_listener"
+    resource.values.target_type == "lambda"
+}
+# Validate aws_lb_target_group_attachment with the required arguments
+is_valid_lb_target_group_attachment {
+        resource := input.configuration.root_module.resources[_]
+        resource.type == "aws_lb_target_group_attachment"
+        resource.expressions.target_group_arn
+        resource.expressions.target_id
+}
+# Validate at least one aws_instance with the required arguments
+is_valid_instance {
+        count(valid_instances) > 0
+}
+valid_instances[instance] {
+        instance := input.configuration.root_module.resources[_]
+        instance.type == "aws_instance"
+        requited_argument(instance)
+}
+requited_argument(instance) {
+        instance.expressions.launch_template != null
+}
+requited_argument(instance) {
+        instance.expressions.ami != null
+        instance.expressions.instance_type != null
+}
+# Aggregate validation
+is_valid_configuration {
+    is_valid_vpc
+    is_valid_subnet
+        is_valid_lb
+        is_valid_lb_listener
+        is_valid_lb_target_group_attachment
+        is_valid_lb_target_group
+        is_valid_instance
+}

human_reference_dataset/iac-eval/templates/aws_neptune_cluster/main.tf ADDED Viewed

	@@ -0,0 +1,70 @@

+resource "aws_neptune_cluster" "default" {
+  allow_major_version_upgrade = false
+  apply_immediately           = true
+  availability_zones = [ "us-east-1a" ]
+  backup_retention_period = 2
+  cluster_identifier                  = "neptune-cluster-demo"
+  # cluster_identifier_prefix = "cluster-prefix" # CONFLICTS WITH `cluster_identifier`
+  copy_tags_to_snapshot = false
+  enable_cloudwatch_logs_exports = [ "audit", "slowquery" ]
+  engine                              = "neptune"
+  engine_version = "1.2.1.0"
+  final_snapshot_identifier = "cluster-final-snapshot"
+  # global_cluster_identifer = aws_neptune_global_cluster.<resource name>.id
+  # iam_roles = [ aws_iam_role.<resource name>.arn ]
+  iam_database_authentication_enabled = false
+  # kms_key_arn = aws_kms_key.<resource name>.arn # REQUIRES `storage_encrypted = true`
+  neptune_subnet_group_name = aws_neptune_subnet_group.example_subnet_group.id
+  neptune_cluster_parameter_group_name = aws_neptune_cluster_parameter_group.example_cluster_parameter_group.id
+  # neptune_instance_parameter_group_name = aws_neptune_instance_parameter_group.<resource name>.id
+  preferred_backup_window             = "07:00-09:00"
+  port = 8182
+  # replication_source_identifier = aws_neptune_cluster.<resource name>.arn
+  skip_final_snapshot                 = true
+  # snapshot_identifier = aws_neptune_cluster_snapshot.<resource name>.arn
+  storage_encrypted = false
+  tags = {
+    test-tag = "insert tag"
+  }
+  # vpc_security_group_ids = [ aws_security_group.<resource name>.id ]
+  deletion_protection = false
+  # serverless_v2_scaling_configuration { }
+}
+resource "aws_neptune_cluster_parameter_group" "example_cluster_parameter_group" {
+  family      = "neptune1.2" # neptune1 is also valid but will not work with engines version 1.2.0.0 and higher
+  name        = "example"
+  # name_prefix = "example-prefix" # CONFLICTS WTIH `name`
+  description = "terraform neptune cluster parameter group"
+  parameter {
+    name  = "neptune_enable_audit_log"
+    value = 1
+  }
+  tags = {
+    Name = "My neptune cluster parameter group"
+  }
+}
+resource "aws_neptune_subnet_group" "example_subnet_group" {
+  name       = "example"
+  # name_prefix = "example-prefix" # CONFLICTS WTIH `name`
+  subnet_ids = [aws_subnet.subnet1.id, aws_subnet.subnet2.id]
+  description = "terraform neptune subnet group"
+  tags = {
+    Name = "My neptune subnet group"
+  }
+}
+resource "aws_vpc" "example_vpc" {
+  cidr_block = "10.0.0.0/16"
+}
+resource "aws_subnet" "subnet1" {
+  vpc_id     = aws_vpc.example_vpc.id
+  cidr_block = "10.0.1.0/24"
+}
+resource "aws_subnet" "subnet2" {
+  vpc_id     = aws_vpc.example_vpc.id
+  cidr_block = "10.0.2.0/24"
+}

human_reference_dataset/iac-eval/templates/aws_neptune_cluster/template.rego ADDED Viewed

	@@ -0,0 +1,68 @@

+package aws_neptune_cluster
+import future.keywords.in
+# all attributes are technically optional
+# tags - may only contain unicode letters, digits, whitespace, or one of these symbols: _ . : / = + - @
+# availability_zone_allowed_values := {"us-east-1a", "us-east-1b", "us-east-1c", "us-east-1d", "us-east-1e", "us-east-1f", ...}
+default neptune_cluster_valid := false
+default cluster_parameter_group_valid := false
+neptune_cluster_valid {
+	some cluster in input.configuration.root_module.resources
+	cluster.type == "aws_neptune_cluster"
+	# cluster.expressions.allow_major_version_upgrade.constant_value == true/false # if intended to be specific value
+	# is_boolean(cluster.expressions.allow_major_version_upgrade.constant_value) # if intended to be defined but value doesn't matter
+	# cluster.expressions.apply_immediately.constant_value == true/false # if intended to be specific value
+	# is_boolean(cluster.expressions.apply_immediately.constant_value) # if intended to be defined but value doesn't matter
+	# some availability_zone in cluster.expressions.availability_zones.constant_value
+	# availability_zone == "" # if intended to be specific value
+	# availability_zone in availability_zone_allowed_values # if intended to be defined but value doesn't matter
+    # cluster_parameter_group_valid
+    # TODO: ALL OTHER ATTRIBUTES (they don't seem that important)
+}
+cluster_parameter_group_valid {
+	some cluster in input.configuration.root_module.resources
+	cluster.type == "aws_neptune_cluster"
+    some cluster_parameter_group in input.configuration.root_module.resources
+    cluster_parameter_group.type == "aws_neptune_cluster_parameter_group"
+    cluster_parameter_group.address in cluster.expressions.neptune_cluster_parameter_group_name.references
+    # See for more info: https://docs.aws.amazon.com/neptune/latest/userguide/parameter-groups.html
+    cluster.expressions.engine_version.constant_value < "1.2.0.0"
+    cluster_parameter_group.expressions.family.constant_value == "neptune1"
+}
+cluster_parameter_group_valid {
+	some cluster in input.configuration.root_module.resources
+	cluster.type == "aws_neptune_cluster"
+    some cluster_parameter_group in input.configuration.root_module.resources
+    cluster_parameter_group.type == "aws_neptune_cluster_parameter_group"
+    cluster_parameter_group.address in cluster.expressions.neptune_cluster_parameter_group_name.references
+    # See for more info: https://docs.aws.amazon.com/neptune/latest/userguide/parameter-groups.html
+    cluster.expressions.engine_version.constant_value >= "1.2.0.0"
+    cluster_parameter_group.expressions.family.constant_value == "neptune1.2"
+}
+cluster_parameter_group_valid {
+	some cluster in input.configuration.root_module.resources
+	cluster.type == "aws_neptune_cluster"
+    some cluster_parameter_group in input.configuration.root_module.resources
+    cluster_parameter_group.type == "aws_neptune_cluster_parameter_group"
+    cluster_parameter_group.address in cluster.expressions.neptune_cluster_parameter_group_name.references
+    # See for more info: https://docs.aws.amazon.com/neptune/latest/userguide/parameter-groups.html
+    not cluster.expressions.engine_version.constant_value # defaults as latest version
+    cluster_parameter_group.expressions.family.constant_value == "neptune1.2"
+}

human_reference_dataset/iac-eval/templates/aws_neptune_cluster/tfplan.json ADDED Viewed

	@@ -0,0 +1,749 @@

+{
+    "format_version": "1.2",
+    "terraform_version": "1.6.6",
+    "planned_values": {
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_neptune_cluster.default",
+                    "mode": "managed",
+                    "type": "aws_neptune_cluster",
+                    "name": "default",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "allow_major_version_upgrade": false,
+                        "apply_immediately": true,
+                        "availability_zones": [
+                            "us-east-1a"
+                        ],
+                        "backup_retention_period": 2,
+                        "cluster_identifier": "neptune-cluster-demo",
+                        "copy_tags_to_snapshot": false,
+                        "deletion_protection": false,
+                        "enable_cloudwatch_logs_exports": [
+                            "audit",
+                            "slowquery"
+                        ],
+                        "engine": "neptune",
+                        "engine_version": "1.2.1.0",
+                        "final_snapshot_identifier": "cluster-final-snapshot",
+                        "global_cluster_identifier": null,
+                        "iam_database_authentication_enabled": false,
+                        "iam_roles": null,
+                        "neptune_instance_parameter_group_name": null,
+                        "port": 8182,
+                        "preferred_backup_window": "07:00-09:00",
+                        "replication_source_identifier": null,
+                        "serverless_v2_scaling_configuration": [],
+                        "skip_final_snapshot": true,
+                        "snapshot_identifier": null,
+                        "storage_encrypted": false,
+                        "tags": {
+                            "test-tag": "insert tag"
+                        },
+                        "tags_all": {
+                            "test-tag": "insert tag"
+                        },
+                        "timeouts": null
+                    },
+                    "sensitive_values": {
+                        "availability_zones": [
+                            false
+                        ],
+                        "cluster_members": [],
+                        "enable_cloudwatch_logs_exports": [
+                            false,
+                            false
+                        ],
+                        "serverless_v2_scaling_configuration": [],
+                        "tags": {},
+                        "tags_all": {},
+                        "vpc_security_group_ids": []
+                    }
+                },
+                {
+                    "address": "aws_neptune_cluster_parameter_group.example_cluster_parameter_group",
+                    "mode": "managed",
+                    "type": "aws_neptune_cluster_parameter_group",
+                    "name": "example_cluster_parameter_group",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "description": "terraform neptune cluster parameter group",
+                        "family": "neptune1.2",
+                        "name": "example",
+                        "parameter": [
+                            {
+                                "apply_method": "pending-reboot",
+                                "name": "neptune_enable_audit_log",
+                                "value": "1"
+                            }
+                        ],
+                        "tags": {
+                            "Name": "My neptune cluster parameter group"
+                        },
+                        "tags_all": {
+                            "Name": "My neptune cluster parameter group"
+                        }
+                    },
+                    "sensitive_values": {
+                        "parameter": [
+                            {}
+                        ],
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_neptune_subnet_group.example_subnet_group",
+                    "mode": "managed",
+                    "type": "aws_neptune_subnet_group",
+                    "name": "example_subnet_group",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "description": "terraform neptune subnet group",
+                        "name": "example",
+                        "tags": {
+                            "Name": "My neptune subnet group"
+                        },
+                        "tags_all": {
+                            "Name": "My neptune subnet group"
+                        }
+                    },
+                    "sensitive_values": {
+                        "subnet_ids": [],
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_subnet.subnet1",
+                    "mode": "managed",
+                    "type": "aws_subnet",
+                    "name": "subnet1",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 1,
+                    "values": {
+                        "assign_ipv6_address_on_creation": false,
+                        "cidr_block": "10.0.1.0/24",
+                        "customer_owned_ipv4_pool": null,
+                        "enable_dns64": false,
+                        "enable_lni_at_device_index": null,
+                        "enable_resource_name_dns_a_record_on_launch": false,
+                        "enable_resource_name_dns_aaaa_record_on_launch": false,
+                        "ipv6_cidr_block": null,
+                        "ipv6_native": false,
+                        "map_customer_owned_ip_on_launch": null,
+                        "map_public_ip_on_launch": false,
+                        "outpost_arn": null,
+                        "tags": null,
+                        "timeouts": null
+                    },
+                    "sensitive_values": {
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_subnet.subnet2",
+                    "mode": "managed",
+                    "type": "aws_subnet",
+                    "name": "subnet2",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 1,
+                    "values": {
+                        "assign_ipv6_address_on_creation": false,
+                        "cidr_block": "10.0.2.0/24",
+                        "customer_owned_ipv4_pool": null,
+                        "enable_dns64": false,
+                        "enable_lni_at_device_index": null,
+                        "enable_resource_name_dns_a_record_on_launch": false,
+                        "enable_resource_name_dns_aaaa_record_on_launch": false,
+                        "ipv6_cidr_block": null,
+                        "ipv6_native": false,
+                        "map_customer_owned_ip_on_launch": null,
+                        "map_public_ip_on_launch": false,
+                        "outpost_arn": null,
+                        "tags": null,
+                        "timeouts": null
+                    },
+                    "sensitive_values": {
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_vpc.example_vpc",
+                    "mode": "managed",
+                    "type": "aws_vpc",
+                    "name": "example_vpc",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 1,
+                    "values": {
+                        "assign_generated_ipv6_cidr_block": null,
+                        "cidr_block": "10.0.0.0/16",
+                        "enable_dns_support": true,
+                        "instance_tenancy": "default",
+                        "ipv4_ipam_pool_id": null,
+                        "ipv4_netmask_length": null,
+                        "ipv6_ipam_pool_id": null,
+                        "ipv6_netmask_length": null,
+                        "tags": null
+                    },
+                    "sensitive_values": {
+                        "tags_all": {}
+                    }
+                }
+            ]
+        }
+    },
+    "resource_changes": [
+        {
+            "address": "aws_neptune_cluster.default",
+            "mode": "managed",
+            "type": "aws_neptune_cluster",
+            "name": "default",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "allow_major_version_upgrade": false,
+                    "apply_immediately": true,
+                    "availability_zones": [
+                        "us-east-1a"
+                    ],
+                    "backup_retention_period": 2,
+                    "cluster_identifier": "neptune-cluster-demo",
+                    "copy_tags_to_snapshot": false,
+                    "deletion_protection": false,
+                    "enable_cloudwatch_logs_exports": [
+                        "audit",
+                        "slowquery"
+                    ],
+                    "engine": "neptune",
+                    "engine_version": "1.2.1.0",
+                    "final_snapshot_identifier": "cluster-final-snapshot",
+                    "global_cluster_identifier": null,
+                    "iam_database_authentication_enabled": false,
+                    "iam_roles": null,
+                    "neptune_instance_parameter_group_name": null,
+                    "port": 8182,
+                    "preferred_backup_window": "07:00-09:00",
+                    "replication_source_identifier": null,
+                    "serverless_v2_scaling_configuration": [],
+                    "skip_final_snapshot": true,
+                    "snapshot_identifier": null,
+                    "storage_encrypted": false,
+                    "tags": {
+                        "test-tag": "insert tag"
+                    },
+                    "tags_all": {
+                        "test-tag": "insert tag"
+                    },
+                    "timeouts": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "availability_zones": [
+                        false
+                    ],
+                    "cluster_identifier_prefix": true,
+                    "cluster_members": true,
+                    "cluster_resource_id": true,
+                    "enable_cloudwatch_logs_exports": [
+                        false,
+                        false
+                    ],
+                    "endpoint": true,
+                    "hosted_zone_id": true,
+                    "id": true,
+                    "kms_key_arn": true,
+                    "neptune_cluster_parameter_group_name": true,
+                    "neptune_subnet_group_name": true,
+                    "preferred_maintenance_window": true,
+                    "reader_endpoint": true,
+                    "serverless_v2_scaling_configuration": [],
+                    "tags": {},
+                    "tags_all": {},
+                    "vpc_security_group_ids": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "availability_zones": [
+                        false
+                    ],
+                    "cluster_members": [],
+                    "enable_cloudwatch_logs_exports": [
+                        false,
+                        false
+                    ],
+                    "serverless_v2_scaling_configuration": [],
+                    "tags": {},
+                    "tags_all": {},
+                    "vpc_security_group_ids": []
+                }
+            }
+        },
+        {
+            "address": "aws_neptune_cluster_parameter_group.example_cluster_parameter_group",
+            "mode": "managed",
+            "type": "aws_neptune_cluster_parameter_group",
+            "name": "example_cluster_parameter_group",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "description": "terraform neptune cluster parameter group",
+                    "family": "neptune1.2",
+                    "name": "example",
+                    "parameter": [
+                        {
+                            "apply_method": "pending-reboot",
+                            "name": "neptune_enable_audit_log",
+                            "value": "1"
+                        }
+                    ],
+                    "tags": {
+                        "Name": "My neptune cluster parameter group"
+                    },
+                    "tags_all": {
+                        "Name": "My neptune cluster parameter group"
+                    }
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "id": true,
+                    "name_prefix": true,
+                    "parameter": [
+                        {}
+                    ],
+                    "tags": {},
+                    "tags_all": {}
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "parameter": [
+                        {}
+                    ],
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_neptune_subnet_group.example_subnet_group",
+            "mode": "managed",
+            "type": "aws_neptune_subnet_group",
+            "name": "example_subnet_group",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "description": "terraform neptune subnet group",
+                    "name": "example",
+                    "tags": {
+                        "Name": "My neptune subnet group"
+                    },
+                    "tags_all": {
+                        "Name": "My neptune subnet group"
+                    }
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "id": true,
+                    "name_prefix": true,
+                    "subnet_ids": true,
+                    "tags": {},
+                    "tags_all": {}
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "subnet_ids": [],
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_subnet.subnet1",
+            "mode": "managed",
+            "type": "aws_subnet",
+            "name": "subnet1",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "assign_ipv6_address_on_creation": false,
+                    "cidr_block": "10.0.1.0/24",
+                    "customer_owned_ipv4_pool": null,
+                    "enable_dns64": false,
+                    "enable_lni_at_device_index": null,
+                    "enable_resource_name_dns_a_record_on_launch": false,
+                    "enable_resource_name_dns_aaaa_record_on_launch": false,
+                    "ipv6_cidr_block": null,
+                    "ipv6_native": false,
+                    "map_customer_owned_ip_on_launch": null,
+                    "map_public_ip_on_launch": false,
+                    "outpost_arn": null,
+                    "tags": null,
+                    "timeouts": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "availability_zone": true,
+                    "availability_zone_id": true,
+                    "id": true,
+                    "ipv6_cidr_block_association_id": true,
+                    "owner_id": true,
+                    "private_dns_hostname_type_on_launch": true,
+                    "tags_all": true,
+                    "vpc_id": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_subnet.subnet2",
+            "mode": "managed",
+            "type": "aws_subnet",
+            "name": "subnet2",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "assign_ipv6_address_on_creation": false,
+                    "cidr_block": "10.0.2.0/24",
+                    "customer_owned_ipv4_pool": null,
+                    "enable_dns64": false,
+                    "enable_lni_at_device_index": null,
+                    "enable_resource_name_dns_a_record_on_launch": false,
+                    "enable_resource_name_dns_aaaa_record_on_launch": false,
+                    "ipv6_cidr_block": null,
+                    "ipv6_native": false,
+                    "map_customer_owned_ip_on_launch": null,
+                    "map_public_ip_on_launch": false,
+                    "outpost_arn": null,
+                    "tags": null,
+                    "timeouts": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "availability_zone": true,
+                    "availability_zone_id": true,
+                    "id": true,
+                    "ipv6_cidr_block_association_id": true,
+                    "owner_id": true,
+                    "private_dns_hostname_type_on_launch": true,
+                    "tags_all": true,
+                    "vpc_id": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_vpc.example_vpc",
+            "mode": "managed",
+            "type": "aws_vpc",
+            "name": "example_vpc",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "assign_generated_ipv6_cidr_block": null,
+                    "cidr_block": "10.0.0.0/16",
+                    "enable_dns_support": true,
+                    "instance_tenancy": "default",
+                    "ipv4_ipam_pool_id": null,
+                    "ipv4_netmask_length": null,
+                    "ipv6_ipam_pool_id": null,
+                    "ipv6_netmask_length": null,
+                    "tags": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "default_network_acl_id": true,
+                    "default_route_table_id": true,
+                    "default_security_group_id": true,
+                    "dhcp_options_id": true,
+                    "enable_dns_hostnames": true,
+                    "enable_network_address_usage_metrics": true,
+                    "id": true,
+                    "ipv6_association_id": true,
+                    "ipv6_cidr_block": true,
+                    "ipv6_cidr_block_network_border_group": true,
+                    "main_route_table_id": true,
+                    "owner_id": true,
+                    "tags_all": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags_all": {}
+                }
+            }
+        }
+    ],
+    "configuration": {
+        "provider_config": {
+            "aws": {
+                "name": "aws",
+                "full_name": "registry.terraform.io/hashicorp/aws"
+            }
+        },
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_neptune_cluster.default",
+                    "mode": "managed",
+                    "type": "aws_neptune_cluster",
+                    "name": "default",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "allow_major_version_upgrade": {
+                            "constant_value": false
+                        },
+                        "apply_immediately": {
+                            "constant_value": true
+                        },
+                        "availability_zones": {
+                            "constant_value": [
+                                "us-east-1a"
+                            ]
+                        },
+                        "backup_retention_period": {
+                            "constant_value": 2
+                        },
+                        "cluster_identifier": {
+                            "constant_value": "neptune-cluster-demo"
+                        },
+                        "copy_tags_to_snapshot": {
+                            "constant_value": false
+                        },
+                        "deletion_protection": {
+                            "constant_value": false
+                        },
+                        "enable_cloudwatch_logs_exports": {
+                            "constant_value": [
+                                "audit",
+                                "slowquery"
+                            ]
+                        },
+                        "engine": {
+                            "constant_value": "neptune"
+                        },
+                        "engine_version": {
+                            "constant_value": "1.2.1.0"
+                        },
+                        "final_snapshot_identifier": {
+                            "constant_value": "cluster-final-snapshot"
+                        },
+                        "iam_database_authentication_enabled": {
+                            "constant_value": false
+                        },
+                        "neptune_cluster_parameter_group_name": {
+                            "references": [
+                                "aws_neptune_cluster_parameter_group.example_cluster_parameter_group.id",
+                                "aws_neptune_cluster_parameter_group.example_cluster_parameter_group"
+                            ]
+                        },
+                        "neptune_subnet_group_name": {
+                            "references": [
+                                "aws_neptune_subnet_group.example_subnet_group.id",
+                                "aws_neptune_subnet_group.example_subnet_group"
+                            ]
+                        },
+                        "port": {
+                            "constant_value": 8182
+                        },
+                        "preferred_backup_window": {
+                            "constant_value": "07:00-09:00"
+                        },
+                        "skip_final_snapshot": {
+                            "constant_value": true
+                        },
+                        "storage_encrypted": {
+                            "constant_value": false
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "test-tag": "insert tag"
+                            }
+                        }
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_neptune_cluster_parameter_group.example_cluster_parameter_group",
+                    "mode": "managed",
+                    "type": "aws_neptune_cluster_parameter_group",
+                    "name": "example_cluster_parameter_group",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "description": {
+                            "constant_value": "terraform neptune cluster parameter group"
+                        },
+                        "family": {
+                            "constant_value": "neptune1.2"
+                        },
+                        "name": {
+                            "constant_value": "example"
+                        },
+                        "parameter": [
+                            {
+                                "name": {
+                                    "constant_value": "neptune_enable_audit_log"
+                                },
+                                "value": {
+                                    "constant_value": 1
+                                }
+                            }
+                        ],
+                        "tags": {
+                            "constant_value": {
+                                "Name": "My neptune cluster parameter group"
+                            }
+                        }
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_neptune_subnet_group.example_subnet_group",
+                    "mode": "managed",
+                    "type": "aws_neptune_subnet_group",
+                    "name": "example_subnet_group",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "description": {
+                            "constant_value": "terraform neptune subnet group"
+                        },
+                        "name": {
+                            "constant_value": "example"
+                        },
+                        "subnet_ids": {
+                            "references": [
+                                "aws_subnet.subnet1.id",
+                                "aws_subnet.subnet1",
+                                "aws_subnet.subnet2.id",
+                                "aws_subnet.subnet2"
+                            ]
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "Name": "My neptune subnet group"
+                            }
+                        }
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_subnet.subnet1",
+                    "mode": "managed",
+                    "type": "aws_subnet",
+                    "name": "subnet1",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "cidr_block": {
+                            "constant_value": "10.0.1.0/24"
+                        },
+                        "vpc_id": {
+                            "references": [
+                                "aws_vpc.example_vpc.id",
+                                "aws_vpc.example_vpc"
+                            ]
+                        }
+                    },
+                    "schema_version": 1
+                },
+                {
+                    "address": "aws_subnet.subnet2",
+                    "mode": "managed",
+                    "type": "aws_subnet",
+                    "name": "subnet2",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "cidr_block": {
+                            "constant_value": "10.0.2.0/24"
+                        },
+                        "vpc_id": {
+                            "references": [
+                                "aws_vpc.example_vpc.id",
+                                "aws_vpc.example_vpc"
+                            ]
+                        }
+                    },
+                    "schema_version": 1
+                },
+                {
+                    "address": "aws_vpc.example_vpc",
+                    "mode": "managed",
+                    "type": "aws_vpc",
+                    "name": "example_vpc",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "cidr_block": {
+                            "constant_value": "10.0.0.0/16"
+                        }
+                    },
+                    "schema_version": 1
+                }
+            ]
+        }
+    },
+    "relevant_attributes": [
+        {
+            "resource": "aws_subnet.subnet1",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_subnet.subnet2",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_neptune_cluster_parameter_group.example_cluster_parameter_group",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_neptune_subnet_group.example_subnet_group",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_vpc.example_vpc",
+            "attribute": [
+                "id"
+            ]
+        }
+    ],
+    "timestamp": "2024-01-03T17:28:49Z",
+    "errored": false
+}

human_reference_dataset/iac-eval/templates/aws_redshift_cluster/sns-event/main.tf ADDED Viewed

	@@ -0,0 +1,55 @@

+resource "aws_redshift_cluster" "example" {
+  cluster_identifier  = "tf-redshift-cluster"
+  database_name       = "mydb"
+  master_username     = "exampleuser"
+  master_password     = "Mustbe8characters"
+  node_type           = "ra3.xlplus"
+  cluster_type        = "single-node"
+  skip_final_snapshot = true
+  cluster_parameter_group_name = aws_redshift_parameter_group.bar.id
+}
+resource "aws_redshift_parameter_group" "bar" {
+  name   = "parameter-group-test-terraform"
+  family = "redshift-1.0"
+  parameter {
+    name  = "require_ssl"
+    value = "true"
+  }
+  parameter {
+    name  = "query_group"
+    value = "example"
+  }
+  parameter {
+    name  = "enable_user_activity_logging"
+    value = "true"
+  }
+}
+resource "aws_sns_topic" "default" {
+  name = "redshift-events"
+}
+resource "aws_redshift_event_subscription" "default" {
+  name          = "redshift-event-sub"
+  sns_topic_arn = aws_sns_topic.default.arn
+  source_type = "cluster-parameter-group"
+  source_ids  = [aws_redshift_parameter_group.bar.id]
+  severity = "INFO"
+  event_categories = [
+    "configuration",
+    "management",
+    "monitoring",
+    "security",
+  ]
+  tags = {
+    Name = "default"
+  }
+}

human_reference_dataset/iac-eval/templates/aws_redshift_cluster/sns-event/tfplan.json ADDED Viewed

	@@ -0,0 +1,577 @@

+{
+    "format_version": "1.2",
+    "terraform_version": "1.6.6",
+    "planned_values": {
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_redshift_cluster.example",
+                    "mode": "managed",
+                    "type": "aws_redshift_cluster",
+                    "name": "example",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "allow_version_upgrade": true,
+                        "apply_immediately": false,
+                        "automated_snapshot_retention_period": 1,
+                        "availability_zone_relocation_enabled": null,
+                        "cluster_identifier": "tf-redshift-cluster",
+                        "cluster_type": "single-node",
+                        "cluster_version": "1.0",
+                        "database_name": "mydb",
+                        "elastic_ip": null,
+                        "encrypted": false,
+                        "final_snapshot_identifier": null,
+                        "logging": [],
+                        "maintenance_track_name": "current",
+                        "manage_master_password": null,
+                        "manual_snapshot_retention_period": -1,
+                        "master_password": "Mustbe8characters",
+                        "master_username": "exampleuser",
+                        "node_type": "ra3.xlplus",
+                        "number_of_nodes": 1,
+                        "owner_account": null,
+                        "port": 5439,
+                        "publicly_accessible": true,
+                        "skip_final_snapshot": true,
+                        "snapshot_arn": null,
+                        "snapshot_cluster_identifier": null,
+                        "snapshot_copy": [],
+                        "snapshot_identifier": null,
+                        "tags": null,
+                        "timeouts": null
+                    },
+                    "sensitive_values": {
+                        "cluster_nodes": [],
+                        "iam_roles": [],
+                        "logging": [],
+                        "snapshot_copy": [],
+                        "tags_all": {},
+                        "vpc_security_group_ids": []
+                    }
+                },
+                {
+                    "address": "aws_redshift_event_subscription.default",
+                    "mode": "managed",
+                    "type": "aws_redshift_event_subscription",
+                    "name": "default",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "enabled": true,
+                        "event_categories": [
+                            "configuration",
+                            "management",
+                            "monitoring",
+                            "security"
+                        ],
+                        "name": "redshift-event-sub",
+                        "severity": "INFO",
+                        "source_type": "cluster-parameter-group",
+                        "tags": {
+                            "Name": "default"
+                        },
+                        "tags_all": {
+                            "Name": "default"
+                        },
+                        "timeouts": null
+                    },
+                    "sensitive_values": {
+                        "event_categories": [
+                            false,
+                            false,
+                            false,
+                            false
+                        ],
+                        "source_ids": [],
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_redshift_parameter_group.bar",
+                    "mode": "managed",
+                    "type": "aws_redshift_parameter_group",
+                    "name": "bar",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "description": "Managed by Terraform",
+                        "family": "redshift-1.0",
+                        "name": "parameter-group-test-terraform",
+                        "parameter": [
+                            {
+                                "name": "enable_user_activity_logging",
+                                "value": "true"
+                            },
+                            {
+                                "name": "query_group",
+                                "value": "example"
+                            },
+                            {
+                                "name": "require_ssl",
+                                "value": "true"
+                            }
+                        ],
+                        "tags": null
+                    },
+                    "sensitive_values": {
+                        "parameter": [
+                            {},
+                            {},
+                            {}
+                        ],
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_sns_topic.default",
+                    "mode": "managed",
+                    "type": "aws_sns_topic",
+                    "name": "default",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "application_failure_feedback_role_arn": null,
+                        "application_success_feedback_role_arn": null,
+                        "application_success_feedback_sample_rate": null,
+                        "archive_policy": null,
+                        "content_based_deduplication": false,
+                        "delivery_policy": null,
+                        "display_name": null,
+                        "fifo_topic": false,
+                        "firehose_failure_feedback_role_arn": null,
+                        "firehose_success_feedback_role_arn": null,
+                        "firehose_success_feedback_sample_rate": null,
+                        "http_failure_feedback_role_arn": null,
+                        "http_success_feedback_role_arn": null,
+                        "http_success_feedback_sample_rate": null,
+                        "kms_master_key_id": null,
+                        "lambda_failure_feedback_role_arn": null,
+                        "lambda_success_feedback_role_arn": null,
+                        "lambda_success_feedback_sample_rate": null,
+                        "name": "redshift-events",
+                        "sqs_failure_feedback_role_arn": null,
+                        "sqs_success_feedback_role_arn": null,
+                        "sqs_success_feedback_sample_rate": null,
+                        "tags": null
+                    },
+                    "sensitive_values": {
+                        "tags_all": {}
+                    }
+                }
+            ]
+        }
+    },
+    "resource_changes": [
+        {
+            "address": "aws_redshift_cluster.example",
+            "mode": "managed",
+            "type": "aws_redshift_cluster",
+            "name": "example",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "allow_version_upgrade": true,
+                    "apply_immediately": false,
+                    "automated_snapshot_retention_period": 1,
+                    "availability_zone_relocation_enabled": null,
+                    "cluster_identifier": "tf-redshift-cluster",
+                    "cluster_type": "single-node",
+                    "cluster_version": "1.0",
+                    "database_name": "mydb",
+                    "elastic_ip": null,
+                    "encrypted": false,
+                    "final_snapshot_identifier": null,
+                    "logging": [],
+                    "maintenance_track_name": "current",
+                    "manage_master_password": null,
+                    "manual_snapshot_retention_period": -1,
+                    "master_password": "Mustbe8characters",
+                    "master_username": "exampleuser",
+                    "node_type": "ra3.xlplus",
+                    "number_of_nodes": 1,
+                    "owner_account": null,
+                    "port": 5439,
+                    "publicly_accessible": true,
+                    "skip_final_snapshot": true,
+                    "snapshot_arn": null,
+                    "snapshot_cluster_identifier": null,
+                    "snapshot_copy": [],
+                    "snapshot_identifier": null,
+                    "tags": null,
+                    "timeouts": null
+                },
+                "after_unknown": {
+                    "aqua_configuration_status": true,
+                    "arn": true,
+                    "availability_zone": true,
+                    "cluster_namespace_arn": true,
+                    "cluster_nodes": true,
+                    "cluster_parameter_group_name": true,
+                    "cluster_public_key": true,
+                    "cluster_revision_number": true,
+                    "cluster_subnet_group_name": true,
+                    "default_iam_role_arn": true,
+                    "dns_name": true,
+                    "endpoint": true,
+                    "enhanced_vpc_routing": true,
+                    "iam_roles": true,
+                    "id": true,
+                    "kms_key_id": true,
+                    "logging": [],
+                    "master_password_secret_arn": true,
+                    "master_password_secret_kms_key_id": true,
+                    "preferred_maintenance_window": true,
+                    "snapshot_copy": [],
+                    "tags_all": true,
+                    "vpc_security_group_ids": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "cluster_nodes": [],
+                    "iam_roles": [],
+                    "logging": [],
+                    "master_password": true,
+                    "snapshot_copy": [],
+                    "tags_all": {},
+                    "vpc_security_group_ids": []
+                }
+            }
+        },
+        {
+            "address": "aws_redshift_event_subscription.default",
+            "mode": "managed",
+            "type": "aws_redshift_event_subscription",
+            "name": "default",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "enabled": true,
+                    "event_categories": [
+                        "configuration",
+                        "management",
+                        "monitoring",
+                        "security"
+                    ],
+                    "name": "redshift-event-sub",
+                    "severity": "INFO",
+                    "source_type": "cluster-parameter-group",
+                    "tags": {
+                        "Name": "default"
+                    },
+                    "tags_all": {
+                        "Name": "default"
+                    },
+                    "timeouts": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "customer_aws_id": true,
+                    "event_categories": [
+                        false,
+                        false,
+                        false,
+                        false
+                    ],
+                    "id": true,
+                    "sns_topic_arn": true,
+                    "source_ids": true,
+                    "status": true,
+                    "tags": {},
+                    "tags_all": {}
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "event_categories": [
+                        false,
+                        false,
+                        false,
+                        false
+                    ],
+                    "source_ids": [],
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_redshift_parameter_group.bar",
+            "mode": "managed",
+            "type": "aws_redshift_parameter_group",
+            "name": "bar",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "description": "Managed by Terraform",
+                    "family": "redshift-1.0",
+                    "name": "parameter-group-test-terraform",
+                    "parameter": [
+                        {
+                            "name": "enable_user_activity_logging",
+                            "value": "true"
+                        },
+                        {
+                            "name": "query_group",
+                            "value": "example"
+                        },
+                        {
+                            "name": "require_ssl",
+                            "value": "true"
+                        }
+                    ],
+                    "tags": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "id": true,
+                    "parameter": [
+                        {},
+                        {},
+                        {}
+                    ],
+                    "tags_all": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "parameter": [
+                        {},
+                        {},
+                        {}
+                    ],
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_sns_topic.default",
+            "mode": "managed",
+            "type": "aws_sns_topic",
+            "name": "default",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "application_failure_feedback_role_arn": null,
+                    "application_success_feedback_role_arn": null,
+                    "application_success_feedback_sample_rate": null,
+                    "archive_policy": null,
+                    "content_based_deduplication": false,
+                    "delivery_policy": null,
+                    "display_name": null,
+                    "fifo_topic": false,
+                    "firehose_failure_feedback_role_arn": null,
+                    "firehose_success_feedback_role_arn": null,
+                    "firehose_success_feedback_sample_rate": null,
+                    "http_failure_feedback_role_arn": null,
+                    "http_success_feedback_role_arn": null,
+                    "http_success_feedback_sample_rate": null,
+                    "kms_master_key_id": null,
+                    "lambda_failure_feedback_role_arn": null,
+                    "lambda_success_feedback_role_arn": null,
+                    "lambda_success_feedback_sample_rate": null,
+                    "name": "redshift-events",
+                    "sqs_failure_feedback_role_arn": null,
+                    "sqs_success_feedback_role_arn": null,
+                    "sqs_success_feedback_sample_rate": null,
+                    "tags": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "beginning_archive_time": true,
+                    "id": true,
+                    "name_prefix": true,
+                    "owner": true,
+                    "policy": true,
+                    "signature_version": true,
+                    "tags_all": true,
+                    "tracing_config": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags_all": {}
+                }
+            }
+        }
+    ],
+    "configuration": {
+        "provider_config": {
+            "aws": {
+                "name": "aws",
+                "full_name": "registry.terraform.io/hashicorp/aws"
+            }
+        },
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_redshift_cluster.example",
+                    "mode": "managed",
+                    "type": "aws_redshift_cluster",
+                    "name": "example",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "cluster_identifier": {
+                            "constant_value": "tf-redshift-cluster"
+                        },
+                        "cluster_parameter_group_name": {
+                            "references": [
+                                "aws_redshift_parameter_group.bar.id",
+                                "aws_redshift_parameter_group.bar"
+                            ]
+                        },
+                        "cluster_type": {
+                            "constant_value": "single-node"
+                        },
+                        "database_name": {
+                            "constant_value": "mydb"
+                        },
+                        "master_password": {
+                            "constant_value": "Mustbe8characters"
+                        },
+                        "master_username": {
+                            "constant_value": "exampleuser"
+                        },
+                        "node_type": {
+                            "constant_value": "ra3.xlplus"
+                        },
+                        "skip_final_snapshot": {
+                            "constant_value": true
+                        }
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_redshift_event_subscription.default",
+                    "mode": "managed",
+                    "type": "aws_redshift_event_subscription",
+                    "name": "default",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "event_categories": {
+                            "constant_value": [
+                                "configuration",
+                                "management",
+                                "monitoring",
+                                "security"
+                            ]
+                        },
+                        "name": {
+                            "constant_value": "redshift-event-sub"
+                        },
+                        "severity": {
+                            "constant_value": "INFO"
+                        },
+                        "sns_topic_arn": {
+                            "references": [
+                                "aws_sns_topic.default.arn",
+                                "aws_sns_topic.default"
+                            ]
+                        },
+                        "source_ids": {
+                            "references": [
+                                "aws_redshift_parameter_group.bar.id",
+                                "aws_redshift_parameter_group.bar"
+                            ]
+                        },
+                        "source_type": {
+                            "constant_value": "cluster-parameter-group"
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "Name": "default"
+                            }
+                        }
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_redshift_parameter_group.bar",
+                    "mode": "managed",
+                    "type": "aws_redshift_parameter_group",
+                    "name": "bar",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "family": {
+                            "constant_value": "redshift-1.0"
+                        },
+                        "name": {
+                            "constant_value": "parameter-group-test-terraform"
+                        },
+                        "parameter": [
+                            {
+                                "name": {
+                                    "constant_value": "require_ssl"
+                                },
+                                "value": {
+                                    "constant_value": "true"
+                                }
+                            },
+                            {
+                                "name": {
+                                    "constant_value": "query_group"
+                                },
+                                "value": {
+                                    "constant_value": "example"
+                                }
+                            },
+                            {
+                                "name": {
+                                    "constant_value": "enable_user_activity_logging"
+                                },
+                                "value": {
+                                    "constant_value": "true"
+                                }
+                            }
+                        ]
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_sns_topic.default",
+                    "mode": "managed",
+                    "type": "aws_sns_topic",
+                    "name": "default",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "name": {
+                            "constant_value": "redshift-events"
+                        }
+                    },
+                    "schema_version": 0
+                }
+            ]
+        }
+    },
+    "relevant_attributes": [
+        {
+            "resource": "aws_redshift_parameter_group.bar",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_sns_topic.default",
+            "attribute": [
+                "arn"
+            ]
+        }
+    ],
+    "timestamp": "2024-01-04T04:48:23Z",
+    "errored": false
+}

human_reference_dataset/iac-eval/templates/aws_redshift_cluster/subnet-group/main.tf ADDED Viewed

	@@ -0,0 +1,48 @@

+resource "aws_redshift_cluster" "example" {
+  cluster_identifier = "tf-redshift-cluster"
+  database_name      = "mydb"
+  master_username    = "exampleuser"
+  master_password    = "Mustbe8characters"
+  node_type          = "ra3.xlplus"
+  cluster_type       = "single-node"
+  skip_final_snapshot = true
+}
+resource "aws_redshift_endpoint_access" "example" {
+  endpoint_name      = "example"
+  subnet_group_name  = aws_redshift_subnet_group.foobar.id
+  cluster_identifier = aws_redshift_cluster.example.cluster_identifier
+}
+resource "aws_vpc" "foo" {
+  cidr_block = "10.1.0.0/16"
+}
+resource "aws_subnet" "foo" {
+  cidr_block        = "10.1.1.0/24"
+  availability_zone = "us-east-1a"
+  vpc_id            = aws_vpc.foo.id
+  tags = {
+    Name = "tf-dbsubnet-test-1"
+  }
+}
+resource "aws_subnet" "bar" {
+  cidr_block        = "10.1.2.0/24"
+  availability_zone = "us-east-1b"
+  vpc_id            = aws_vpc.foo.id
+  tags = {
+    Name = "tf-dbsubnet-test-2"
+  }
+}
+resource "aws_redshift_subnet_group" "foobar" {
+  name       = "foo"
+  subnet_ids = [aws_subnet.foo.id, aws_subnet.bar.id]
+  tags = {
+    environment = "Production"
+  }
+}

human_reference_dataset/iac-eval/templates/aws_redshift_cluster/subnet-group/tfplan.json ADDED Viewed

	@@ -0,0 +1,675 @@

+{
+    "format_version": "1.2",
+    "terraform_version": "1.6.6",
+    "planned_values": {
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_redshift_cluster.example",
+                    "mode": "managed",
+                    "type": "aws_redshift_cluster",
+                    "name": "example",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "allow_version_upgrade": true,
+                        "apply_immediately": false,
+                        "automated_snapshot_retention_period": 1,
+                        "availability_zone_relocation_enabled": null,
+                        "cluster_identifier": "tf-redshift-cluster",
+                        "cluster_type": "single-node",
+                        "cluster_version": "1.0",
+                        "database_name": "mydb",
+                        "elastic_ip": null,
+                        "encrypted": false,
+                        "final_snapshot_identifier": null,
+                        "logging": [],
+                        "maintenance_track_name": "current",
+                        "manage_master_password": null,
+                        "manual_snapshot_retention_period": -1,
+                        "master_password": "Mustbe8characters",
+                        "master_username": "exampleuser",
+                        "node_type": "ra3.xlplus",
+                        "number_of_nodes": 1,
+                        "owner_account": null,
+                        "port": 5439,
+                        "publicly_accessible": true,
+                        "skip_final_snapshot": true,
+                        "snapshot_arn": null,
+                        "snapshot_cluster_identifier": null,
+                        "snapshot_copy": [],
+                        "snapshot_identifier": null,
+                        "tags": null,
+                        "timeouts": null
+                    },
+                    "sensitive_values": {
+                        "cluster_nodes": [],
+                        "iam_roles": [],
+                        "logging": [],
+                        "snapshot_copy": [],
+                        "tags_all": {},
+                        "vpc_security_group_ids": []
+                    }
+                },
+                {
+                    "address": "aws_redshift_endpoint_access.example",
+                    "mode": "managed",
+                    "type": "aws_redshift_endpoint_access",
+                    "name": "example",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "cluster_identifier": "tf-redshift-cluster",
+                        "endpoint_name": "example"
+                    },
+                    "sensitive_values": {
+                        "vpc_endpoint": [],
+                        "vpc_security_group_ids": []
+                    }
+                },
+                {
+                    "address": "aws_redshift_subnet_group.foobar",
+                    "mode": "managed",
+                    "type": "aws_redshift_subnet_group",
+                    "name": "foobar",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 0,
+                    "values": {
+                        "description": "Managed by Terraform",
+                        "name": "foo",
+                        "tags": {
+                            "environment": "Production"
+                        },
+                        "tags_all": {
+                            "environment": "Production"
+                        }
+                    },
+                    "sensitive_values": {
+                        "subnet_ids": [],
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_subnet.bar",
+                    "mode": "managed",
+                    "type": "aws_subnet",
+                    "name": "bar",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 1,
+                    "values": {
+                        "assign_ipv6_address_on_creation": false,
+                        "availability_zone": "us-east-1b",
+                        "cidr_block": "10.1.2.0/24",
+                        "customer_owned_ipv4_pool": null,
+                        "enable_dns64": false,
+                        "enable_lni_at_device_index": null,
+                        "enable_resource_name_dns_a_record_on_launch": false,
+                        "enable_resource_name_dns_aaaa_record_on_launch": false,
+                        "ipv6_cidr_block": null,
+                        "ipv6_native": false,
+                        "map_customer_owned_ip_on_launch": null,
+                        "map_public_ip_on_launch": false,
+                        "outpost_arn": null,
+                        "tags": {
+                            "Name": "tf-dbsubnet-test-2"
+                        },
+                        "tags_all": {
+                            "Name": "tf-dbsubnet-test-2"
+                        },
+                        "timeouts": null
+                    },
+                    "sensitive_values": {
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_subnet.foo",
+                    "mode": "managed",
+                    "type": "aws_subnet",
+                    "name": "foo",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 1,
+                    "values": {
+                        "assign_ipv6_address_on_creation": false,
+                        "availability_zone": "us-east-1a",
+                        "cidr_block": "10.1.1.0/24",
+                        "customer_owned_ipv4_pool": null,
+                        "enable_dns64": false,
+                        "enable_lni_at_device_index": null,
+                        "enable_resource_name_dns_a_record_on_launch": false,
+                        "enable_resource_name_dns_aaaa_record_on_launch": false,
+                        "ipv6_cidr_block": null,
+                        "ipv6_native": false,
+                        "map_customer_owned_ip_on_launch": null,
+                        "map_public_ip_on_launch": false,
+                        "outpost_arn": null,
+                        "tags": {
+                            "Name": "tf-dbsubnet-test-1"
+                        },
+                        "tags_all": {
+                            "Name": "tf-dbsubnet-test-1"
+                        },
+                        "timeouts": null
+                    },
+                    "sensitive_values": {
+                        "tags": {},
+                        "tags_all": {}
+                    }
+                },
+                {
+                    "address": "aws_vpc.foo",
+                    "mode": "managed",
+                    "type": "aws_vpc",
+                    "name": "foo",
+                    "provider_name": "registry.terraform.io/hashicorp/aws",
+                    "schema_version": 1,
+                    "values": {
+                        "assign_generated_ipv6_cidr_block": null,
+                        "cidr_block": "10.1.0.0/16",
+                        "enable_dns_support": true,
+                        "instance_tenancy": "default",
+                        "ipv4_ipam_pool_id": null,
+                        "ipv4_netmask_length": null,
+                        "ipv6_ipam_pool_id": null,
+                        "ipv6_netmask_length": null,
+                        "tags": null
+                    },
+                    "sensitive_values": {
+                        "tags_all": {}
+                    }
+                }
+            ]
+        }
+    },
+    "resource_changes": [
+        {
+            "address": "aws_redshift_cluster.example",
+            "mode": "managed",
+            "type": "aws_redshift_cluster",
+            "name": "example",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "allow_version_upgrade": true,
+                    "apply_immediately": false,
+                    "automated_snapshot_retention_period": 1,
+                    "availability_zone_relocation_enabled": null,
+                    "cluster_identifier": "tf-redshift-cluster",
+                    "cluster_type": "single-node",
+                    "cluster_version": "1.0",
+                    "database_name": "mydb",
+                    "elastic_ip": null,
+                    "encrypted": false,
+                    "final_snapshot_identifier": null,
+                    "logging": [],
+                    "maintenance_track_name": "current",
+                    "manage_master_password": null,
+                    "manual_snapshot_retention_period": -1,
+                    "master_password": "Mustbe8characters",
+                    "master_username": "exampleuser",
+                    "node_type": "ra3.xlplus",
+                    "number_of_nodes": 1,
+                    "owner_account": null,
+                    "port": 5439,
+                    "publicly_accessible": true,
+                    "skip_final_snapshot": true,
+                    "snapshot_arn": null,
+                    "snapshot_cluster_identifier": null,
+                    "snapshot_copy": [],
+                    "snapshot_identifier": null,
+                    "tags": null,
+                    "timeouts": null
+                },
+                "after_unknown": {
+                    "aqua_configuration_status": true,
+                    "arn": true,
+                    "availability_zone": true,
+                    "cluster_namespace_arn": true,
+                    "cluster_nodes": true,
+                    "cluster_parameter_group_name": true,
+                    "cluster_public_key": true,
+                    "cluster_revision_number": true,
+                    "cluster_subnet_group_name": true,
+                    "default_iam_role_arn": true,
+                    "dns_name": true,
+                    "endpoint": true,
+                    "enhanced_vpc_routing": true,
+                    "iam_roles": true,
+                    "id": true,
+                    "kms_key_id": true,
+                    "logging": [],
+                    "master_password_secret_arn": true,
+                    "master_password_secret_kms_key_id": true,
+                    "preferred_maintenance_window": true,
+                    "snapshot_copy": [],
+                    "tags_all": true,
+                    "vpc_security_group_ids": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "cluster_nodes": [],
+                    "iam_roles": [],
+                    "logging": [],
+                    "master_password": true,
+                    "snapshot_copy": [],
+                    "tags_all": {},
+                    "vpc_security_group_ids": []
+                }
+            }
+        },
+        {
+            "address": "aws_redshift_endpoint_access.example",
+            "mode": "managed",
+            "type": "aws_redshift_endpoint_access",
+            "name": "example",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "cluster_identifier": "tf-redshift-cluster",
+                    "endpoint_name": "example"
+                },
+                "after_unknown": {
+                    "address": true,
+                    "id": true,
+                    "port": true,
+                    "resource_owner": true,
+                    "subnet_group_name": true,
+                    "vpc_endpoint": true,
+                    "vpc_security_group_ids": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "vpc_endpoint": [],
+                    "vpc_security_group_ids": []
+                }
+            }
+        },
+        {
+            "address": "aws_redshift_subnet_group.foobar",
+            "mode": "managed",
+            "type": "aws_redshift_subnet_group",
+            "name": "foobar",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "description": "Managed by Terraform",
+                    "name": "foo",
+                    "tags": {
+                        "environment": "Production"
+                    },
+                    "tags_all": {
+                        "environment": "Production"
+                    }
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "id": true,
+                    "subnet_ids": true,
+                    "tags": {},
+                    "tags_all": {}
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "subnet_ids": [],
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_subnet.bar",
+            "mode": "managed",
+            "type": "aws_subnet",
+            "name": "bar",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "assign_ipv6_address_on_creation": false,
+                    "availability_zone": "us-east-1b",
+                    "cidr_block": "10.1.2.0/24",
+                    "customer_owned_ipv4_pool": null,
+                    "enable_dns64": false,
+                    "enable_lni_at_device_index": null,
+                    "enable_resource_name_dns_a_record_on_launch": false,
+                    "enable_resource_name_dns_aaaa_record_on_launch": false,
+                    "ipv6_cidr_block": null,
+                    "ipv6_native": false,
+                    "map_customer_owned_ip_on_launch": null,
+                    "map_public_ip_on_launch": false,
+                    "outpost_arn": null,
+                    "tags": {
+                        "Name": "tf-dbsubnet-test-2"
+                    },
+                    "tags_all": {
+                        "Name": "tf-dbsubnet-test-2"
+                    },
+                    "timeouts": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "availability_zone_id": true,
+                    "id": true,
+                    "ipv6_cidr_block_association_id": true,
+                    "owner_id": true,
+                    "private_dns_hostname_type_on_launch": true,
+                    "tags": {},
+                    "tags_all": {},
+                    "vpc_id": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_subnet.foo",
+            "mode": "managed",
+            "type": "aws_subnet",
+            "name": "foo",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "assign_ipv6_address_on_creation": false,
+                    "availability_zone": "us-east-1a",
+                    "cidr_block": "10.1.1.0/24",
+                    "customer_owned_ipv4_pool": null,
+                    "enable_dns64": false,
+                    "enable_lni_at_device_index": null,
+                    "enable_resource_name_dns_a_record_on_launch": false,
+                    "enable_resource_name_dns_aaaa_record_on_launch": false,
+                    "ipv6_cidr_block": null,
+                    "ipv6_native": false,
+                    "map_customer_owned_ip_on_launch": null,
+                    "map_public_ip_on_launch": false,
+                    "outpost_arn": null,
+                    "tags": {
+                        "Name": "tf-dbsubnet-test-1"
+                    },
+                    "tags_all": {
+                        "Name": "tf-dbsubnet-test-1"
+                    },
+                    "timeouts": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "availability_zone_id": true,
+                    "id": true,
+                    "ipv6_cidr_block_association_id": true,
+                    "owner_id": true,
+                    "private_dns_hostname_type_on_launch": true,
+                    "tags": {},
+                    "tags_all": {},
+                    "vpc_id": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags": {},
+                    "tags_all": {}
+                }
+            }
+        },
+        {
+            "address": "aws_vpc.foo",
+            "mode": "managed",
+            "type": "aws_vpc",
+            "name": "foo",
+            "provider_name": "registry.terraform.io/hashicorp/aws",
+            "change": {
+                "actions": [
+                    "create"
+                ],
+                "before": null,
+                "after": {
+                    "assign_generated_ipv6_cidr_block": null,
+                    "cidr_block": "10.1.0.0/16",
+                    "enable_dns_support": true,
+                    "instance_tenancy": "default",
+                    "ipv4_ipam_pool_id": null,
+                    "ipv4_netmask_length": null,
+                    "ipv6_ipam_pool_id": null,
+                    "ipv6_netmask_length": null,
+                    "tags": null
+                },
+                "after_unknown": {
+                    "arn": true,
+                    "default_network_acl_id": true,
+                    "default_route_table_id": true,
+                    "default_security_group_id": true,
+                    "dhcp_options_id": true,
+                    "enable_dns_hostnames": true,
+                    "enable_network_address_usage_metrics": true,
+                    "id": true,
+                    "ipv6_association_id": true,
+                    "ipv6_cidr_block": true,
+                    "ipv6_cidr_block_network_border_group": true,
+                    "main_route_table_id": true,
+                    "owner_id": true,
+                    "tags_all": true
+                },
+                "before_sensitive": false,
+                "after_sensitive": {
+                    "tags_all": {}
+                }
+            }
+        }
+    ],
+    "configuration": {
+        "provider_config": {
+            "aws": {
+                "name": "aws",
+                "full_name": "registry.terraform.io/hashicorp/aws"
+            }
+        },
+        "root_module": {
+            "resources": [
+                {
+                    "address": "aws_redshift_cluster.example",
+                    "mode": "managed",
+                    "type": "aws_redshift_cluster",
+                    "name": "example",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "cluster_identifier": {
+                            "constant_value": "tf-redshift-cluster"
+                        },
+                        "cluster_type": {
+                            "constant_value": "single-node"
+                        },
+                        "database_name": {
+                            "constant_value": "mydb"
+                        },
+                        "master_password": {
+                            "constant_value": "Mustbe8characters"
+                        },
+                        "master_username": {
+                            "constant_value": "exampleuser"
+                        },
+                        "node_type": {
+                            "constant_value": "ra3.xlplus"
+                        },
+                        "skip_final_snapshot": {
+                            "constant_value": true
+                        }
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_redshift_endpoint_access.example",
+                    "mode": "managed",
+                    "type": "aws_redshift_endpoint_access",
+                    "name": "example",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "cluster_identifier": {
+                            "references": [
+                                "aws_redshift_cluster.example.cluster_identifier",
+                                "aws_redshift_cluster.example"
+                            ]
+                        },
+                        "endpoint_name": {
+                            "constant_value": "example"
+                        },
+                        "subnet_group_name": {
+                            "references": [
+                                "aws_redshift_subnet_group.foobar.id",
+                                "aws_redshift_subnet_group.foobar"
+                            ]
+                        }
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_redshift_subnet_group.foobar",
+                    "mode": "managed",
+                    "type": "aws_redshift_subnet_group",
+                    "name": "foobar",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "name": {
+                            "constant_value": "foo"
+                        },
+                        "subnet_ids": {
+                            "references": [
+                                "aws_subnet.foo.id",
+                                "aws_subnet.foo",
+                                "aws_subnet.bar.id",
+                                "aws_subnet.bar"
+                            ]
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "environment": "Production"
+                            }
+                        }
+                    },
+                    "schema_version": 0
+                },
+                {
+                    "address": "aws_subnet.bar",
+                    "mode": "managed",
+                    "type": "aws_subnet",
+                    "name": "bar",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "availability_zone": {
+                            "constant_value": "us-east-1b"
+                        },
+                        "cidr_block": {
+                            "constant_value": "10.1.2.0/24"
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "Name": "tf-dbsubnet-test-2"
+                            }
+                        },
+                        "vpc_id": {
+                            "references": [
+                                "aws_vpc.foo.id",
+                                "aws_vpc.foo"
+                            ]
+                        }
+                    },
+                    "schema_version": 1
+                },
+                {
+                    "address": "aws_subnet.foo",
+                    "mode": "managed",
+                    "type": "aws_subnet",
+                    "name": "foo",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "availability_zone": {
+                            "constant_value": "us-east-1a"
+                        },
+                        "cidr_block": {
+                            "constant_value": "10.1.1.0/24"
+                        },
+                        "tags": {
+                            "constant_value": {
+                                "Name": "tf-dbsubnet-test-1"
+                            }
+                        },
+                        "vpc_id": {
+                            "references": [
+                                "aws_vpc.foo.id",
+                                "aws_vpc.foo"
+                            ]
+                        }
+                    },
+                    "schema_version": 1
+                },
+                {
+                    "address": "aws_vpc.foo",
+                    "mode": "managed",
+                    "type": "aws_vpc",
+                    "name": "foo",
+                    "provider_config_key": "aws",
+                    "expressions": {
+                        "cidr_block": {
+                            "constant_value": "10.1.0.0/16"
+                        }
+                    },
+                    "schema_version": 1
+                }
+            ]
+        }
+    },
+    "relevant_attributes": [
+        {
+            "resource": "aws_vpc.foo",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_subnet.foo",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_subnet.bar",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_redshift_subnet_group.foobar",
+            "attribute": [
+                "id"
+            ]
+        },
+        {
+            "resource": "aws_redshift_cluster.example",
+            "attribute": [
+                "cluster_identifier"
+            ]
+        }
+    ],
+    "timestamp": "2024-01-04T04:13:46Z",
+    "errored": false
+}