janus-llm 4.3.5__py3-none-any.whl → 4.5.4__py3-none-any.whl

janus/metrics/metric.py

@@ -1,12 +1,13 @@
 import inspect
 import json
-from pathlib import Path
 from typing import Callable, Optional
 
 import click
 import typer
 from typing_extensions import Annotated
 
+from janus.cli.constants import CONVERTERS
+from janus.converter.converter import Converter
 from janus.llm import load_model
 from janus.llm.model_callbacks import COST_PER_1K_TOKENS
 from janus.metrics.cli import evaluate
@@ -70,31 +71,6 @@ def metric(
                         help="Reference file or string to use as reference/baseline.",
                     ),
                 ] = None,
-                json_file_name: Annotated[
-                    Optional[str],
-                    typer.Option(
-                        "--json",
-                        "-j",
-                        help="Json file to extract pairs from \
-                            (if set ignores --target and --reference)",
-                    ),
-                ] = None,
-                target_key: Annotated[
-                    str,
-                    typer.Option(
-                        "--target-key",
-                        "-tk",
-                        help="json key to extract list of target strings",
-                    ),
-                ] = "target",
-                reference_key: Annotated[
-                    str,
-                    typer.Option(
-                        "--reference-key",
-                        "-rk",
-                        help="json key to extract list of reference strings",
-                    ),
-                ] = "reference",
                 file_pairing_method: Annotated[
                     str,
                     typer.Option(
@@ -123,6 +99,14 @@ def metric(
                         is_flag=True,
                     ),
                 ] = False,
+                use_janus_inputs: Annotated[
+                    bool,
+                    typer.Option(
+                        "-j",
+                        "--use-janus-inputs",
+                        help="present if janus output files should be evaluated",
+                    ),
+                ] = False,
                 use_strings: Annotated[
                     bool,
                     typer.Option(
@@ -137,25 +121,23 @@ def metric(
             ):
                 out = []
                 llm = load_model(llm_name)
-                if json_file_name is not None:
-                    with open(json_file_name, "r") as f:
-                        json_obj = json.load(f)
-                    pairs = {}
-                    for key in json_obj:
-                        doc = json_obj[key]
-                        ref = doc[reference_key]
-                        experiments = doc["experiments"]
-                        for model_key in experiments:
-                            model_dict = experiments[model_key]
-                            if not isinstance(model_dict, dict):
-                                continue
-                            if target_key not in model_dict:
-                                continue
-                            if model_key not in pairs:
-                                pairs[model_key] = {}
-                            for k in model_dict[target_key]:
-                                pairs[model_key][k] = (model_dict[target_key][k], ref[k])
-                elif target is not None and reference is not None:
+                if use_janus_inputs:
+                    with open(target, "r") as f:
+                        target_obj = json.load(f)
+                    with open(reference, "r") as f:
+                        reference_obj = json.load(f)
+                    converter_cls = CONVERTERS.get(
+                        target_obj["metadata"].get("converter_name", "Converter"),
+                        Converter,
+                    )
+                    out = converter_cls.eval_obj_reference(
+                        target=target_obj,
+                        reference=reference_obj,
+                        metric_func=function,
+                        *args,
+                        **kwargs,
+                    )
+                else:
                     if use_strings:
                         target_contents = target
                         reference_contents = reference
@@ -175,25 +157,6 @@ def metric(
                         token_limit=llm.token_limit,
                         model_cost=COST_PER_1K_TOKENS[llm.model_id],
                     )
-                else:
-                    raise ValueError(
-                        "Error, specify json or target and reference files/strings"
-                    )
-                if isinstance(pairs, dict):
-                    out = {}
-                    for k in pairs:
-                        out[k] = apply_function_pairs(
-                            pairs[k],
-                            function,
-                            progress,
-                            language,
-                            llm,
-                            llm.token_limit,
-                            COST_PER_1K_TOKENS[llm.model_id],
-                            *args,
-                            **kwargs,
-                        )
-                else:
                     out = apply_function_pairs(
                         pairs,
                         function,
@@ -205,17 +168,15 @@ def metric(
                         *args,
                         **kwargs,
                     )
-                out_file = Path(out_file)
-                out_file.parent.mkdir(parents=True, exist_ok=True)
                 with open(out_file, "w") as f:
+                    log.info(f"Writing output to {out_file}")
                     json.dump(out, f)
-                    log.info(f"Saved results to file: {out_file}")
 
             sig1 = inspect.signature(function)
             sig2 = inspect.signature(func)
             func.__signature__ = sig2.replace(
                 parameters=tuple(
-                    list(sig2.parameters.values())[:11]
+                    list(sig2.parameters.values())[:9]
                     + list(sig1.parameters.values())[2:-1]
                 )
             )
@@ -241,23 +202,14 @@ def metric(
                         "--target", "-t", help="Target file or string to evaluate."
                     ),
                 ] = None,
-                json_file_name: Annotated[
-                    Optional[str],
+                use_janus_inputs: Annotated[
+                    bool,
                     typer.Option(
-                        "--json",
                         "-j",
-                        help="Json file to extract pairs from \
-                            (if set ignores --target)",
+                        "--use-janus-inputs",
+                        help="whether to use a janus output file as input",
                     ),
-                ] = None,
-                target_key: Annotated[
-                    str,
-                    typer.Option(
-                        "--target-key",
-                        "-tk",
-                        help="json key to extract list of target strings",
-                    ),
-                ] = "target",
+                ] = False,
                 splitting_method: Annotated[
                     str,
                     typer.Option(
@@ -298,25 +250,17 @@ def metric(
                 **kwargs,
             ):
                 llm = load_model(llm_name)
-                if json_file_name is not None:
-                    with open(json_file_name, "r") as f:
-                        json_obj = json.load(f)
-                    strings = {}
-                    for key in json_obj:
-                        doc = json_obj[key]
-                        experiments = doc["experiments"]
-                        for model_key in experiments:
-                            model_dict = experiments[model_key]
-                            if not isinstance(model_dict, dict):
-                                continue
-                            if target_key not in model_dict:
-                                continue
-                            if model_key not in strings:
-                                strings[model_key] = {}
-                            for k in model_dict[target_key]:
-                                strings[model_key][k] = model_dict[target_key][k]
-                        # strings += list(json_obj[key][target_key].values())
-                elif target is not None:
+                if use_janus_inputs:
+                    with open(target, "r") as f:
+                        target_obj = json.load(f)
+                    converter_cls = CONVERTERS.get(
+                        target_obj["metadata"].get("converter_name", "Converter"),
+                        Converter,
+                    )
+                    out = converter_cls.eval_obj(
+                        target=target_obj, metric_func=function, *args, **kwargs
+                    )
+                else:
                     if use_strings:
                         target_contents = target
                     else:
@@ -332,25 +276,6 @@ def metric(
                         token_limit=llm.token_limit,
                         model_cost=COST_PER_1K_TOKENS[llm.model_id],
                     )
-                else:
-                    raise ValueError(
-                        "Error: must specify either json file or target file/string"
-                    )
-                if isinstance(strings, dict):
-                    out = {}
-                    for k in strings:
-                        out[k] = apply_function_strings(
-                            strings[k],
-                            function,
-                            progress,
-                            language,
-                            llm,
-                            llm.token_limit,
-                            COST_PER_1K_TOKENS[llm.model_id],
-                            *args,
-                            **kwargs,
-                        )
-                else:
                     out = apply_function_strings(
                         strings,
                         function,
@@ -362,17 +287,15 @@ def metric(
                         *args,
                         **kwargs,
                     )
-                out_file = Path(out_file)
-                out_file.parent.mkdir(parents=True, exist_ok=True)
                 with open(out_file, "w") as f:
+                    log.info(f"Writing output to {out_file}")
                     json.dump(out, f)
-                    log.info(f"Saved results to file: {out_file}")
 
             sig1 = inspect.signature(function)
             sig2 = inspect.signature(func)
             func.__signature__ = sig2.replace(
                 parameters=tuple(
-                    list(sig2.parameters.values())[:9]
+                    list(sig2.parameters.values())[:7]
                     + list(sig1.parameters.values())[1:-1]
                 )
             )

janus/metrics/reading.py

@@ -1,8 +1,7 @@
 import re
 
-import nltk
-import readability
 from nltk.tokenize import TweetTokenizer
+from textstat import textstat
 
 from janus.metrics.metric import metric
 
@@ -48,23 +47,9 @@ def _repeat_text(text):
     return repeated_text
 
 
-def get_readability(target: str) -> readability.Readability:
-    """Create a Readability object from an input string
-
-    Arguments:
-        target: The target text.
-
-    Returns:
-        py-readability-metrics Readability object for that text
-    """
-    nltk.download("punkt", quiet=True)
-    target = _repeat_text(target)
-    return readability.Readability(target)
-
-
 @metric(use_reference=False, help="The Flesch Readability score")
 def flesch(target: str, **kwargs) -> float:
-    """Calculate the Flesch Score using py-readability-metrics.
+    """Calculate the Flesch Score using textstat.
 
     Arguments:
         target: The target text.
@@ -74,12 +59,13 @@ def flesch(target: str, **kwargs) -> float:
     """
     if not target.strip():  # Check if the target text is blank
         return None
-    return get_readability(target).flesch().score
+    target = _repeat_text(target)
+    return textstat.flesch_reading_ease(target)
 
 
 @metric(use_reference=False, help="The Flesch Grade Level Readability score")
 def flesch_grade(target: str, **kwargs) -> float:
-    """Calculate the Flesch Score using py-readability-metrics.
+    """Calculate the Flesch Score using textstat.
 
     Arguments:
         target: The target text.
@@ -89,12 +75,13 @@ def flesch_grade(target: str, **kwargs) -> float:
     """
     if not target.strip():  # Check if the target text is blank
         return None
-    return get_readability(target).flesch_kincaid().score
+    target = _repeat_text(target)
+    return textstat.flesch_kincaid_grade(target)
 
 
 @metric(use_reference=False, help="The Gunning-Fog Readability score")
 def gunning_fog(target: str, **kwargs) -> float:
-    """Calculate the Gunning-Fog Score using py-readability-metrics.
+    """Calculate the Gunning-Fog Score using textstat.
 
     Arguments:
         target: The target text.
@@ -104,20 +91,53 @@ def gunning_fog(target: str, **kwargs) -> float:
     """
     if not target.strip():  # Check if the target text is blank
         return None
-    return get_readability(target).gunning_fog().score
+    target = _repeat_text(target)
+    return textstat.gunning_fog(target)
 
 
-@metric(use_reference=False, help="The Gunning-Fog Grade Level Readability score")
-def gunning_fog_grade(target: str, **kwargs) -> float:
-    """Calculate the Gunning-Fog Grade Level Score using py-readability-metrics.
+@metric(use_reference=False, help="The Dale-Chall Readability score")
+def dale_chall(target: str, **kwargs) -> float:
+    """Calculate the Dale-Chall Readability Score using textstat.
 
     Arguments:
         target: The target text.
 
     Returns:
-        The Gunning-Fog Grade Level score.
+        The Dale-Chall score.
     """
     if not target.strip():  # Check if the target text is blank
         return None
-    grade_level = get_readability(target).gunning_fog().grade_level
-    return None if grade_level == "na" else grade_level
+    target = _repeat_text(target)
+    return textstat.dale_chall_readability_score_v2(target)
+
+
+@metric(use_reference=False, help="The Automated Readability Index")
+def automated_readability(target: str, **kwargs) -> float:
+    """Calculate the Automated Readability Index using textstat.
+
+    Arguments:
+        target: The target text.
+
+    Returns:
+        The Automated Readability score.
+    """
+    if not target.strip():  # Check if the target text is blank
+        return None
+    target = _repeat_text(target)
+    return textstat.automated_readability_index(target)
+
+
+@metric(use_reference=False, help="The Coleman-Liau Index")
+def coleman_liau(target: str, **kwargs) -> float:
+    """Calculate the Coleman-Liau Index using textstat.
+
+    Arguments:
+        target: The target text.
+
+    Returns:
+        The Coleman-Liau Index.
+    """
+    if not target.strip():  # Check if the target text is blank
+        return None
+    target = _repeat_text(target)
+    return textstat.coleman_liau_index(target)

janus/metrics/rouge_score.py

@@ -1,7 +1,6 @@
 import click
-import nltk
 import typer
-from rouge import Rouge
+from rouge_score import rouge_scorer
 from typing_extensions import Annotated
 
 from janus.metrics.metric import metric
@@ -18,9 +17,9 @@ def rouge(
             "-g",
             help=(
                 "The granularity of the ROUGE score. `n` refers to "
-                "ROUGE-N, `l` refers to ROUGE-L, and `w` refers to ROUGE-W."
+                "ROUGE-N, `l` refers to ROUGE-L."
             ),
-            click_type=click.Choice(["n", "l", "w"]),
+            click_type=click.Choice(["n", "l"]),
         ),
     ] = "n",
     n_gram: Annotated[
@@ -52,7 +51,7 @@ def rouge(
         target: The target text.
         reference: The reference text.
         granularity: The granularity of the ROUGE score. `n` refers to ROUGE-N, `l`
-            refers to ROUGE-L, and `w` refers to ROUGE-W.
+            refers to ROUGE-L.
         n_gram: The n-gram overlap calculated for ROUGE-N. Can be an integer.
         score_type: Whether to use the F-score, precision, or recall. For example, `f`
             refers to the F-score, `p` refers to precision, and `r` refers to recall.
@@ -60,37 +59,25 @@ def rouge(
     Returns:
         The ROUGE score.
     """
-    nltk.download("punkt", quiet=True)
-
     if granularity.lower() == "n":
-        metric_name = "rouge-n"
-        metric_name_output = f"rouge-{n_gram}"
-        max_n = n_gram
+        metric_name = f"rouge{n_gram}"
     elif granularity.lower() == "l":
-        metric_name = "rouge-l"
-        metric_name_output = "rouge-l"
-        max_n = 4
-    elif granularity.lower() == "w":
-        metric_name = "rouge-w"
-        metric_name_output = "rouge-w"
-        max_n = 4
+        metric_name = "rougeL"
     else:
-        raise ValueError("Invalid granularity. Must be one of `n`, `l`, or `w`.")
-
-    if score_type.lower() not in ["f", "p", "r"]:
-        raise ValueError("Invalid score type. Must be one of `f`, `p`, or `r`.")
+        raise ValueError("Invalid granularity. Must be one of `n` or `l`")
 
-    evaluator = Rouge(
-        metrics=[metric_name],
-        max_n=max_n,
-        limit_length=False,
-        length_limit=1_000,
-        length_limit_type="words",
-        apply_avg=False,
-        apply_best=False,
-        alpha=0.5,  # Default F1_score
-        weight_factor=1.2,
-        stemming=True,
+    evaluator = rouge_scorer.RougeScorer(
+        [metric_name],
+        use_stemmer=True,
     )
-    scores = evaluator.get_scores(target, reference)
-    return scores[metric_name_output][0][score_type.lower()][0]
+    scores = evaluator.score(target, reference)
+    scores_fpr = scores[metric_name]
+    if score_type.lower() == "f":
+        score = scores_fpr.fmeasure
+    elif score_type.lower() == "p":
+        score = scores_fpr.precision
+    elif score_type.lower() == "r":
+        score = scores_fpr.recall
+    else:
+        raise ValueError("Invalid score type. Must be one of `f`, `p`, or `r`.")
+    return score

janus/parsers/_tests/test_code_parser.py

@@ -25,7 +25,7 @@ class TestCodeParser(unittest.TestCase):
     def test_get_format_instructions(self):
         self.assertEqual(
             self.parser.get_format_instructions(),
-            "Output must contain text contained within triple square brackets (```)",
+            "Output must contain text contained within triple backticks (```)",
         )
 
 

janus/parsers/code_parser.py

@@ -19,9 +19,9 @@ class CodeParser(JanusParser):
         if code is None:
             raise JanusParserException(
                 text,
-                "Code not find code between triple square brackets",
+                "Code not find code between triple backticks",
             )
         return str(code.group(1))
 
     def get_format_instructions(self) -> str:
-        return "Output must contain text contained within triple square brackets (```)"
+        return "Output must contain text contained within triple backticks (```)"

janus/parsers/eval_parsers/incose_parser.py

@@ -70,7 +70,6 @@ class IncoseParser(JanusParser, PydanticOutputParser):
 
         obj = json.loads(text)
 
-        # For some reason requirements objects are in a double list?
         reqs = obj["requirements"]
 
         # Generate a unique ID for each requirement (ensure they are unique)
@@ -91,10 +90,11 @@ class IncoseParser(JanusParser, PydanticOutputParser):
 
         # Strip everything outside the JSON object
         begin, end = text.find("["), text.rfind("]")
-        text = text[begin : end + 1]
+        end += 1 if end != -1 else 0
+        text = text[begin:end]
 
         try:
-            out: RequirementList = super().parse(text)
+            out: RequirementList = super(IncoseParser, self).parse(text)
         except json.JSONDecodeError as e:
             log.debug(f"Invalid JSON object. Output:\n{text}")
             raise OutputParserException(f"Got invalid JSON object. Error: {e}")

janus/parsers/reqs_parser.py

@@ -41,7 +41,7 @@ class RequirementsParser(JanusParser):
             )
         return json.dumps(obj)
 
-    def parse_combined_output(self, text: str):
+    def parse_combined_output(self, text: str) -> str:
         """Parse the output text from the LLM when multiple inputs are combined.
 
         Arguments:
@@ -52,10 +52,10 @@ class RequirementsParser(JanusParser):
         """
         json_strings = re.findall(r"\{.*?\}", text)
         output_list = list()
-        for i, json_string in enumerate(json_strings, 1):
+        for _, json_string in enumerate(json_strings, 1):
             json_dict = json.loads(json_string)
             output_list.append(json_dict["requirements"])
-        return output_list
+        return json.dumps(output_list)
 
     def get_format_instructions(self) -> str:
         """Get the format instructions for the parser.

janus/prompts/templates/cyclic/human.txt

@@ -0,0 +1,16 @@
+You are tasked with generating code in the {TARGET_LANGUAGE} language given a list of requirements.
+
+
+1. Read all requirements.
+2. Write code that addresses all requirments, ensuring that all mentioned conditions are met.
+3. Adhere to the coding conventions and best practices of the {TARGET_LANGUAGE} language.
+4. Ensure the code is correct, well-structured, and includes comments for readability.
+5. The code you provide should be succienct, concise, and runable.
+
+Here are the requirements for the code:
+
+```
+{SOURCE_CODE}
+```
+
+Don't forget to include your final code between triple backticks!

janus/prompts/templates/cyclic/system.txt

@@ -0,0 +1 @@
+Your task is to generate code based on the provided requirements. The code should be written in the {TARGET_LANGUAGE} language. Make sure the code adheres to best practices, is efficient, and well-documented.

janus/prompts/templates/eval_prompts/incose/human.txt

@@ -17,7 +17,7 @@ C9 - Conforming: Individual needs and requirements should conform to an approved
 
 For each and every requirement below, you must indicate whether they "pass" or "fail" each of the above criteria. Briefly explain your reasoning before providing each pass/fail.
 
-Your response should be formatted as a list of JSON objects, with each object corresponding to one requirement. Each object should include 10 keys: `requirement_id`, `C1`, `C2`, ..., `C9`. `requirement_id` should have a string value that holds the 8-character UUID associated with the requirement. The other four values should each be a JSON object with two keys: `reasoning` (a clear explanation of why the criterion is passed or failed) and a `score` (the literal string "pass" or "fail").
+Your response should be formatted as a list of JSON objects, with each object corresponding to one requirement. Each object should include 10 keys: `requirement_id`, `C1`, `C2`, ..., `C9`. `requirement_id` should have a string value that holds the 8-character UUID associated with the requirement. The other four values should each be a JSON object with two keys: `reasoning` (a clear explanation of why the criterion is passed or failed) and a `score` (the literal string "pass" or "fail"). You should also include the requirement itself as a string value for the key `requirement`.
 
 Be discerning in your evaluation; only very high-quality requirements should pass all criteria. Be a hard grader. If a requirement fails a criterion, be thorough and detailed in your explanation of why.
 

janus/prompts/templates/extract_variables/human.txt

@@ -0,0 +1,5 @@
+Extract all global variables and functions from the {SOURCE_LANGUAGE} code below.
+Here is the source code:
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/extract_variables/system.txt

@@ -0,0 +1 @@
+You are a senior software engineer named John and tasked with creating intermediate products of {SOURCE_LANGUAGE} code.

{janus_llm-4.3.5.dist-info → janus_llm-4.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: janus-llm
-Version: 4.3.5
+Version: 4.5.4
 Summary: A transcoding library using LLMs.
 License: Apache 2.0
 Author: Michael Doyle
@@ -24,22 +24,21 @@ Requires-Dist: langchain-community (>=0.2.0,<0.3.0)
 Requires-Dist: langchain-core (>=0.2.0,<0.3.0)
 Requires-Dist: langchain-openai (>=0.1.8,<0.2.0)
 Requires-Dist: langchain-unstructured (>=0.1.2,<0.2.0)
-Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.24.3,<2.0.0)
 Requires-Dist: openai (>=1.14.0,<2.0.0)
 Requires-Dist: pi-heif (>=0.20.0,<0.21.0)
-Requires-Dist: py-readability-metrics (>=1.4.5,<2.0.0)
-Requires-Dist: py-rouge (>=1.1,<2.0)
 Requires-Dist: pybind11 (>=2.13.6,<3.0.0)
 Requires-Dist: pytesseract (>=0.3.13,<0.4.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: rich (>=13.7.1,<14.0.0)
+Requires-Dist: rouge-score (>=0.1.2,<0.2.0)
 Requires-Dist: sacrebleu (>=2.4.1,<3.0.0)
 Requires-Dist: scikit-learn (>=1.5.2,<2.0.0)
 Requires-Dist: sentence-transformers (>=2.6.1,<3.0.0) ; extra == "hf-local" or extra == "all"
 Requires-Dist: setuptools (>=75.6.0,<76.0.0)
 Requires-Dist: tesseract (>=0.1.3,<0.2.0)
 Requires-Dist: text-generation (>=0.6.0,<0.7.0)
+Requires-Dist: textstat (>=0.7.5,<0.8.0)
 Requires-Dist: tiktoken (>=0.7.0,<0.8.0)
 Requires-Dist: transformers (>=4.31.0,<5.0.0)
 Requires-Dist: tree-sitter (>=0.21.0,<0.22.0)
@@ -53,7 +52,7 @@ Description-Content-Type: text/markdown
 
 
 <p align="center">
-    <img src="assets/icons/logo_horizontal.png">
+    <img src="https://raw.githubusercontent.com/janus-llm/janus-llm/public/assets/icons/logo_horizontal.png">
 </p>
 <p align="center">
 <a href="https://github.com/janus-llm/janus-llm/actions/workflows/pages.yml" target="_blank">
@@ -78,16 +77,12 @@ Description-Content-Type: text/markdown
 Janus (`janus-llm`) uses LLMs to aid in the modernization of legacy IT systems. The repository can currently do the following:
 
 1. Chunk code of over 100 programming languages to fit within different model context windows and add to a [Chroma](https://trychroma.com) vector database.
-2. Translate from one programming language to another on a file-by-file basis using an LLM with varying results (with the `translate.py` script).
-3. Translate from a binary file to a programming language using Ghidra decompilation.
-4. Do 1-3 with a CLI tool (`janus`).
+2. Translate from one programming language to another on a file-by-file basis using an LLM.
+3. Translate from a binary file to a programming language using [Ghidra](https://github.com/NationalSecurityAgency/ghidra) decompilation.
+4. Generate requirements, UML diagrams, code comments, and summaries from source code.
+5. Evaluate the products that you generate.
+6. Do 1-5 with a CLI tool (`janus`).
 
-## Roadmap
-
-### Priorities
-
-1. Scripts interacting with Chroma Vector DB for RAG translation and understanding.
-2. Evaluation of outputs in CLI using LLM self-evaluation or static analysis.
 
 ## Installation
 
@@ -111,10 +106,14 @@ export PATH=$PATH:$HOME/.local/bin
 poetry install
 ```
 
+### Documentation
+
+See [the documentation](https://janus-llm.github.io/janus-llm) for more information on how to use the package.
+
 ### Contributing
 
 See our [contributing pages](https://janus-llm.github.io/janus-llm/contributing.html)
 
 ### Copyright
-Copyright ©2024 The MITRE Corporation. ALL RIGHTS RESERVED. Approved for Public Release; Distribution Unlimited. Public Release Case Number 23-4084.
+Copyright ©2025 The MITRE Corporation. ALL RIGHTS RESERVED. Approved for Public Release; Distribution Unlimited. Public Release Case Number 23-4084.