aiqtoolkit 1.2.0a20250731__py3-none-any.whl → 1.2.0a20250801__py3-none-any.whl

aiq/builder/function.py

@@ -76,11 +76,16 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
         -------
         _T
             The converted value.
+
+        Raises
+        ------
+        ValueError
+            If the value cannot be converted to the specified type (when `to_type` is specified).
         """
 
         return self._converter.convert(value, to_type=to_type)
 
-    def try_convert(self, value: typing.Any, to_type: type[_T]) -> _T:
+    def try_convert(self, value: typing.Any, to_type: type[_T]) -> _T | typing.Any:
         """
         Converts the given value to the specified type using graceful error handling.
         If conversion fails, returns the original value and continues processing.
@@ -94,7 +99,7 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
 
         Returns
         -------
-        _T
+        _T | typing.Any
             The converted value, or original value if conversion fails.
         """
         return self._converter.try_convert(value, to_type=to_type)
@@ -129,17 +134,22 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
         -------
         typing.Any
             The output of the function optionally converted to the specified type.
+
+        Raises
+        ------
+        ValueError
+            If the output of the function cannot be converted to the specified type.
         """
 
         with self._context.push_active_function(self.instance_name,
                                                 input_data=value) as manager:  # Set the current invocation context
             try:
-                converted_input: InputT = self._convert_input(value)  # type: ignore
+                converted_input: InputT = self._convert_input(value)
 
                 result = await self._ainvoke(converted_input)
 
                 if to_type is not None and not isinstance(result, to_type):
-                    result = self._converter.try_convert(result, to_type=to_type)
+                    result = self.convert(result, to_type)
 
                 manager.set_output(result)
 
@@ -215,18 +225,23 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
         ------
         typing.Any
             The output of the function optionally converted to the specified type.
+
+        Raises
+        ------
+        ValueError
+            If the output of the function cannot be converted to the specified type (when `to_type` is specified).
         """
 
         with self._context.push_active_function(self.instance_name, input_data=value) as manager:
             try:
-                converted_input: InputT = self._convert_input(value)  # type: ignore
+                converted_input: InputT = self._convert_input(value)
 
                 # Collect streaming outputs to capture the final result
                 final_output: list[typing.Any] = []
 
                 async for data in self._astream(converted_input):
                     if to_type is not None and not isinstance(data, to_type):
-                        converted_data = self._converter.try_convert(data, to_type=to_type)
+                        converted_data = self.convert(data, to_type=to_type)
                         final_output.append(converted_data)
                         yield converted_data
                     else:

aiq/builder/function_base.py

@@ -350,7 +350,7 @@ class FunctionBase(typing.Generic[InputT, StreamingOutputT, SingleOutputT], ABC)
         # output because the ABC has it.
         return True
 
-    def _convert_input(self, value: typing.Any):
+    def _convert_input(self, value: typing.Any) -> InputT:
         if (isinstance(value, self.input_class)):
             return value
 
@@ -373,4 +373,8 @@ class FunctionBase(typing.Generic[InputT, StreamingOutputT, SingleOutputT], ABC)
             return value
 
         # Fallback to the converter
-        return self._converter.try_convert(value, to_type=self.input_class)
+        try:
+            return self._converter.convert(value, to_type=self.input_class)
+        except ValueError as e:
+            # Input parsing should yield a TypeError instead of a ValueError
+            raise TypeError from e

aiq/cli/commands/sizing/calc.py

@@ -274,9 +274,12 @@ def calc_command(ctx,
 
         click.echo(tabulate(table, headers=headers, tablefmt="github"))
 
-        # Display slope-based GPU estimates at the end
-        click.echo("")  # Add blank line for separation
-        click.echo(click.style("=== GPU ESTIMATES ===", fg="bright_blue", bold=True))
+        # Display slope-based GPU estimates if they are available
+        if results.gpu_estimates.gpu_estimate_by_llm_latency is not None or \
+                results.gpu_estimates.gpu_estimate_by_wf_runtime is not None:
+            click.echo("")
+            click.echo(click.style("=== GPU ESTIMATES ===", fg="bright_blue", bold=True))
+
         if results.gpu_estimates.gpu_estimate_by_wf_runtime is not None:
             click.echo(
                 click.style(

aiq/cli/commands/uninstall.py

@@ -53,13 +53,11 @@ async def uninstall_packages(packages: list[dict[str, str]]) -> None:
         await stack.enter_async_context(registry_handler.remove(packages=package_name_list))
 
 
-@click.group(name=__name__,
-             invoke_without_command=True,
-             help=("Uninstall an AIQ Toolkit plugin packages from the local environment."))
+@click.group(name=__name__, invoke_without_command=True, help=("Uninstall plugin packages from the local environment."))
 @click.argument("packages", type=str)
 def uninstall_command(packages: str) -> None:
     """
-    Uninstall AIQ Toolkit plugin packages from the local environment.
+    Uninstall plugin packages from the local environment.
     """
 
     packages = packages.split()

aiq/observability/exporter/processing_exporter.py

@@ -17,6 +17,7 @@ import asyncio
 import logging
 from abc import abstractmethod
 from collections.abc import Coroutine
+from typing import Any
 from typing import Generic
 from typing import TypeVar
 
@@ -24,6 +25,7 @@ from aiq.builder.context import AIQContextState
 from aiq.data_models.intermediate_step import IntermediateStep
 from aiq.observability.exporter.base_exporter import BaseExporter
 from aiq.observability.mixin.type_introspection_mixin import TypeIntrospectionMixin
+from aiq.observability.processor.callback_processor import CallbackProcessor
 from aiq.observability.processor.processor import Processor
 from aiq.utils.type_utils import DecomposedType
 from aiq.utils.type_utils import override
@@ -89,6 +91,14 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
                     self._processors[-1].output_type)
         self._processors.append(processor)
 
+        # Set up pipeline continuation callback for processors that support it
+        if isinstance(processor, CallbackProcessor):
+            # Create a callback that continues processing through the rest of the pipeline
+            async def pipeline_callback(item):
+                await self._continue_pipeline_after(processor, item)
+
+            processor.set_done_callback(pipeline_callback)
+
     def remove_processor(self, processor: Processor) -> None:
         """Remove a processor from the processing pipeline.
 
@@ -143,20 +153,82 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
         """Process item through all registered processors.
 
         Args:
-            item: The item to process (starts as PipelineInputT, can transform to PipelineOutputT)
+            item (PipelineInputT): The item to process (starts as PipelineInputT, can transform to PipelineOutputT)
+
+        Returns:
+            PipelineOutputT: The processed item after running through all processors
+        """
+        return await self._process_through_processors(self._processors, item)  # type: ignore
+
+    async def _process_through_processors(self, processors: list[Processor], item: Any) -> Any:
+        """Process an item through a list of processors.
+
+        Args:
+            processors (list[Processor]): List of processors to run the item through
+            item (Any): The item to process
 
         Returns:
             The processed item after running through all processors
         """
         processed_item = item
-        for processor in self._processors:
+        for processor in processors:
             try:
                 processed_item = await processor.process(processed_item)
             except Exception as e:
                 logger.error("Error in processor %s: %s", processor.__class__.__name__, e, exc_info=True)
-                # Continue with unprocessed item rather than failing the export
+                # Continue with unprocessed item rather than failing
+        return processed_item
+
+    async def _export_final_item(self, processed_item: Any, raise_on_invalid: bool = False) -> None:
+        """Export a processed item with proper type handling.
+
+        Args:
+            processed_item (Any): The item to export
+            raise_on_invalid (bool): If True, raise ValueError for invalid types instead of logging warning
+        """
+        if isinstance(processed_item, list):
+            if len(processed_item) > 0:
+                await self.export_processed(processed_item)
+            else:
+                logger.debug("Skipping export of empty batch")
+        elif isinstance(processed_item, self.output_class):
+            await self.export_processed(processed_item)
+        else:
+            if raise_on_invalid:
+                raise ValueError(f"Processed item {processed_item} is not a valid output type. "
+                                 f"Expected {self.output_class} or list[{self.output_class}]")
+            logger.warning("Processed item %s is not a valid output type for export", processed_item)
+
+    async def _continue_pipeline_after(self, source_processor: Processor, item: Any) -> None:
+        """Continue processing an item through the pipeline after a specific processor.
 
-        return processed_item  # type: ignore
+        This is used when processors (like BatchingProcessor) need to inject items
+        back into the pipeline flow to continue through downstream processors.
+
+        Args:
+            source_processor (Processor): The processor that generated the item
+            item (Any): The item to continue processing through the remaining pipeline
+        """
+        try:
+            # Find the source processor's position
+            try:
+                source_index = self._processors.index(source_processor)
+            except ValueError:
+                logger.error("Source processor %s not found in pipeline", source_processor.__class__.__name__)
+                return
+
+            # Process through remaining processors (skip the source processor)
+            remaining_processors = self._processors[source_index + 1:]
+            processed_item = await self._process_through_processors(remaining_processors, item)
+
+            # Export the final result
+            await self._export_final_item(processed_item)
+
+        except Exception as e:
+            logger.error("Failed to continue pipeline processing after %s: %s",
+                         source_processor.__class__.__name__,
+                         e,
+                         exc_info=True)
 
     async def _export_with_processing(self, item: PipelineInputT) -> None:
         """Export an item after processing it through the pipeline.
@@ -169,20 +241,11 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
             final_item: PipelineOutputT = await self._process_pipeline(item)
 
             # Handle different output types from batch processors
-            if isinstance(final_item, list):
-                # Empty lists from batch processors should be skipped, not exported
-                if len(final_item) == 0:
-                    logger.debug("Skipping export of empty batch from processor pipeline")
-                    return
-
-                # Non-empty lists should be exported (batch processors)
-                await self.export_processed(final_item)
-            elif isinstance(final_item, self.output_class):
-                # Single items should be exported normally
-                await self.export_processed(final_item)
-            else:
-                raise ValueError(f"Processed item {final_item} is not a valid output type. "
-                                 f"Expected {self.output_class} or list[{self.output_class}]")
+            if isinstance(final_item, list) and len(final_item) == 0:
+                logger.debug("Skipping export of empty batch from processor pipeline")
+                return
+
+            await self._export_final_item(final_item, raise_on_invalid=True)
 
         except Exception as e:
             logger.error("Failed to export item '%s': %s", item, e, exc_info=True)
@@ -235,35 +298,25 @@ class ProcessingExporter(Generic[PipelineInputT, PipelineOutputT], BaseExporter,
 
     @override
     async def _cleanup(self):
-        """Enhanced cleanup that shuts down all shutdown-aware processors."""
+        """Enhanced cleanup that shuts down all shutdown-aware processors.
+
+        Each processor is responsible for its own cleanup, including routing
+        any final batches through the remaining pipeline via their done callbacks.
+        """
         # Shutdown all processors that support it
-        if hasattr(self, '_processors'):
-            shutdown_tasks = []
-            for processor in getattr(self, '_processors', []):
-                if hasattr(processor, 'shutdown'):
-                    logger.debug("Shutting down processor: %s", processor.__class__.__name__)
-                    shutdown_tasks.append(processor.shutdown())
-
-            if shutdown_tasks:
-                try:
-                    await asyncio.gather(*shutdown_tasks, return_exceptions=True)
-                    logger.info("Successfully shut down %d processors", len(shutdown_tasks))
-                except Exception as e:
-                    logger.error("Error shutting down processors: %s", e, exc_info=True)
-
-            # Process final batches from batch processors
-            for processor in getattr(self, '_processors', []):
-                if hasattr(processor, 'has_final_batch') and hasattr(processor, 'get_final_batch'):
-                    if processor.has_final_batch():
-                        final_batch = processor.get_final_batch()
-                        if final_batch:
-                            logger.info("Processing final batch of %d items from %s during cleanup",
-                                        len(final_batch),
-                                        processor.__class__.__name__)
-                            try:
-                                await self.export_processed(final_batch)
-                            except Exception as e:
-                                logger.error("Error processing final batch during cleanup: %s", e, exc_info=True)
+        shutdown_tasks = []
+        for processor in getattr(self, '_processors', []):
+            shutdown_method = getattr(processor, 'shutdown', None)
+            if shutdown_method:
+                logger.debug("Shutting down processor: %s", processor.__class__.__name__)
+                shutdown_tasks.append(shutdown_method())
+
+        if shutdown_tasks:
+            try:
+                await asyncio.gather(*shutdown_tasks, return_exceptions=True)
+                logger.info("Successfully shut down %d processors", len(shutdown_tasks))
+            except Exception as e:
+                logger.error("Error shutting down processors: %s", e, exc_info=True)
 
         # Call parent cleanup
         await super()._cleanup()

aiq/observability/exporter/span_exporter.py

@@ -262,3 +262,4 @@ class SpanExporter(ProcessingExporter[InputSpanT, OutputSpanT], SerializeMixin):
         self._outstanding_spans.clear()  # type: ignore
         self._span_stack.clear()  # type: ignore
         self._metadata_stack.clear()  # type: ignore
+        await super()._cleanup()

aiq/observability/processor/batching_processor.py

@@ -23,17 +23,17 @@ from typing import Any
 from typing import Generic
 from typing import TypeVar
 
-from aiq.observability.processor.processor import Processor
+from aiq.observability.processor.callback_processor import CallbackProcessor
 
 logger = logging.getLogger(__name__)
 
 T = TypeVar('T')
 
 
-class BatchingProcessor(Processor[T, list[T]], Generic[T]):
+class BatchingProcessor(CallbackProcessor[T, list[T]], Generic[T]):
     """Pass-through batching processor that accumulates items and outputs batched lists.
 
-    This processor fits properly into the generics design by implementing Processor[T, List[T]].
+    This processor extends CallbackProcessor[T, List[T]] to provide batching functionality.
     It accumulates individual items and outputs them as batches when size or time thresholds
     are met. The batched output continues through the processing pipeline.
 
@@ -43,25 +43,31 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
     Key Features:
     - Pass-through design: Processor[T, List[T]]
     - Size-based and time-based batching
-    - Fits into generics processing pipeline design
+    - Pipeline flow: batches continue through downstream processors
     - GUARANTEED: No items lost during cleanup
     - Comprehensive statistics and monitoring
     - Proper cleanup and shutdown handling
     - High-performance async implementation
     - Back-pressure handling with queue limits
 
+    Pipeline Flow:
+        Normal processing: Individual items → BatchingProcessor → List[items] → downstream processors → export
+        Time-based flush: Scheduled batches automatically continue through remaining pipeline
+        Shutdown: Final batch immediately routed through remaining pipeline
+
     Cleanup Guarantee:
-        When ProcessingExporter._cleanup() calls shutdown(), this processor:
+        When shutdown() is called, this processor:
         1. Stops accepting new items
-        2. Processes all queued items as final batch
-        3. Returns final batch to continue through pipeline
-        4. Ensures zero data loss during shutdown
+        2. Creates final batch from all queued items
+        3. Immediately routes final batch through remaining pipeline via callback
+        4. Ensures zero data loss with no external coordination needed
 
     Usage in Pipeline:
         ```python
-        # Individual spans → Batched spans → Continue processing
-        exporter.add_processor(BatchingProcessor[Span](batch_size=100))
-        exporter.add_processor(BatchedSpanProcessor())  # Processes List[Span]
+        # Individual spans → Batched spans → Continue through downstream processors
+        exporter.add_processor(BatchingProcessor[Span](batch_size=100))  # Auto-wired with pipeline callback
+        exporter.add_processor(FilterProcessor())  # Processes List[Span] from batching
+        exporter.add_processor(TransformProcessor())  # Further processing
         ```
 
     Args:
@@ -70,6 +76,10 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
         max_queue_size: Maximum items to queue before blocking (default: 1000)
         drop_on_overflow: If True, drop items when queue is full (default: False)
         shutdown_timeout: Max seconds to wait for final batch processing (default: 10.0)
+
+    Note:
+        The done_callback for pipeline integration is automatically set by ProcessingExporter
+        when the processor is added to a pipeline. For standalone usage, call set_done_callback().
     """
 
     def __init__(self,
@@ -77,14 +87,13 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
                  flush_interval: float = 5.0,
                  max_queue_size: int = 1000,
                  drop_on_overflow: bool = False,
-                 shutdown_timeout: float = 10.0,
-                 done_callback: Callable[[list[T]], Awaitable[None]] | None = None):
+                 shutdown_timeout: float = 10.0):
         self._batch_size = batch_size
         self._flush_interval = flush_interval
         self._max_queue_size = max_queue_size
         self._drop_on_overflow = drop_on_overflow
         self._shutdown_timeout = shutdown_timeout
-        self._done_callback = done_callback
+        self._done_callback: Callable[[list[T]], Awaitable[None]] | None = None
 
         # Batching state
         self._batch_queue: deque[T] = deque()
@@ -93,11 +102,7 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
         self._batch_lock = asyncio.Lock()
         self._shutdown_requested = False
         self._shutdown_complete = False
-        self._shutdown_complete_event: asyncio.Event | None = None
-
-        # Final batch handling for cleanup
-        self._final_batch: list[T] | None = None
-        self._final_batch_processed = False
+        self._shutdown_complete_event = asyncio.Event()
 
         # Callback for immediate export of scheduled batches
         self._done = None
@@ -167,7 +172,11 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
             return []
 
     def set_done_callback(self, callback: Callable[[list[T]], Awaitable[None]]):
-        """Set callback function for immediate export of scheduled batches."""
+        """Set callback function for routing batches through the remaining pipeline.
+
+        This is automatically set by ProcessingExporter.add_processor() to continue
+        batches through downstream processors before final export.
+        """
         self._done_callback = callback
 
     async def _schedule_flush(self):
@@ -178,15 +187,15 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
                 if not self._shutdown_requested and self._batch_queue:
                     batch = await self._create_batch()
                     if batch:
-                        # Immediately export scheduled batches via callback
+                        # Route scheduled batches through pipeline via callback
                         if self._done_callback is not None:
                             try:
                                 await self._done_callback(batch)
-                                logger.debug("Scheduled flush exported batch of %d items", len(batch))
+                                logger.debug("Scheduled flush routed batch of %d items through pipeline", len(batch))
                             except Exception as e:
-                                logger.error("Error exporting scheduled batch: %s", e, exc_info=True)
+                                logger.error("Error routing scheduled batch through pipeline: %s", e, exc_info=True)
                         else:
-                            logger.warning("Scheduled flush created batch of %d items but no export callback set",
+                            logger.warning("Scheduled flush created batch of %d items but no pipeline callback set",
                                            len(batch))
         except asyncio.CancelledError:
             pass
@@ -223,11 +232,8 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
         """Shutdown the processor and ensure all items are processed.
 
         CRITICAL: This method is called by ProcessingExporter._cleanup() to ensure
-        no items are lost during shutdown. It creates a final batch from any
-        remaining items and stores it for processing.
-
-        The final batch will be processed by the next process() call or can be
-        retrieved via get_final_batch().
+        no items are lost during shutdown. It immediately routes any remaining
+        items as a final batch through the rest of the processing pipeline.
         """
         if self._shutdown_requested:
             logger.debug("Shutdown already requested, waiting for completion")
@@ -251,13 +257,26 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
                 except asyncio.CancelledError:
                     pass
 
-            # Create final batch from remaining items
+            # Create and route final batch through pipeline
             async with self._batch_lock:
                 if self._batch_queue:
-                    self._final_batch = await self._create_batch()
-                    logger.info("Created final batch of %d items during shutdown", len(self._final_batch))
+                    final_batch = await self._create_batch()
+                    logger.info("Created final batch of %d items during shutdown", len(final_batch))
+
+                    # Route final batch through pipeline via callback
+                    if self._done_callback is not None:
+                        try:
+                            await self._done_callback(final_batch)
+                            logger.info("Successfully routed final batch of %d items through pipeline during shutdown",
+                                        len(final_batch))
+                        except Exception as e:
+                            logger.error("Error routing final batch through pipeline during shutdown: %s",
+                                         e,
+                                         exc_info=True)
+                    else:
+                        logger.warning("Final batch of %d items created during shutdown but no pipeline callback set",
+                                       len(final_batch))
                 else:
-                    self._final_batch = []
                     logger.info("No items remaining during shutdown")
 
             self._shutdown_complete = True
@@ -269,30 +288,6 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
             self._shutdown_complete = True
             self._shutdown_complete_event.set()
 
-    def get_final_batch(self) -> list[T]:
-        """Get the final batch created during shutdown.
-
-        This method allows the exporter to retrieve and process any items
-        that were queued when shutdown was called.
-
-        Returns:
-            List[T]: Final batch of items, empty list if none
-        """
-        if self._final_batch is not None:
-            final_batch = self._final_batch
-            self._final_batch = None  # Clear to avoid double processing
-            self._final_batch_processed = True
-            return final_batch
-        return []
-
-    def has_final_batch(self) -> bool:
-        """Check if there's a final batch waiting to be processed.
-
-        Returns:
-            bool: True if final batch exists and hasn't been processed
-        """
-        return self._final_batch is not None and not self._final_batch_processed
-
     def get_stats(self) -> dict[str, Any]:
         """Get comprehensive batching statistics."""
         return {
@@ -309,8 +304,6 @@ class BatchingProcessor(Processor[T, list[T]], Generic[T]):
             "shutdown_batches": self._shutdown_batches,
             "shutdown_requested": self._shutdown_requested,
             "shutdown_complete": self._shutdown_complete,
-            "final_batch_size": len(self._final_batch) if self._final_batch else 0,
-            "final_batch_processed": self._final_batch_processed,
             "avg_items_per_batch": self._items_processed / max(1, self._batches_created),
             "drop_rate": self._items_dropped / max(1, self._items_processed) * 100 if self._items_processed > 0 else 0
         }

aiq/observability/processor/callback_processor.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import abstractmethod
+from collections.abc import Awaitable
+from collections.abc import Callable
+from typing import Any
+from typing import Generic
+from typing import TypeVar
+
+from aiq.observability.processor.processor import Processor
+
+InputT = TypeVar('InputT')
+OutputT = TypeVar('OutputT')
+
+
+class CallbackProcessor(Processor[InputT, OutputT], Generic[InputT, OutputT]):
+    """Abstract base class for processors that support done callbacks.
+
+    Processors inheriting from this class can register callbacks that are
+    invoked when items are ready for further processing or export.
+    """
+
+    @abstractmethod
+    def set_done_callback(self, callback: Callable[[Any], Awaitable[None]]) -> None:
+        """Set a callback function to be invoked when items are processed.
+
+        Args:
+            callback (Callable[[Any], Awaitable[None]]): Function to call with processed items
+        """
+        pass

aiq/observability/processor/processor.py

@@ -63,6 +63,9 @@ class Processor(Generic[InputT, OutputT], TypeIntrospectionMixin, ABC):
         """Process an item and return a potentially different type.
 
         Args:
-            item: The item to process
+            item (InputT): The item to process
+
+        Returns:
+            OutputT: The processed item
         """
         pass

aiq/profiler/calc/calc_runner.py

@@ -34,6 +34,7 @@ from aiq.profiler.calc.data_models import CalcData
 from aiq.profiler.calc.data_models import CalcRunnerConfig
 from aiq.profiler.calc.data_models import CalcRunnerOutput
 from aiq.profiler.calc.data_models import FitConfig
+from aiq.profiler.calc.data_models import FitResults
 from aiq.profiler.calc.data_models import GPUEstimates
 from aiq.profiler.calc.data_models import SizingMetricPerItem
 from aiq.profiler.calc.data_models import SizingMetrics
@@ -408,7 +409,10 @@ class CalcRunner:
         if gpu_estimates.gpu_estimate_by_llm_latency is not None:
             logger.info("GPU estimate by LLM latency: %.2f", gpu_estimates.gpu_estimate_by_llm_latency)
 
-        return CalcRunnerOutput(gpu_estimates=gpu_estimates, calc_data=calc_data)
+        return CalcRunnerOutput(gpu_estimates=gpu_estimates,
+                                calc_data=calc_data,
+                                fit_results=FitResults(llm_latency_fit=self.linear_analyzer.llm_latency_fit,
+                                                       wf_runtime_fit=self.linear_analyzer.wf_runtime_fit))
 
     def plot_concurrency_vs_time_metrics(self, output_dir: Path):
         """Plots concurrency vs. time metrics using pre-computed fits."""

aiq/profiler/calc/data_models.py

@@ -17,6 +17,7 @@ import typing
 from pathlib import Path
 
 from pydantic import BaseModel
+from pydantic import Field
 
 
 class FitConfig(BaseModel):
@@ -76,7 +77,7 @@ class CalcRunnerConfig(BaseModel):
     plot_data: bool = True
 
     # Configuration for linear fit and outlier detection
-    fit_config: FitConfig = FitConfig()
+    fit_config: FitConfig = Field(default_factory=FitConfig)
 
 
 # Sizing metrics are gathered from the evaluation runs and used as input by the calculator.
@@ -103,7 +104,7 @@ class SizingMetrics(BaseModel):
     Sizing metrics for a single concurrency.
     """
     # alerts associated with the sizing metrics
-    alerts: SizingMetricsAlerts = SizingMetricsAlerts()
+    alerts: SizingMetricsAlerts = Field(default_factory=SizingMetricsAlerts)
 
     # p95 LLM latency
     llm_latency_p95: float = 0.0
@@ -125,6 +126,14 @@ class LinearFitResult(BaseModel):
     outliers_removed: list[int]
 
 
+class FitResults(BaseModel):
+    """
+    Linear fit results for both LLM latency and workflow runtime analysis.
+    """
+    llm_latency_fit: LinearFitResult | None = None
+    wf_runtime_fit: LinearFitResult | None = None
+
+
 # GPU estimates are generated by the calculator.
 class GPUEstimates(BaseModel):
     """
@@ -158,11 +167,11 @@ class CalcData(BaseModel):
     """
     # ROUGH GPU estimates per concurrency: these are not used for the final GPU estimation
     # they are only available for information purposes
-    gpu_estimates: GPUEstimates = GPUEstimates()
+    gpu_estimates: GPUEstimates = Field(default_factory=GPUEstimates)
     # Calc runner alerts
-    alerts: CalcAlerts = CalcAlerts()
+    alerts: CalcAlerts = Field(default_factory=CalcAlerts)
     # Sizing metrics
-    sizing_metrics: SizingMetrics = SizingMetrics()
+    sizing_metrics: SizingMetrics = Field(default_factory=SizingMetrics)
 
 
 class CalcRunnerOutput(BaseModel):
@@ -170,7 +179,10 @@ class CalcRunnerOutput(BaseModel):
     Output of the calc runner.
     """
     # GPU estimates based on the slope of the time vs concurrency, calculated online or offline
-    gpu_estimates: GPUEstimates
+    gpu_estimates: GPUEstimates = Field(default_factory=GPUEstimates)
+
+    # Linear fit results for analysis and debugging
+    fit_results: FitResults = Field(default_factory=FitResults)
 
     # Per-concurrency data (GPU estimates, out-of-range runs, and sizing metrics)
     calc_data: dict[int, CalcData] = {}

aiq/tool/server_tools.py

@@ -63,4 +63,4 @@ async def current_request_attributes(config: RequestAttributesTool, builder: Bui
                 f"Conversation Id: {conversation_id}")
 
     yield FunctionInfo.from_fn(_get_request_attributes,
-                               description="Returns the acquired user defined request attriubutes.")
+                               description="Returns the acquired user defined request attributes.")

aiq/utils/type_converter.py

@@ -35,9 +35,12 @@ class TypeConverter:
 
     def __init__(self, converters: list[Callable[[typing.Any], typing.Any]], parent: "TypeConverter | None" = None):
         """
-        :param converters: A list of single-argument converter callables
-                           annotated with their input param and return type.
-        :param parent:     An optional parent TypeConverter for fallback.
+        Parameters
+        ----------
+        converters : list[Callable[[typing.Any], typing.Any]]
+            A list of single-argument converter callables annotated with their input param and return type.
+        parent : TypeConverter | None
+            An optional parent TypeConverter for fallback.
         """
         # dict[to_type, dict[from_type, converter]]
         self._converters: OrderedDict[type, OrderedDict[type, Callable]] = OrderedDict()
@@ -54,6 +57,16 @@ class TypeConverter:
         """
         Registers a converter. Must have exactly one parameter
         and an annotated return type.
+
+        Parameters
+        ----------
+        converter : Callable
+            A converter function. Must have exactly one parameter and an annotated return type.
+
+        Raises
+        ------
+        ValueError
+            If the converter does not have a return type or exactly one argument or the argument has no data type.
         """
         sig = typing.get_type_hints(converter)
         to_type = sig.pop("return", None)
@@ -70,7 +83,7 @@ class TypeConverter:
         self._converters.setdefault(to_type, OrderedDict())[from_type] = converter
         # to do(MDD): If needed, sort by specificity here.
 
-    def _convert(self, data, to_type: type[_T]) -> _T | None:
+    def _convert(self, data: typing.Any, to_type: type[_T]) -> _T | None:
         """
         Attempts to convert `data` into `to_type`. Returns None if no path is found.
         """
@@ -95,10 +108,27 @@ class TypeConverter:
         # 4) If we still haven't succeeded, return None
         return None
 
-    def convert(self, data, to_type: type[_T]) -> _T:
+    def convert(self, data: typing.Any, to_type: type[_T]) -> _T:
         """
-        Converts or raises ValueError if no path is found.
+        Converts or raises ValueError if no conversion path is found.
         We also give the parent a chance if self fails.
+
+        Parameters
+        ----------
+        data : typing.Any
+            The value to convert.
+        to_type : type
+            The type to convert the value to.
+
+        Returns
+        -------
+        _T
+            The converted value.
+
+        Raises
+        ------
+        ValueError
+            If the value cannot be converted to the specified type.
         """
         result = self._convert(data, to_type)
         if result is None and self._parent:
@@ -109,10 +139,22 @@ class TypeConverter:
             return result
         raise ValueError(f"Cannot convert type {type(data)} to {to_type}. No match found.")
 
-    def try_convert(self, data, to_type: type[_T]) -> _T:
+    def try_convert(self, data: typing.Any, to_type: type[_T]) -> _T | typing.Any:
         """
         Converts with graceful error handling. If conversion fails, returns the original data
         and continues processing.
+
+        Parameters
+        ----------
+        data : typing.Any
+            The value to convert.
+        to_type : type
+            The type to convert the value to.
+
+        Returns
+        -------
+        _T | typing.Any
+            The converted value, or original value if conversion fails.
         """
         try:
             return self.convert(data, to_type)
@@ -124,7 +166,7 @@ class TypeConverter:
     # -------------------------------------------------
     # INTERNAL DIRECT CONVERSION (with parent fallback)
     # -------------------------------------------------
-    def _try_direct_conversion(self, data, target_root_type: type) -> typing.Any | None:
+    def _try_direct_conversion(self, data: typing.Any, target_root_type: type) -> typing.Any | None:
         """
         Tries direct conversion in *this* converter's registry.
         If no match here, we forward to parent's direct conversion
@@ -149,7 +191,7 @@ class TypeConverter:
     # -------------------------------------------------
     # INTERNAL INDIRECT CONVERSION (with parent fallback)
     # -------------------------------------------------
-    def _try_indirect_convert(self, data, to_type: type[_T]) -> _T | None:
+    def _try_indirect_convert(self, data: typing.Any, to_type: type[_T]) -> _T | None:
         """
         Attempt indirect conversion (DFS) in *this* converter.
         If no success, fallback to parent's indirect attempt.
@@ -234,7 +276,7 @@ class GlobalTypeConverter:
         return GlobalTypeConverter._global_converter.convert(data, to_type)
 
     @staticmethod
-    def try_convert(data, to_type: type[_T]) -> _T:
+    def try_convert(data: typing.Any, to_type: type[_T]) -> _T | typing.Any:
         return GlobalTypeConverter._global_converter.try_convert(data, to_type)
 
 

{aiqtoolkit-1.2.0a20250731.dist-info → aiqtoolkit-1.2.0a20250801.dist-info}/METADATA

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

{aiqtoolkit-1.2.0a20250731.dist-info → aiqtoolkit-1.2.0a20250801.dist-info}/RECORD

@@ -44,8 +44,8 @@ aiq/builder/eval_builder.py,sha256=P2yqhPkjvkUi_ZwEsBNJi_qTSmHjraH0_9LXPGnLR7s,6
 aiq/builder/evaluator.py,sha256=O6Gu0cUwQkrPxPX29Vf_-RopgijxPnhy7mhg_j-9A84,1162
 aiq/builder/framework_enum.py,sha256=eYwHQifZ86dx-OTubVA3qhCLRqhB4ElMBYBGA0gYtic,885
 aiq/builder/front_end.py,sha256=Xhvfi4VcDh5EoCtLr6AlLQfbRm8_TyugUc_IRfirN6Y,2225
-aiq/builder/function.py,sha256=lDcMcAhtwYmFihpG3iXb6rkb0goKcJx5H7_WqNJhoRg,12775
-aiq/builder/function_base.py,sha256=lzAFQtpreDx-XVPzInIzKwizpx8rVyI_hDz1m49ueSY,13113
+aiq/builder/function.py,sha256=ox6wkmSk9ZlwJqAogxCe5rlWr7ZjwlyK2P_iGRJtOlY,13179
+aiq/builder/function_base.py,sha256=xj956YMIySsppijaRkL0GBL0NICtiKqCt4clPFSYJKE,13280
 aiq/builder/function_info.py,sha256=pGPIAL0tjVqLOJymIRB0boI9pzJGdXiPK3KiZvXQsqM,25266
 aiq/builder/intermediate_step_manager.py,sha256=sENuXYQKOwnlEZ7f4lKZ63TTVa6FraT8s_ZM9-vwqa4,7614
 aiq/builder/llm.py,sha256=DcoYCyschsRjkW_yGsa_Ci7ELSpk5KRbi9778Dm_B9c,951
@@ -64,7 +64,7 @@ aiq/cli/cli_utils/validation.py,sha256=GlKpoi3HfE5HELjmz5wk8ezGbb5iZeY0zmA3uxmCr
 aiq/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiq/cli/commands/evaluate.py,sha256=_pqAuvrNKBf0DvGpZFO28vAKBWp6izMpaLbAVnP57_4,4783
 aiq/cli/commands/start.py,sha256=8mnJYSToQ1XuYuRBRSonuOsjSL1wqSm8nwj3tH9cnAM,10097
-aiq/cli/commands/uninstall.py,sha256=tTb5WsyRPPXo511yAGSvSG7U19swbQs8Cf_B4rh7mxQ,3248
+aiq/cli/commands/uninstall.py,sha256=D3PGizMGy-c3DLQ-HBcVYPOv0X8eyxFFw27jJW4kxig,3195
 aiq/cli/commands/validate.py,sha256=YfYNRK7m5te_jkKp1klhGp4PdUVCuDyVG4LRW1YXZk0,1669
 aiq/cli/commands/configure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiq/cli/commands/configure/configure.py,sha256=b_rnfThV161rDmuRO0Jbke-10oSn4RJj2q4IdTvL3ng,1107
@@ -85,7 +85,7 @@ aiq/cli/commands/registry/registry.py,sha256=oo-dPYoKqmGc9lqw3FN9ADg6mGMHwfM14hX
 aiq/cli/commands/registry/remove.py,sha256=ysyfA38NKFZpktjKqDkVK54e9AakpAmBGym2OF6xSuo,3915
 aiq/cli/commands/registry/search.py,sha256=1AhW5Q5GL8SsR6fKgG0rbsd2E0nodm-ehYZwqX2SGgA,5125
 aiq/cli/commands/sizing/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
-aiq/cli/commands/sizing/calc.py,sha256=jJq4BHrdtaiPK9P7f-AblvEouq1fbFZxnGn3GGtWsHY,11007
+aiq/cli/commands/sizing/calc.py,sha256=vAcDknEG8tbmfJV7GcsdbPePOvb-Z8fIZUeW5Q5dl2w,11150
 aiq/cli/commands/sizing/sizing.py,sha256=-Hr9mz_ScEMtBbn6ijvmmWVk0WybLeX0Ryi4qhDiYQU,902
 aiq/cli/commands/workflow/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
 aiq/cli/commands/workflow/workflow.py,sha256=gzd_UXIMGq_NBRZiS_WHh3Dimuw9aTdncREVh8KItJI,1342
@@ -261,9 +261,9 @@ aiq/observability/exporter/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48j
 aiq/observability/exporter/base_exporter.py,sha256=uVr2qssNwJPVJP0P9fD7tNVSdUmj4SWx4GVHqkA1_3s,16639
 aiq/observability/exporter/exporter.py,sha256=QjEtbaTC7LTQpuzdcvRK7gUs6OIlHzQnhzD2pGmXyws,2391
 aiq/observability/exporter/file_exporter.py,sha256=Z1DhUSpTu1SmN282pPRTU20QJZox49jZ75ARsUkgZAk,1496
-aiq/observability/exporter/processing_exporter.py,sha256=4X-LIiJFWryo8ZRrgmz2A5X-JyU3EbVirT6y8rWL9Ck,12310
+aiq/observability/exporter/processing_exporter.py,sha256=wLQ7luy5pZD_uVeAI_JDS92MJhyLDSmoOWeSNL_G3uI,14493
 aiq/observability/exporter/raw_exporter.py,sha256=9MFukCkJE7qHBWf2V2rnsCdzL1HRYRarcudveTsvS8w,1862
-aiq/observability/exporter/span_exporter.py,sha256=9KHedqEAZnPyoPNbVLb4yGsT_2LCYPSCbh3XLCoN9NA,12062
+aiq/observability/exporter/span_exporter.py,sha256=AxEAFeEN3oOs-5ljveDWWCYuJDhVeNXzqyIDS5Gx6Rc,12095
 aiq/observability/mixin/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 aiq/observability/mixin/batch_config_mixin.py,sha256=DixQq-jRhBFJvpOX-gq7GvPmZCPOXQdacylyEuhZ6y0,1399
 aiq/observability/mixin/collector_config_mixin.py,sha256=3iptkRH9N6JgcsPq7GyjjJVAoxjd-l42UKE7iSF4Hq8,1087
@@ -273,9 +273,10 @@ aiq/observability/mixin/resource_conflict_mixin.py,sha256=mcUp3Qinmhiepq3DyRvp9I
 aiq/observability/mixin/serialize_mixin.py,sha256=DgRHJpXCz9qHFYzhlTTx8Dkj297EylCKK3ydGrH5zOw,2478
 aiq/observability/mixin/type_introspection_mixin.py,sha256=VCb68SY_hitWrWLaK2UHQLkjn2jsgxSn9593T2N3zC0,6637
 aiq/observability/processor/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
-aiq/observability/processor/batching_processor.py,sha256=unPc4bZcBgLzMTPVp2x9ezXOPsrZj9LZvrMDsld26KU,13441
+aiq/observability/processor/batching_processor.py,sha256=dE5E_0oHwISXfCxGXpOJ5fEM-YKIfuPz5h9j9gpJoMQ,13857
+aiq/observability/processor/callback_processor.py,sha256=CTa9FVcoGXaYBRfarF7Ig9jymgmKHNgWRIy-OXtDZ1k,1600
 aiq/observability/processor/intermediate_step_serializer.py,sha256=UQgcHauq568TqVmF_FrInsE5Q_Piryrf_fDnuJbRtAc,1249
-aiq/observability/processor/processor.py,sha256=WY-olVcVe2VNB9iopxVIj4xwVODlJ8UcHKqPBh7UqsE,2526
+aiq/observability/processor/processor.py,sha256=kfYe1EiQZkOPSnqIwQ6Rjz44j-EpreRAe2uIspmHK9w,2593
 aiq/observability/utils/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 aiq/observability/utils/dict_utils.py,sha256=DcNhZ0mgcJ-QQfsCl9QSGL-m_jTuHhr1N-v43ZCAMik,7371
 aiq/observability/utils/time_utils.py,sha256=V8m-e3ldUgwv031B17y29yLXIowdlTH4QW8xDw9WKvk,1071
@@ -288,9 +289,9 @@ aiq/profiler/intermediate_property_adapter.py,sha256=XZ_A8f2S5M-EJSkErY6I750Y8HA
 aiq/profiler/profile_runner.py,sha256=aNwzcgw9udNh_rgTjtPCScAfvn7ug63LVzW13AvhWRY,22363
 aiq/profiler/utils.py,sha256=hNh_JfxXDrACIp4usXtlriTfVuYUkk3Pv-x74K34MQg,8180
 aiq/profiler/calc/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
-aiq/profiler/calc/calc_runner.py,sha256=r65olaY-AjuE0lCwlC7Ob9MJ3opopYzGuTqDwx5UOd4,30379
+aiq/profiler/calc/calc_runner.py,sha256=r06RJi7bWGfI39lmG6qjS-l9ZkWm_r7AbzBRNYuVc9w,30681
 aiq/profiler/calc/calculations.py,sha256=GUDceQOs52QMmHg0u6BVgq_cmFKjXLbuQdNyd7UVZ0A,12327
-aiq/profiler/calc/data_models.py,sha256=Wq3REnYWiJR5EWMH-ZzouJRo2NUi78DfyKevNmXKqX8,5662
+aiq/profiler/calc/data_models.py,sha256=vmBu89C1LsJyIRpEEzGi29_cFJDZJUJXOSXWtraVfd8,6172
 aiq/profiler/calc/plot.py,sha256=GW1cK8U2w6hIzKp6ItciCmxHR0KeUCw7n5EvpcPsoio,12222
 aiq/profiler/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiq/profiler/callbacks/agno_callback_handler.py,sha256=aDAUY6GDIUtly6KowXXKUqLc7NbE6khg1aXT1AritaA,14930
@@ -368,7 +369,7 @@ aiq/tool/document_search.py,sha256=w3D3r5ZBS2jYmVAZZ7lC7xCoi25bA1RePoFjjlV1Zog,6
 aiq/tool/nvidia_rag.py,sha256=9mS3igONo1RywxXNj_ITh2-qD91x1R0f7uhOWMZQX3o,4178
 aiq/tool/register.py,sha256=Lwl6l_eEzS8LAELxClmniNhhLluRVZFYXhsk2ocQhNg,1491
 aiq/tool/retriever.py,sha256=DnuU4khpJkd4epDBGQsowDOqDBKFiLQrnyKXgU6IRW8,3724
-aiq/tool/server_tools.py,sha256=7wnB-bfFb2lcGSJuG4Wu9PL_N4cDYRu29zFXxIIa9-8,3201
+aiq/tool/server_tools.py,sha256=286hTIvX_8pEohmkqmgWTCLkTfMTjuR9v0zivcW17r4,3200
 aiq/tool/code_execution/README.md,sha256=GQy3pPOVspFHQdclQCCweIAY2r8rVZ6bXyCY2FcEc6M,4090
 aiq/tool/code_execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiq/tool/code_execution/code_sandbox.py,sha256=ibe6BoYdWzmQWHdVNweVP-QW1WRGirfhvFr0iqm4fI8,10159
@@ -404,7 +405,7 @@ aiq/utils/metadata_utils.py,sha256=lGYvc8Gk0az4qZDGeRbVz4L7B_b-Gnjss8JT4goqL5I,2
 aiq/utils/optional_imports.py,sha256=jQSVBc2fBSRw-2d6r8cEwvh5-di2EUUPakuuo9QbbwA,4039
 aiq/utils/producer_consumer_queue.py,sha256=AcSYkAMBxLx06A5Xdy960PP3AJ7YaSPGJ7rbN_hJsjI,6599
 aiq/utils/string_utils.py,sha256=71HuIzGx7rF8ocTmeoUBpnCi1Qf1yynYlNLLIKP4BVs,1415
-aiq/utils/type_converter.py,sha256=w711BBOwzhtJo2si722C0wPtACFwZvOaKZQDwScAunY,9461
+aiq/utils/type_converter.py,sha256=mu09lnTOrsYee1gQlc1zLoDL7rJhzN7VNhK6viIS5gA,10640
 aiq/utils/type_utils.py,sha256=G-SYlk4BkJv4L225myUhwBY6-Z7wOgR9K49dVUtV8SA,14896
 aiq/utils/url_utils.py,sha256=UzDP_xaS6brWTu7vAws0B4jZyrITIK9Si3U6pZBZqDE,1028
 aiq/utils/data_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -427,10 +428,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.0a20250731.dist-info/licenses/LICENSE-3rd-party.txt,sha256=8o7aySJa9CBvFshPcsRdJbczzdNyDGJ8b0J67WRUQ2k,183936
-aiqtoolkit-1.2.0a20250731.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-aiqtoolkit-1.2.0a20250731.dist-info/METADATA,sha256=n1FtKvKcVGn7LJs3KZa1UUOJWXMi2bNI0baIy6rNGM8,21564
-aiqtoolkit-1.2.0a20250731.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiqtoolkit-1.2.0a20250731.dist-info/entry_points.txt,sha256=iZR3yrf1liXfbcLqn5_pUkLhZyr1bUw_Qh1d2i7gsv4,625
-aiqtoolkit-1.2.0a20250731.dist-info/top_level.txt,sha256=fo7AzYcNhZ_tRWrhGumtxwnxMew4xrT1iwouDy_f0Kc,4
-aiqtoolkit-1.2.0a20250731.dist-info/RECORD,,
+aiqtoolkit-1.2.0a20250801.dist-info/licenses/LICENSE-3rd-party.txt,sha256=8o7aySJa9CBvFshPcsRdJbczzdNyDGJ8b0J67WRUQ2k,183936
+aiqtoolkit-1.2.0a20250801.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+aiqtoolkit-1.2.0a20250801.dist-info/METADATA,sha256=BrsA79HoQ5RbxW4dd9v8o5Ym7CqbsDV8ywi_GSbg9x8,21564
+aiqtoolkit-1.2.0a20250801.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiqtoolkit-1.2.0a20250801.dist-info/entry_points.txt,sha256=iZR3yrf1liXfbcLqn5_pUkLhZyr1bUw_Qh1d2i7gsv4,625
+aiqtoolkit-1.2.0a20250801.dist-info/top_level.txt,sha256=fo7AzYcNhZ_tRWrhGumtxwnxMew4xrT1iwouDy_f0Kc,4
+aiqtoolkit-1.2.0a20250801.dist-info/RECORD,,