aiqtoolkit 1.2.0a20250603__py3-none-any.whl → 1.2.0a20250605__py3-none-any.whl

aiq/front_ends/fastapi/fastapi_front_end_config.py

@@ -77,25 +77,45 @@ class AIQEvaluateRequest(BaseModel):
         return config_file
 
 
-class AIQEvaluateResponse(BaseModel):
+class BaseAsyncResponse(BaseModel):
+    """Base model for async responses."""
+    job_id: str = Field(description="Unique identifier for the job")
+    status: str = Field(description="Current status of the job")
+
+
+class AIQEvaluateResponse(BaseAsyncResponse):
     """Response model for the evaluate endpoint."""
-    job_id: str = Field(description="Unique identifier for the evaluation job")
-    status: str = Field(description="Current status of the evaluation job")
+    pass
 
 
-class AIQEvaluateStatusResponse(BaseModel):
-    """Response model for the evaluate status endpoint."""
+class AIQAsyncGenerateResponse(BaseAsyncResponse):
+    """Response model for the async generation endpoint."""
+    pass
+
+
+class BaseAsyncStatusResponse(BaseModel):
+    """Base model for async status responses."""
     job_id: str = Field(description="Unique identifier for the evaluation job")
     status: str = Field(description="Current status of the evaluation job")
-    config_file: str = Field(description="Path to the configuration file used for evaluation")
     error: str | None = Field(default=None, description="Error message if the job failed")
-    output_path: str | None = Field(default=None,
-                                    description="Path to the output file if the job completed successfully")
     created_at: datetime = Field(description="Timestamp when the job was created")
     updated_at: datetime = Field(description="Timestamp when the job was last updated")
     expires_at: datetime | None = Field(default=None, description="Timestamp when the job will expire")
 
 
+class AIQEvaluateStatusResponse(BaseAsyncStatusResponse):
+    """Response model for the evaluate status endpoint."""
+    config_file: str = Field(description="Path to the configuration file used for evaluation")
+    output_path: str | None = Field(default=None,
+                                    description="Path to the output file if the job completed successfully")
+
+
+class AIQAsyncGenerationStatusResponse(BaseAsyncStatusResponse):
+    output: dict | None = Field(
+        default=None,
+        description="Output of the generate request, this is only available if the job completed successfully.")
+
+
 class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
     """
     A FastAPI based front end that allows an AIQ Toolkit workflow to be served as a microservice.
@@ -153,6 +173,9 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
     port: int = Field(default=8000, description="Port to bind the server to", ge=0, le=65535)
     reload: bool = Field(default=False, description="Enable auto-reload for development")
     workers: int = Field(default=1, description="Number of workers to run", ge=1)
+    max_running_async_jobs: int = Field(default=10,
+                                        description="Maximum number of async jobs to run concurrently",
+                                        ge=1)
     step_adaptor: StepAdaptorConfig = StepAdaptorConfig()
 
     workflow: typing.Annotated[EndpointBase, Field(description="Endpoint for the default workflow.")] = EndpointBase(

aiq/front_ends/fastapi/fastapi_front_end_plugin_worker.py

@@ -16,6 +16,7 @@
 import asyncio
 import logging
 import os
+import time
 import typing
 from abc import ABC
 from abc import abstractmethod
@@ -32,6 +33,7 @@ from fastapi.exceptions import HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
+from pydantic import Field
 
 from aiq.builder.workflow_builder import WorkflowBuilder
 from aiq.data_models.api_server import AIQChatRequest
@@ -42,6 +44,8 @@ from aiq.data_models.config import AIQConfig
 from aiq.eval.config import EvaluationRunOutput
 from aiq.eval.evaluate import EvaluationRun
 from aiq.eval.evaluate import EvaluationRunConfig
+from aiq.front_ends.fastapi.fastapi_front_end_config import AIQAsyncGenerateResponse
+from aiq.front_ends.fastapi.fastapi_front_end_config import AIQAsyncGenerationStatusResponse
 from aiq.front_ends.fastapi.fastapi_front_end_config import AIQEvaluateRequest
 from aiq.front_ends.fastapi.fastapi_front_end_config import AIQEvaluateResponse
 from aiq.front_ends.fastapi.fastapi_front_end_config import AIQEvaluateStatusResponse
@@ -68,6 +72,9 @@ class FastApiFrontEndPluginWorkerBase(ABC):
 
         self._front_end_config = config.general.front_end
 
+        self._cleanup_tasks: list[str] = []
+        self._cleanup_tasks_lock = asyncio.Lock()
+
     @property
     def config(self) -> AIQConfig:
         return self._config
@@ -92,10 +99,18 @@ class FastApiFrontEndPluginWorkerBase(ABC):
                 yield
 
                 # If a cleanup task is running, cancel it
-                cleanup_task = getattr(starting_app.state, "cleanup_task", None)
-                if cleanup_task:
-                    logger.info("Cancelling cleanup task")
-                    cleanup_task.cancel()
+                async with self._cleanup_tasks_lock:
+
+                    # Cancel all cleanup tasks
+                    for task_name in self._cleanup_tasks:
+                        cleanup_task: asyncio.Task | None = getattr(starting_app.state, task_name, None)
+                        if cleanup_task is not None:
+                            logger.info("Cancelling %s cleanup task", task_name)
+                            cleanup_task.cancel()
+                        else:
+                            logger.warning("No cleanup task found for %s", task_name)
+
+                    self._cleanup_tasks.clear()
 
             logger.debug("Closing AIQ Toolkit server from process %s", os.getpid())
 
@@ -153,6 +168,32 @@ class RouteInfo(BaseModel):
 
 class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
 
+    @staticmethod
+    async def _periodic_cleanup(name: str, job_store: JobStore, sleep_time_sec: int = 300):
+        while True:
+            try:
+                job_store.cleanup_expired_jobs()
+                logger.debug("Expired %s jobs cleaned up", name)
+            except Exception as e:
+                logger.error("Error during %s job cleanup: %s", name, e)
+            await asyncio.sleep(sleep_time_sec)
+
+    async def create_cleanup_task(self, app: FastAPI, name: str, job_store: JobStore, sleep_time_sec: int = 300):
+        # Schedule periodic cleanup of expired jobs on first job creation
+        attr_name = f"{name}_cleanup_task"
+
+        # Cheap check, if it doesn't exist, we will need to re-check after we acquire the lock
+        if not hasattr(app.state, attr_name):
+            async with self._cleanup_tasks_lock:
+                if not hasattr(app.state, attr_name):
+                    logger.info("Starting %s periodic cleanup task", name)
+                    setattr(
+                        app.state,
+                        attr_name,
+                        asyncio.create_task(
+                            self._periodic_cleanup(name=name, job_store=job_store, sleep_time_sec=sleep_time_sec)))
+                    self._cleanup_tasks.append(attr_name)
+
     def get_step_adaptor(self) -> StepAdaptor:
 
         return StepAdaptor(self.front_end_config.step_adaptor)
@@ -198,21 +239,6 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
         # Don't run multiple evaluations at the same time
         evaluation_lock = asyncio.Lock()
 
-        async def periodic_cleanup(job_store: JobStore):
-            while True:
-                try:
-                    job_store.cleanup_expired_jobs()
-                    logger.debug("Expired jobs cleaned up")
-                except Exception as e:
-                    logger.error("Error during job cleanup: %s", str(e))
-                await asyncio.sleep(300)  # every 5 minutes
-
-        def create_cleanup_task():
-            # Schedule periodic cleanup of expired jobs on first job creation
-            if not hasattr(app.state, "cleanup_task"):
-                logger.info("Starting periodic cleanup task")
-                app.state.cleanup_task = asyncio.create_task(periodic_cleanup(job_store))
-
         async def run_evaluation(job_id: str, config_file: str, reps: int, session_manager: AIQSessionManager):
             """Background task to run the evaluation."""
             async with evaluation_lock:
@@ -250,7 +276,7 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                         return AIQEvaluateResponse(job_id=job.job_id, status=job.status)
 
                 job_id = job_store.create_job(request.config_file, request.job_id, request.expiry_seconds)
-                create_cleanup_task()
+                await self.create_cleanup_task(app=app, name="async_evaluation", job_store=job_store)
                 background_tasks.add_task(run_evaluation, job_id, request.config_file, request.reps, session_manager)
 
                 return AIQEvaluateResponse(job_id=job_id, status="submitted")
@@ -276,7 +302,7 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                 if not job:
                     logger.warning("Job %s not found", job_id)
                     raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
-                logger.info(f"Found job {job_id} with status {job.status}")
+                logger.info("Found job %s with status %s", job_id, job.status)
                 return translate_job_to_response(job)
 
         async def get_last_job_status(http_request: Request) -> AIQEvaluateStatusResponse:
@@ -370,9 +396,28 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
         GenerateStreamResponseType = workflow.streaming_output_schema  # pylint: disable=invalid-name
         GenerateSingleResponseType = workflow.single_output_schema  # pylint: disable=invalid-name
 
+        # Append job_id and expiry_seconds to the input schema, this effectively makes these reserved keywords
+        # Consider prefixing these with "aiq_" to avoid conflicts
+        class AIQAsyncGenerateRequest(GenerateBodyType):
+            job_id: str | None = Field(default=None, description="Unique identifier for the evaluation job")
+            sync_timeout: int = Field(
+                default=0,
+                ge=0,
+                le=300,
+                description="Attempt to perform the job synchronously up until `sync_timeout` sectonds, "
+                "if the job hasn't been completed by then a job_id will be returned with a status code of 202.")
+            expiry_seconds: int = Field(default=JobStore.DEFAULT_EXPIRY,
+                                        ge=JobStore.MIN_EXPIRY,
+                                        le=JobStore.MAX_EXPIRY,
+                                        description="Optional time (in seconds) before the job expires. "
+                                        "Clamped between 600 (10 min) and 86400 (24h).")
+
         # Ensure that the input is in the body. POD types are treated as query parameters
         if (not issubclass(GenerateBodyType, BaseModel)):
             GenerateBodyType = typing.Annotated[GenerateBodyType, Body()]
+        else:
+            logger.info("Expecting generate request payloads in the following format: %s",
+                        GenerateBodyType.model_fields)
 
         response_500 = {
             "description": "Internal Server Error",
@@ -385,6 +430,12 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
             },
         }
 
+        # Create job store for tracking async generation jobs
+        job_store = JobStore()
+
+        # Run up to max_running_async_jobs jobs at the same time
+        async_job_concurrency = asyncio.Semaphore(self._front_end_config.max_running_async_jobs)
+
         def get_single_endpoint(result_type: type | None):
 
             async def get_single(response: Response, request: Request):
@@ -482,6 +533,96 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
 
             return post_stream
 
+        async def run_generation(job_id: str,
+                                 payload: typing.Any,
+                                 session_manager: AIQSessionManager,
+                                 result_type: type):
+            """Background task to run the evaluation."""
+            async with async_job_concurrency:
+                try:
+                    result = await generate_single_response(payload=payload,
+                                                            session_manager=session_manager,
+                                                            result_type=result_type)
+                    job_store.update_status(job_id, "success", output=result)
+                except Exception as e:
+                    logger.error("Error in evaluation job %s: %s", job_id, e)
+                    job_store.update_status(job_id, "failure", error=str(e))
+
+        def _job_status_to_response(job: JobInfo) -> AIQAsyncGenerationStatusResponse:
+            job_output = job.output
+            if job_output is not None:
+                job_output = job_output.model_dump()
+            return AIQAsyncGenerationStatusResponse(job_id=job.job_id,
+                                                    status=job.status,
+                                                    error=job.error,
+                                                    output=job_output,
+                                                    created_at=job.created_at,
+                                                    updated_at=job.updated_at,
+                                                    expires_at=job_store.get_expires_at(job))
+
+        def post_async_generation(request_type: type, final_result_type: type):
+
+            async def start_async_generation(
+                    request: request_type, background_tasks: BackgroundTasks, response: Response,
+                    http_request: Request) -> AIQAsyncGenerateResponse | AIQAsyncGenerationStatusResponse:
+                """Handle async generation requests."""
+
+                async with session_manager.session(request=http_request):
+
+                    # if job_id is present and already exists return the job info
+                    if request.job_id:
+                        job = job_store.get_job(request.job_id)
+                        if job:
+                            return AIQAsyncGenerateResponse(job_id=job.job_id, status=job.status)
+
+                    job_id = job_store.create_job(job_id=request.job_id, expiry_seconds=request.expiry_seconds)
+                    await self.create_cleanup_task(app=app, name="async_generation", job_store=job_store)
+
+                    # The fastapi/starlette background tasks won't begin executing until after the response is sent
+                    # to the client, so we need to wrap the task in a function, alowing us to start the task now,
+                    # and allowing the background task function to await the results.
+                    task = asyncio.create_task(
+                        run_generation(job_id=job_id,
+                                       payload=request,
+                                       session_manager=session_manager,
+                                       result_type=final_result_type))
+
+                    async def wrapped_task(t: asyncio.Task):
+                        return await t
+
+                    background_tasks.add_task(wrapped_task, task)
+
+                    now = time.time()
+                    sync_timeout = now + request.sync_timeout
+                    while time.time() < sync_timeout:
+                        job = job_store.get_job(job_id)
+                        if job is not None and job.status not in job_store.ACTIVE_STATUS:
+                            # If the job is done, return the result
+                            response.status_code = 200
+                            return _job_status_to_response(job)
+
+                        # Sleep for a short time before checking again
+                        await asyncio.sleep(0.1)
+
+                    response.status_code = 202
+                    return AIQAsyncGenerateResponse(job_id=job_id, status="submitted")
+
+            return start_async_generation
+
+        async def get_async_job_status(job_id: str, http_request: Request) -> AIQAsyncGenerationStatusResponse:
+            """Get the status of an async job."""
+            logger.info("Getting status for job %s", job_id)
+
+            async with session_manager.session(request=http_request):
+
+                job = job_store.get_job(job_id)
+                if not job:
+                    logger.warning("Job %s not found", job_id)
+                    raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
+
+                logger.info("Found job %s with status %s", job_id, job.status)
+                return _job_status_to_response(job)
+
         if (endpoint.path):
             if (endpoint.method == "GET"):
 
@@ -554,9 +695,31 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                     responses={500: response_500},
                 )
 
+                app.add_api_route(
+                    path=f"{endpoint.path}/async",
+                    endpoint=post_async_generation(request_type=AIQAsyncGenerateRequest,
+                                                   final_result_type=GenerateSingleResponseType),
+                    methods=[endpoint.method],
+                    response_model=AIQAsyncGenerateResponse | AIQAsyncGenerationStatusResponse,
+                    description="Start an async generate job",
+                    responses={500: response_500},
+                )
             else:
                 raise ValueError(f"Unsupported method {endpoint.method}")
 
+            app.add_api_route(
+                path=f"{endpoint.path}/async/job/{{job_id}}",
+                endpoint=get_async_job_status,
+                methods=["GET"],
+                response_model=AIQAsyncGenerationStatusResponse,
+                description="Get the status of an async job",
+                responses={
+                    404: {
+                        "description": "Job not found"
+                    }, 500: response_500
+                },
+            )
+
         if (endpoint.openai_api_path):
             if (endpoint.method == "GET"):
 

aiq/front_ends/fastapi/job_store.py

@@ -16,6 +16,7 @@
 import logging
 import os
 import shutil
+import threading
 from datetime import UTC
 from datetime import datetime
 from datetime import timedelta
@@ -40,12 +41,13 @@ class JobStatus(str, Enum):
 class JobInfo(BaseModel):
     job_id: str
     status: JobStatus
-    config_file: str
+    config_file: str | None
     error: str | None
     output_path: str | None
     created_at: datetime
     updated_at: datetime
     expiry_seconds: int
+    output: BaseModel | None = None
 
 
 class JobStore:
@@ -59,8 +61,12 @@ class JobStore:
 
     def __init__(self):
         self._jobs = {}
+        self._lock = threading.Lock()  # Ensure thread safety for job operations
 
-    def create_job(self, config_file: str, job_id: str | None = None, expiry_seconds: int = DEFAULT_EXPIRY) -> str:
+    def create_job(self,
+                   config_file: str | None = None,
+                   job_id: str | None = None,
+                   expiry_seconds: int = DEFAULT_EXPIRY) -> str:
         if job_id is None:
             job_id = str(uuid4())
 
@@ -76,46 +82,62 @@ class JobStore:
                       error=None,
                       output_path=None,
                       expiry_seconds=clamped_expiry)
-        self._jobs[job_id] = job
+
+        with self._lock:
+            self._jobs[job_id] = job
+
         logger.info("Created new job %s with config %s", job_id, config_file)
         return job_id
 
-    def update_status(self, job_id: str, status: str, error: str | None = None, output_path: str | None = None):
+    def update_status(self,
+                      job_id: str,
+                      status: str,
+                      error: str | None = None,
+                      output_path: str | None = None,
+                      output: BaseModel | None = None):
         if job_id not in self._jobs:
             raise ValueError(f"Job {job_id} not found")
 
-        job = self._jobs[job_id]
-        job.status = status
-        job.error = error
-        job.output_path = output_path
-        job.updated_at = datetime.now(UTC)
+        with self._lock:
+            job = self._jobs[job_id]
+            job.status = status
+            job.error = error
+            job.output_path = output_path
+            job.updated_at = datetime.now(UTC)
+            job.output = output
 
     def get_status(self, job_id: str) -> JobInfo | None:
-        return self._jobs.get(job_id)
+        with self._lock:
+            return self._jobs.get(job_id)
 
     def list_jobs(self):
-        return self._jobs
+        with self._lock:
+            return self._jobs
 
     def get_job(self, job_id: str) -> JobInfo | None:
         """Get a job by its ID."""
-        return self._jobs.get(job_id)
+        with self._lock:
+            return self._jobs.get(job_id)
 
     def get_last_job(self) -> JobInfo | None:
         """Get the last created job."""
-        if not self._jobs:
-            logger.info("No jobs found in job store")
-            return None
-        last_job = max(self._jobs.values(), key=lambda job: job.created_at)
-        logger.info("Retrieved last job %s created at %s", last_job.job_id, last_job.created_at)
-        return last_job
+        with self._lock:
+            if not self._jobs:
+                logger.info("No jobs found in job store")
+                return None
+            last_job = max(self._jobs.values(), key=lambda job: job.created_at)
+            logger.info("Retrieved last job %s created at %s", last_job.job_id, last_job.created_at)
+            return last_job
 
     def get_jobs_by_status(self, status: str) -> list[JobInfo]:
         """Get all jobs with the specified status."""
-        return [job for job in self._jobs.values() if job.status == status]
+        with self._lock:
+            return [job for job in self._jobs.values() if job.status == status]
 
     def get_all_jobs(self) -> list[JobInfo]:
         """Get all jobs in the store."""
-        return list(self._jobs.values())
+        with self._lock:
+            return list(self._jobs.values())
 
     def get_expires_at(self, job: JobInfo) -> datetime | None:
         """Get the time for a job to expire."""
@@ -132,7 +154,8 @@ class JobStore:
         now = datetime.now(UTC)
 
         # Filter out active jobs
-        finished_jobs = {job_id: job for job_id, job in self._jobs.items() if job.status not in self.ACTIVE_STATUS}
+        with self._lock:
+            finished_jobs = {job_id: job for job_id, job in self._jobs.items() if job.status not in self.ACTIVE_STATUS}
 
         # Sort finished jobs by updated_at descending
         sorted_finished = sorted(finished_jobs.items(), key=lambda item: item[1].updated_at, reverse=True)
@@ -155,7 +178,6 @@ class JobStore:
                     elif os.path.isdir(job.output_path):
                         shutil.rmtree(job.output_path)
 
-        for job_id in expired_ids:
-            # cleanup output dir if present
-
-            del self._jobs[job_id]
+        with self._lock:
+            for job_id in expired_ids:
+                del self._jobs[job_id]

{aiqtoolkit-1.2.0a20250603.dist-info → aiqtoolkit-1.2.0a20250605.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqtoolkit
-Version: 1.2.0a20250603
+Version: 1.2.0a20250605
 Summary: NVIDIA Agent Intelligence toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
@@ -271,6 +271,8 @@ Provides-Extra: profiling
 Requires-Dist: matplotlib~=3.9; extra == "profiling"
 Requires-Dist: prefixspan~=0.5.2; extra == "profiling"
 Requires-Dist: scikit-learn~=1.6; extra == "profiling"
+Provides-Extra: gunicorn
+Requires-Dist: gunicorn~=23.0; extra == "gunicorn"
 Dynamic: license-file
 
 <!--

{aiqtoolkit-1.2.0a20250603.dist-info → aiqtoolkit-1.2.0a20250605.dist-info}/RECORD

@@ -141,11 +141,11 @@ aiq/front_ends/console/console_front_end_plugin.py,sha256=CzadUoHmzrHC_MWn2Fkgh_
 aiq/front_ends/console/register.py,sha256=a84M0jWUFTgOQVyrUiS7UJcxx84i1zhCb1yRkjhapiQ,1159
 aiq/front_ends/cron/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 aiq/front_ends/fastapi/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
-aiq/front_ends/fastapi/fastapi_front_end_config.py,sha256=TaRppa8h7_noLq_TvLbOOO60vE8ccab90jELD-nVLDE,8742
+aiq/front_ends/fastapi/fastapi_front_end_config.py,sha256=8Pb0dpICjc_zGbBrA5cZ92QTVjjePK9L0zfnFrrBnWc,9483
 aiq/front_ends/fastapi/fastapi_front_end_plugin.py,sha256=NdE5c4pS5sMYopI3PUaE397K8HF-GuZoOmpAi1ReDRk,4002
-aiq/front_ends/fastapi/fastapi_front_end_plugin_worker.py,sha256=UJ4u8d-auPF8Dn-0w6UEExEGe5E8kkIkmTcD9yYzj9Q,27333
+aiq/front_ends/fastapi/fastapi_front_end_plugin_worker.py,sha256=ZbAM3qZFUQJDp2sMyNIyJ6enhB_2gx6aSX7UPkgUtHU,36064
 aiq/front_ends/fastapi/intermediate_steps_subscriber.py,sha256=2Y3ZXfiu8d85qJRWbT3-ex6iFDuXO6TnNtjQ6Cjl-tc,3131
-aiq/front_ends/fastapi/job_store.py,sha256=XpLrl-V-bJM-ae-aseLG1KfZLpFt3X285D0B5SSU9PM,5715
+aiq/front_ends/fastapi/job_store.py,sha256=AZC0a8miKqSI9YbW19-AA_GPITVY9bYHXn9H8saNrfQ,6389
 aiq/front_ends/fastapi/main.py,sha256=ftLYy8YEyiY38kxReRwAVKwQsTa7QrKjnBU8V1omXaU,2789
 aiq/front_ends/fastapi/message_handler.py,sha256=3rFDXG633Upom1taW3ab_sC3KKxN8Y_WoM_kXtJ3K6o,12640
 aiq/front_ends/fastapi/message_validator.py,sha256=NqjeIG0InGAS6yooEnTaYwjfy3qtQHNgmdJ4zZlxgSQ,17407
@@ -308,10 +308,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.0a20250603.dist-info/licenses/LICENSE-3rd-party.txt,sha256=8o7aySJa9CBvFshPcsRdJbczzdNyDGJ8b0J67WRUQ2k,183936
-aiqtoolkit-1.2.0a20250603.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-aiqtoolkit-1.2.0a20250603.dist-info/METADATA,sha256=0QDO0cC3pfjNCbxGxNUoi1sqLKUG32Y45xFnPZ8IOuY,20174
-aiqtoolkit-1.2.0a20250603.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiqtoolkit-1.2.0a20250603.dist-info/entry_points.txt,sha256=gRlPfR5g21t328WNEQ4CcEz80S1sJNS8A7rMDYnzl4A,452
-aiqtoolkit-1.2.0a20250603.dist-info/top_level.txt,sha256=fo7AzYcNhZ_tRWrhGumtxwnxMew4xrT1iwouDy_f0Kc,4
-aiqtoolkit-1.2.0a20250603.dist-info/RECORD,,
+aiqtoolkit-1.2.0a20250605.dist-info/licenses/LICENSE-3rd-party.txt,sha256=8o7aySJa9CBvFshPcsRdJbczzdNyDGJ8b0J67WRUQ2k,183936
+aiqtoolkit-1.2.0a20250605.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+aiqtoolkit-1.2.0a20250605.dist-info/METADATA,sha256=zSXx7wEwV1TwY_ONAYFykvC5BuygtM79ehAye0K1t5E,20250
+aiqtoolkit-1.2.0a20250605.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiqtoolkit-1.2.0a20250605.dist-info/entry_points.txt,sha256=gRlPfR5g21t328WNEQ4CcEz80S1sJNS8A7rMDYnzl4A,452
+aiqtoolkit-1.2.0a20250605.dist-info/top_level.txt,sha256=fo7AzYcNhZ_tRWrhGumtxwnxMew4xrT1iwouDy_f0Kc,4
+aiqtoolkit-1.2.0a20250605.dist-info/RECORD,,