aiqtoolkit 1.2.0a20250613__py3-none-any.whl → 1.2.0a20250614__py3-none-any.whl

aiq/agent/tool_calling_agent/register.py

@@ -38,7 +38,7 @@ class ToolCallAgentWorkflowConfig(FunctionBaseConfig, name="tool_calling_agent")
     tool_names: list[FunctionRef] = Field(default_factory=list,
                                           description="The list of tools to provide to the tool calling agent.")
     llm_name: LLMRef = Field(description="The LLM model to use with the tool calling agent.")
-    verbose: bool = Field(default=False, description="Set the verbosity of the react agent's logging.")
+    verbose: bool = Field(default=False, description="Set the verbosity of the tool calling agent's logging.")
     handle_tool_errors: bool = Field(default=True, description="Specify ability to handle tool calling errors.")
     description: str = Field(default="Tool Calling Agent Workflow", description="Description of this functions use.")
     max_iterations: int = Field(default=15, description="Number of tool calls before stoping the tool calling agent.")

aiq/eval/tunable_rag_evaluator/evaluate.py

@@ -13,17 +13,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import logging
+from typing import Callable
 
 from langchain.output_parsers import ResponseSchema
 from langchain.output_parsers import StructuredOutputParser
 from langchain.schema import HumanMessage
 from langchain.schema import SystemMessage
 from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import RunnableLambda
+from tqdm import tqdm
 
-from aiq.eval.evaluator.base_evaluator import BaseEvaluator
+from aiq.eval.evaluator.evaluator_model import EvalInput
 from aiq.eval.evaluator.evaluator_model import EvalInputItem
+from aiq.eval.evaluator.evaluator_model import EvalOutput
 from aiq.eval.evaluator.evaluator_model import EvalOutputItem
+from aiq.eval.utils.tqdm_position_registry import TqdmPositionRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -65,150 +71,222 @@ def evaluation_prompt(judge_llm_prompt: str,
     return EVAL_PROMPT if not default_scoring else DEFAULT_EVAL_PROMPT
 
 
-class TunableRagEvaluator(BaseEvaluator):
+def runnable_with_retries(original_fn: Callable, llm_retry_control_params: dict | None = None):
+    runnable = RunnableLambda(original_fn)
+
+    if llm_retry_control_params is None:
+        llm_retry_control_params = {
+            "stop_after_attempt": 3, "initial_backoff_delay_seconds": 1, "has_exponential_jitter": True
+        }
+
+    if llm_retry_control_params["has_exponential_jitter"] is None:
+        llm_retry_control_params["has_exponential_jitter"] = True
+    if llm_retry_control_params["stop_after_attempt"] is None:
+        llm_retry_control_params["stop_after_attempt"] = 3
+    if llm_retry_control_params["initial_backoff_delay_seconds"] is None:
+        llm_retry_control_params["initial_backoff_delay_seconds"] = 1
+
+    # Add retry logic with exponential backoff and jitter
+    return runnable.with_retry(
+        retry_if_exception_type=(Exception, ),  # Retry on any error
+        wait_exponential_jitter=llm_retry_control_params["has_exponential_jitter"],  # Add jitter to exponential backoff
+        stop_after_attempt=llm_retry_control_params["stop_after_attempt"],
+        exponential_jitter_params={"initial": llm_retry_control_params["initial_backoff_delay_seconds"]
+                                   }  # Optional: set initial backoff (seconds)
+    )
+
+
+class TunableRagEvaluator:
     '''Tunable RAG evaluator class with customizable LLM prompt for scoring.'''
 
     def __init__(self,
                  llm: BaseChatModel,
                  judge_llm_prompt: str,
+                 llm_retry_control_params: dict | None,
                  max_concurrency: int,
                  default_scoring: bool,
                  default_score_weights: dict):
-        super().__init__(max_concurrency=max_concurrency, tqdm_desc="Evaluating RAG")
         self.llm = llm
+        self.max_concurrency = max_concurrency
         self.judge_llm_prompt = judge_llm_prompt
+        self.llm_retry_control_params = llm_retry_control_params
+        self.semaphore = asyncio.Semaphore(self.max_concurrency)
         self.default_scoring = default_scoring
         # Use user-provided weights if available; otherwise, set equal weights for each score
         self.default_score_weights = default_score_weights if default_score_weights else {
             "coverage": 1 / 3, "correctness": 1 / 3, "relevance": 1 / 3
         }
 
-    async def evaluate_item(self, item: EvalInputItem) -> EvalOutputItem:
-        '''Evaluate a single item'''
-        question = item.input_obj
-        answer_description = item.expected_output_obj
-        generated_answer = item.output_obj
-
-        # Call judge LLM to generate score
-        score = 0.0
-
-        default_evaluation_schema = [
-            ResponseSchema(
-                name="coverage_score",
-                description="Score for the coverage of all critical aspects mentioned in the expected answer. Ex. 0.5",
-                type="float"),
-            ResponseSchema(
-                name="correctness_score",
-                description="Score for the accuracy of the generated answer compared to the expected answer. Ex. 0.5",
-                type="float"),
-            ResponseSchema(name="relevance_score",
-                           description="Score for the relevance of the generated answer to the question. Ex. 0.5",
-                           type="float"),
-            ResponseSchema(
-                name="reasoning",
-                description=
-                "1-2 summarized sentences of reasoning for the scores. Ex. 'The generated answer covers all critical aspects mentioned in the expected answer, is correct, and is relevant to the question.'",
-                type="string"),
-        ]
+    async def evaluate(self, eval_input: EvalInput) -> EvalOutput:
+        '''Evaluate function'''
 
-        custom_evaluation_schema = [
-            ResponseSchema(name="score", description="Score for the generated answer. Ex. 0.5", type="float"),
-            ResponseSchema(
-                name="reasoning",
-                description=
-                "1-2 sentence reasoning for the score. Ex. 'The generated answer is exactly the same as the description of the expected answer.'",
-                type="string"),
-        ]
+        async def process_item(item):
+            """Compute RAG evaluation for an individual item"""
+            question = item.input_obj
+            answer_description = item.expected_output_obj
+            generated_answer = item.output_obj
+
+            # Call judge LLM to generate score
+            score = 0.0
+
+            default_evaluation_schema = [
+                ResponseSchema(
+                    name="coverage_score",
+                    description=
+                    "Score for the coverage of all critical aspects mentioned in the expected answer. Ex. 0.5",
+                    type="float"),
+                ResponseSchema(
+                    name="correctness_score",
+                    description=
+                    "Score for the accuracy of the generated answer compared to the expected answer. Ex. 0.5",
+                    type="float"),
+                ResponseSchema(name="relevance_score",
+                               description="Score for the relevance of the generated answer to the question. Ex. 0.5",
+                               type="float"),
+                ResponseSchema(
+                    name="reasoning",
+                    description=
+                    "1-2 summarized sentences of reasoning for the scores. Ex. 'The generated answer covers all critical aspects mentioned in the expected answer, is correct, and is relevant to the question.'",
+                    type="string"),
+            ]
+
+            custom_evaluation_schema = [
+                ResponseSchema(name="score", description="Score for the generated answer. Ex. 0.5", type="float"),
+                ResponseSchema(
+                    name="reasoning",
+                    description=
+                    "1-2 sentence reasoning for the score. Ex. 'The generated answer is exactly the same as the description of the expected answer.'",
+                    type="string"),
+            ]
 
-        if self.default_scoring:
-            evaluation_schema = default_evaluation_schema
-        else:
-            evaluation_schema = custom_evaluation_schema
+            if self.default_scoring:
+                evaluation_schema = default_evaluation_schema
+            else:
+                evaluation_schema = custom_evaluation_schema
+
+            llm_input_response_parser = StructuredOutputParser.from_response_schemas(evaluation_schema)
+            format_instructions = llm_input_response_parser.get_format_instructions()
 
-        llm_input_response_parser = StructuredOutputParser.from_response_schemas(evaluation_schema)
-        format_instructions = llm_input_response_parser.get_format_instructions()
+            eval_prompt = evaluation_prompt(judge_llm_prompt=self.judge_llm_prompt,
+                                            question=question,
+                                            answer_description=answer_description,
+                                            generated_answer=generated_answer,
+                                            format_instructions=format_instructions,
+                                            default_scoring=self.default_scoring)
 
-        eval_prompt = evaluation_prompt(judge_llm_prompt=self.judge_llm_prompt,
-                                        question=question,
-                                        answer_description=answer_description,
-                                        generated_answer=generated_answer,
-                                        format_instructions=format_instructions,
-                                        default_scoring=self.default_scoring)
+            messages = [
+                SystemMessage(content="You must respond only in JSON format."), HumanMessage(content=eval_prompt)
+            ]
 
-        messages = [SystemMessage(content="You must respond only in JSON format."), HumanMessage(content=eval_prompt)]
+            response = await runnable_with_retries(self.llm.ainvoke, self.llm_retry_control_params).ainvoke(messages)
 
-        response = await self.llm.ainvoke(messages)
+            # Initialize default values to handle service errors
+            coverage_score = 0.0
+            correctness_score = 0.0
+            relevance_score = 0.0
+            reasoning = "Error in evaluator from parsing judge LLM response."
 
-        # Initialize default values to handle service errors
-        coverage_score = 0.0
-        correctness_score = 0.0
-        relevance_score = 0.0
-        reasoning = "Error in evaluator from parsing judge LLM response."
+            try:
+                parsed_response = llm_input_response_parser.parse(response.content)
+                if self.default_scoring:
+                    try:
+                        coverage_score = parsed_response["coverage_score"]
+                        correctness_score = parsed_response["correctness_score"]
+                        relevance_score = parsed_response["relevance_score"]
+                        reasoning = parsed_response["reasoning"]
+                    except KeyError as e:
+                        logger.error("Missing required keys in default scoring response: %s",
+                                     ", ".join(str(arg) for arg in e.args))
+                        reasoning = f"Error in evaluator from parsing judge LLM response. Missing required key(s): {', '.join(str(arg) for arg in e.args)}"
+
+                    coverage_weight = self.default_score_weights.get("coverage", 1 / 3)
+                    correctness_weight = self.default_score_weights.get("correctness", 1 / 3)
+                    relevance_weight = self.default_score_weights.get("relevance", 1 / 3)
+
+                    # Calculate score
+                    total_weight = coverage_weight + correctness_weight + relevance_weight
+                    coverage_weight = coverage_weight / total_weight
+                    correctness_weight = correctness_weight / total_weight
+                    relevance_weight = relevance_weight / total_weight
+
+                    if round(coverage_weight + correctness_weight + relevance_weight, 2) != 1:
+                        logger.warning("The sum of the default score weights is not 1. The weights will be normalized.")
+                        coverage_weight = coverage_weight / (coverage_weight + correctness_weight + relevance_weight)
+                        correctness_weight = correctness_weight / (coverage_weight + correctness_weight +
+                                                                   relevance_weight)
+                        relevance_weight = relevance_weight / (coverage_weight + correctness_weight + relevance_weight)
+
+                    score = (coverage_weight * coverage_score + correctness_weight * correctness_score +
+                             relevance_weight * relevance_score)
+
+                else:
+                    try:
+                        score = parsed_response["score"]
+                        reasoning = parsed_response["reasoning"]
+                    except KeyError as e:
+                        logger.error("Missing required keys in custom scoring response: %s",
+                                     ", ".join(str(arg) for arg in e.args))
+                        reasoning = f"Error in evaluator from parsing judge LLM response. Missing required key(s): {', '.join(str(arg) for arg in e.args)}"
+                        raise
+            except (KeyError, ValueError) as e:
+                logger.error("Error parsing judge LLM response: %s", e)
+                score = 0.0
+                reasoning = "Error in evaluator from parsing judge LLM response."
 
-        try:
-            parsed_response = llm_input_response_parser.parse(response.content)
             if self.default_scoring:
-                try:
-                    coverage_score = parsed_response["coverage_score"]
-                    correctness_score = parsed_response["correctness_score"]
-                    relevance_score = parsed_response["relevance_score"]
-                    reasoning = parsed_response["reasoning"]
-                except KeyError as e:
-                    logger.error("Missing required keys in default scoring response: %s",
-                                 ", ".join(str(arg) for arg in e.args))
-                    reasoning = f"Error in evaluator from parsing judge LLM response. Missing required key(s): {', '.join(str(arg) for arg in e.args)}"
-
-                coverage_weight = self.default_score_weights.get("coverage", 1 / 3)
-                correctness_weight = self.default_score_weights.get("correctness", 1 / 3)
-                relevance_weight = self.default_score_weights.get("relevance", 1 / 3)
-
-                # Calculate score
-                total_weight = coverage_weight + correctness_weight + relevance_weight
-                coverage_weight = coverage_weight / total_weight
-                correctness_weight = correctness_weight / total_weight
-                relevance_weight = relevance_weight / total_weight
-
-                if round(coverage_weight + correctness_weight + relevance_weight, 2) != 1:
-                    logger.warning("The sum of the default score weights is not 1. The weights will be normalized.")
-                    coverage_weight = coverage_weight / (coverage_weight + correctness_weight + relevance_weight)
-                    correctness_weight = correctness_weight / (coverage_weight + correctness_weight + relevance_weight)
-                    relevance_weight = relevance_weight / (coverage_weight + correctness_weight + relevance_weight)
-
-                score = (coverage_weight * coverage_score + correctness_weight * correctness_score +
-                         relevance_weight * relevance_score)
-
+                reasoning = {
+                    "question": question,
+                    "answer_description": answer_description,
+                    "generated_answer": generated_answer,
+                    "score_breakdown": {
+                        "coverage_score": coverage_score,
+                        "correctness_score": correctness_score,
+                        "relevance_score": relevance_score,
+                    },
+                    "reasoning": reasoning,
+                }
             else:
-                try:
-                    score = parsed_response["score"]
-                    reasoning = parsed_response["reasoning"]
-                except KeyError as e:
-                    logger.error("Missing required keys in custom scoring response: %s",
-                                 ", ".join(str(arg) for arg in e.args))
-                    reasoning = f"Error in evaluator from parsing judge LLM response. Missing required key(s): {', '.join(str(arg) for arg in e.args)}"
-                    raise
-        except (KeyError, ValueError) as e:
-            logger.error("Error parsing judge LLM response: %s", e)
-            score = 0.0
-            reasoning = "Error in evaluator from parsing judge LLM response."
+                reasoning = {
+                    "question": question,
+                    "answer_description": answer_description,
+                    "generated_answer": generated_answer,
+                    "reasoning": reasoning
+                }
+
+            return score, reasoning
+
+        async def wrapped_process(item: EvalInputItem) -> tuple[float, dict]:
+            """
+            Process an item asynchronously and update the progress bar.
+            Use the semaphore to limit the number of concurrent items.
+            """
+            async with self.semaphore:
+                result = await process_item(item)
+                # Update the progress bar
+                pbar.update(1)
+                return result
+
+        try:
+            # Claim a tqdm position to display the progress bar
+            tqdm_position = TqdmPositionRegistry.claim()
+            # Create a progress bar
+            pbar = tqdm(total=len(eval_input.eval_input_items), desc="Evaluating RAG", position=tqdm_position)
+            # Process items concurrently with a limit on concurrency
+            results = await asyncio.gather(*[wrapped_process(item) for item in eval_input.eval_input_items])
+        finally:
+            pbar.close()
+            TqdmPositionRegistry.release(tqdm_position)
+
+        # Extract scores and reasonings
+        sample_scores, sample_reasonings = zip(*results) if results else ([], [])
+
+        # Compute average score
+        avg_score = round(sum(sample_scores) / len(sample_scores), 2) if sample_scores else 0.0
+
+        # Construct EvalOutputItems
+        eval_output_items = [
+            EvalOutputItem(id=item.id, score=score, reasoning=reasoning)
+            for item, score, reasoning in zip(eval_input.eval_input_items, sample_scores, sample_reasonings)
+        ]
 
-        if self.default_scoring:
-            reasoning = {
-                "question": question,
-                "answer_description": answer_description,
-                "generated_answer": generated_answer,
-                "score_breakdown": {
-                    "coverage_score": coverage_score,
-                    "correctness_score": correctness_score,
-                    "relevance_score": relevance_score,
-                },
-                "reasoning": reasoning,
-            }
-        else:
-            reasoning = {
-                "question": question,
-                "answer_description": answer_description,
-                "generated_answer": generated_answer,
-                "reasoning": reasoning
-            }
-
-        return EvalOutputItem(id=item.id, score=score, reasoning=reasoning)
+        return EvalOutput(average_score=avg_score, eval_output_items=eval_output_items)

aiq/eval/tunable_rag_evaluator/register.py

@@ -26,6 +26,7 @@ from aiq.data_models.evaluator import EvaluatorBaseConfig
 class TunableRagEvaluatorConfig(EvaluatorBaseConfig, name="tunable_rag_evaluator"):
     '''Configuration for tunable RAG evaluator'''
     llm_name: LLMRef = Field(description="Name of the judge LLM")
+    llm_retry_control_params: dict | None = Field(description="Parameters to control LLM retry behavior", default=None)
     judge_llm_prompt: str = Field(description="LLM prompt for the judge LLM")
     default_scoring: bool = Field(description="Whether to use default scoring", default=False)
     default_score_weights: dict = Field(
@@ -43,6 +44,7 @@ async def register_tunable_rag_evaluator(config: TunableRagEvaluatorConfig, buil
     llm = await builder.get_llm(config.llm_name, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
     evaluator = TunableRagEvaluator(llm,
                                     config.judge_llm_prompt,
+                                    config.llm_retry_control_params,
                                     builder.get_max_concurrency(),
                                     config.default_scoring,
                                     config.default_score_weights)

{aiqtoolkit-1.2.0a20250613.dist-info → aiqtoolkit-1.2.0a20250614.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqtoolkit
-Version: 1.2.0a20250613
+Version: 1.2.0a20250614
 Summary: NVIDIA Agent Intelligence toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation

{aiqtoolkit-1.2.0a20250613.dist-info → aiqtoolkit-1.2.0a20250614.dist-info}/RECORD

@@ -15,7 +15,7 @@ aiq/agent/rewoo_agent/prompt.py,sha256=2XsuI-db_qmH02ypx_IDvi6jTak15cqt_4pZkUv9T
 aiq/agent/rewoo_agent/register.py,sha256=MRd2s3nOMYlLzr5Rq5wkl6_HJGhT3im09ylzllyOXT8,8120
 aiq/agent/tool_calling_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiq/agent/tool_calling_agent/agent.py,sha256=U6PD3_fxfdXe6O4WSGC2Hch-Hz_tqvlbiAkpKj7dgkQ,6034
-aiq/agent/tool_calling_agent/register.py,sha256=qWY1KmDhpG9AIwM3fO5nsF8zE7lWln5qeLa72sFgUpU,5401
+aiq/agent/tool_calling_agent/register.py,sha256=kqcN2uovVBQxrIx5MszBS65opbhBrCRlAw00TlG2i30,5408
 aiq/builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiq/builder/builder.py,sha256=JE3uCw6qTmWX2akUfS-Ga5WSiJVTzBjDQPniiONMjy4,7448
 aiq/builder/component_utils.py,sha256=2jIXWSLIlKxDKAO7kdXz_4BHqQNWw4t9GmcQfw0ER4g,12923
@@ -129,8 +129,8 @@ aiq/eval/trajectory_evaluator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 aiq/eval/trajectory_evaluator/evaluate.py,sha256=Y51KMhJ9t8AoYWrQlrwipc2CtgIXA9IUGZTbKegtsnw,3257
 aiq/eval/trajectory_evaluator/register.py,sha256=kktT4fu5_1Cou-iohD3YhQevsWiR3TA5NpFSweVz0eQ,1709
 aiq/eval/tunable_rag_evaluator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiq/eval/tunable_rag_evaluator/evaluate.py,sha256=lZxQDhvcAu0JR1RApkbs-G3T9pUOSfh822TYGp7vrQw,11440
-aiq/eval/tunable_rag_evaluator/register.py,sha256=uV36xONVxQW8qBO_bsvbvZk4-J4IhowxiRKErnYsbzA,2369
+aiq/eval/tunable_rag_evaluator/evaluate.py,sha256=xo7gtBI-cOrmk8s6FNLDoMhn2F0ODOxdAtg37i4Vu24,15387
+aiq/eval/tunable_rag_evaluator/register.py,sha256=q4p2rFyMzWmaINJc961ZV4jzIlAN4GfWsoImHo0ovsY,2558
 aiq/eval/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiq/eval/utils/output_uploader.py,sha256=SaQbZPkw-Q0H7t5yG60Kh-p1cflR7gPklVkilC4uPbU,5141
 aiq/eval/utils/tqdm_position_registry.py,sha256=9CtpCk1wtYCSyieHPaSp8nlZu6EcNUOaUz2RTqfekrA,1286
@@ -309,10 +309,10 @@ aiq/utils/reactive/base/observer_base.py,sha256=UAlyAY_ky4q2t0P81RVFo2Bs_R7z5Nde
 aiq/utils/reactive/base/subject_base.py,sha256=Ed-AC6P7cT3qkW1EXjzbd5M9WpVoeN_9KCe3OM3FLU4,2521
 aiq/utils/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiq/utils/settings/global_settings.py,sha256=U9TCLdoZsKq5qOVGjREipGVv9e-FlStzqy5zv82_VYk,7454
-aiqtoolkit-1.2.0a20250613.dist-info/licenses/LICENSE-3rd-party.txt,sha256=8o7aySJa9CBvFshPcsRdJbczzdNyDGJ8b0J67WRUQ2k,183936
-aiqtoolkit-1.2.0a20250613.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-aiqtoolkit-1.2.0a20250613.dist-info/METADATA,sha256=0LV-fg4UXDznF9C1ojoVD1qrvT1Spoc0w7duaBn_QVI,20274
-aiqtoolkit-1.2.0a20250613.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiqtoolkit-1.2.0a20250613.dist-info/entry_points.txt,sha256=gRlPfR5g21t328WNEQ4CcEz80S1sJNS8A7rMDYnzl4A,452
-aiqtoolkit-1.2.0a20250613.dist-info/top_level.txt,sha256=fo7AzYcNhZ_tRWrhGumtxwnxMew4xrT1iwouDy_f0Kc,4
-aiqtoolkit-1.2.0a20250613.dist-info/RECORD,,
+aiqtoolkit-1.2.0a20250614.dist-info/licenses/LICENSE-3rd-party.txt,sha256=8o7aySJa9CBvFshPcsRdJbczzdNyDGJ8b0J67WRUQ2k,183936
+aiqtoolkit-1.2.0a20250614.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+aiqtoolkit-1.2.0a20250614.dist-info/METADATA,sha256=4jdt6HGMhOX43rgDHWjrVKutpccXZODrtZPAtJuAzfU,20274
+aiqtoolkit-1.2.0a20250614.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiqtoolkit-1.2.0a20250614.dist-info/entry_points.txt,sha256=gRlPfR5g21t328WNEQ4CcEz80S1sJNS8A7rMDYnzl4A,452
+aiqtoolkit-1.2.0a20250614.dist-info/top_level.txt,sha256=fo7AzYcNhZ_tRWrhGumtxwnxMew4xrT1iwouDy_f0Kc,4
+aiqtoolkit-1.2.0a20250614.dist-info/RECORD,,