unique_toolkit 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

{unique_toolkit-0.5.5.dist-info → unique_toolkit-0.5.7.dist-info}/RECORD

@@ -1,24 +1,25 @@
 unique_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+unique_toolkit/_common/_base_service.py,sha256=SDhO69RA6E1ydUuV9N99RKreHZbQmMJj6SCdrYiakhU,283
 unique_toolkit/app/init_logging.py,sha256=Sh26SRxOj8i8dzobKhYha2lLrkrMTHfB1V4jR3h23gQ,678
 unique_toolkit/app/init_sdk.py,sha256=Nv4Now4pMfM0AgRhbtatLpm_39rKxn0WmRLwmPhRl-8,1285
-unique_toolkit/app/performance/async_executor.py,sha256=ImekDRWkFeXuIYFnCpSJAqE0RP-liK-5R8_buZGqYaE,6435
-unique_toolkit/app/performance/async_wrapper.py,sha256=Xli5zH9RFdbBJnlBQS_kP7TGqXhPNou5WKst4FLWzGo,770
+unique_toolkit/app/performance/async_tasks.py,sha256=H0l3OAcosLwNHZ8d2pd-Di4wHIXfclEvagi5kfqLFPA,1941
+unique_toolkit/app/performance/async_wrapper.py,sha256=yVVcRDkcdyfjsxro-N29SBvi-7773wnfDplef6-y8xw,1077
 unique_toolkit/app/schemas.py,sha256=UAbIkrgdqwWEwKqnJwB4TNQWuJgEsFzDxqJbEC8xcOc,1098
 unique_toolkit/app/verification.py,sha256=UZqTHg3PX_QxMjeLH_BVBYoMVqMnMpeMoqvyTBKDqj8,1996
 unique_toolkit/chat/schemas.py,sha256=TYqrDy96ynP7XpnT_abOJlq6LkqBTdKwEft4YHeEgR8,801
-unique_toolkit/chat/service.py,sha256=zxMoOMKlLJNwtRAO8GCpX9tGwVUsbgHWEPWztGe6htw,12300
-unique_toolkit/chat/state.py,sha256=IljPSqbzQq9TMD9cnbkII8k4eTtkyYOGzRe-DuR-Nic,1831
+unique_toolkit/chat/service.py,sha256=jTxFchdjcGp3IQZxWR4x3XTdATxodP0xD4LGJZYltVw,13338
+unique_toolkit/chat/state.py,sha256=qrXkxmYlTM6PRpHX6j_vhJNWkJX4r-xgJ3NvqM80rAY,1441
 unique_toolkit/chat/utils.py,sha256=ihm-wQykBWhB4liR3LnwPVPt_qGW6ETq21Mw4HY0THE,854
 unique_toolkit/content/schemas.py,sha256=b6QiqZUBdYA14_CfJYeXEGSrPmT98n_Q8knugnP20yA,2093
-unique_toolkit/content/service.py,sha256=iDQd4dTVrL_NMRJQDMZsZmtFtwTmYfPAqx832waWy3E,12491
+unique_toolkit/content/service.py,sha256=eRoh92c3sCz2Bz77VdzrUTTnJNWFdo0Ta5xZXMqq47U,13327
 unique_toolkit/content/utils.py,sha256=x3ABo8ZCRm3YJAQwDtrr82z77DmW4Mei7KCIITjP0fk,6897
 unique_toolkit/embedding/schemas.py,sha256=1GvKCaSk4jixzVQ2PKq8yDqwGEVY_hWclYtoAr6CC2g,96
-unique_toolkit/embedding/service.py,sha256=IjBag3koSSeoQTo9836t0K5tkTbu0otvytVWnYQJHw4,2403
+unique_toolkit/embedding/service.py,sha256=xcU84ANMIebBui_AWBhfN1rqz7evXYRgg_Z-132veNE,2703
 unique_toolkit/language_model/infos.py,sha256=NhAkeW7PyusSIHCMvwRikLlzGG4tOXSLf_Fnq7V9rNE,8881
 unique_toolkit/language_model/schemas.py,sha256=kTGSGT3ygrH3guQELOWpxN4MTgEPuudi-CTvRu-zCcI,4377
-unique_toolkit/language_model/service.py,sha256=VHixKmi6-BP-StDQdomS-J-EWKIhHvDjNCi5zrP3mpM,9749
+unique_toolkit/language_model/service.py,sha256=0g0nAGj9Te16YHFhqO9pkszhEwtuZ6bSqor6hi49e6c,10549
 unique_toolkit/language_model/utils.py,sha256=WBPj1XKkDgxy_-T8HCZvsfkkSzj_1w4UZzNmyvdbBLY,1081
-unique_toolkit-0.5.5.dist-info/LICENSE,sha256=bIeCWCYuoUU_MzNdg48-ubJSVm7qxakaRbzTiJ5uxrs,1065
-unique_toolkit-0.5.5.dist-info/METADATA,sha256=YoLF4NmbLwsUgH839HAXLmfC61kjhzyE5dCx0P3kEek,8548
-unique_toolkit-0.5.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-0.5.5.dist-info/RECORD,,
+unique_toolkit-0.5.7.dist-info/LICENSE,sha256=bIeCWCYuoUU_MzNdg48-ubJSVm7qxakaRbzTiJ5uxrs,1065
+unique_toolkit-0.5.7.dist-info/METADATA,sha256=4UJiE5Qwp0g2FWhtVO-EshsKsN5iuCGjH_wn0zQVahY,8977
+unique_toolkit-0.5.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-0.5.7.dist-info/RECORD,,

unique_toolkit/app/performance/async_executor.py

@@ -1,186 +0,0 @@
-import asyncio
-import contextlib
-import logging
-import threading
-import time
-from concurrent.futures import ThreadPoolExecutor
-from math import ceil
-from typing import (
-    AsyncContextManager,
-    Awaitable,
-    Callable,
-    Optional,
-    Sequence,
-    TypeVar,
-    Union,
-)
-
-T = TypeVar("T")
-Result = Union[T, BaseException]
-
-
-class AsyncExecutor:
-    """
-    A class for executing asynchronous tasks concurrently, with optional threading support.
-
-    This class provides methods to run multiple asynchronous tasks in parallel, with
-    the ability to limit the number of concurrent tasks and distribute work across
-    multiple threads if needed.
-
-    Attributes:
-        logger (logging.Logger): Logger instance for recording execution information.
-        context_manager (Callable[[], AsyncContextManager]): A factory function that returns
-            an async context manager to be used for each task execution, e.g., quart.current_app.app_context().
-
-    """
-
-    def __init__(
-        self,
-        logger: Optional[logging.Logger] = None,
-        context_manager: Optional[Callable[[], AsyncContextManager]] = None,
-    ) -> None:
-        self.logger = logger or logging.getLogger(__name__)
-        self.context_manager = context_manager or (lambda: contextlib.nullcontext())
-
-    async def run_async_tasks(
-        self,
-        tasks: Sequence[Awaitable[T]],
-        max_tasks: int,
-    ) -> list[Result]:
-        """
-        Executes the a set of given async tasks and returns the results.
-
-        Args:
-        tasks (list[Awaitable[T]]): list of async callables to execute in parallel.
-        max_tasks (int): Maximum number of tasks for the asyncio Semaphore.
-
-        Returns:
-        list[Result]: list of results from the executed tasks.
-        """
-
-        async def logging_wrapper(task: Awaitable[T], task_id: int) -> Result:
-            thread = threading.current_thread()
-            start_time = time.time()
-
-            self.logger.info(
-                f"Thread {thread.name} (ID: {thread.ident}) starting task {task_id}"
-            )
-
-            try:
-                async with self.context_manager():
-                    result = await task
-                return result
-            except Exception as e:
-                self.logger.error(
-                    f"Thread {thread.name} (ID: {thread.ident}) - Task {task_id} failed with error: {e}"
-                )
-                return e
-            finally:
-                end_time = time.time()
-                duration = end_time - start_time
-                self.logger.debug(
-                    f"Thread {thread.name} (ID: {thread.ident}) - Task {task_id} finished in {duration:.2f} seconds"
-                )
-
-        sem = asyncio.Semaphore(max_tasks)
-
-        async def sem_task(task: Awaitable[T], task_id: int) -> Result:
-            async with sem:
-                return await logging_wrapper(task, task_id)
-
-        wrapped_tasks: list[Awaitable[Result]] = [
-            sem_task(task, i) for i, task in enumerate(tasks)
-        ]
-
-        results: list[Result] = await asyncio.gather(
-            *wrapped_tasks, return_exceptions=True
-        )
-
-        return results
-
-    async def run_async_tasks_in_threads(
-        self,
-        tasks: Sequence[Awaitable[T]],
-        max_threads: int,
-        max_tasks: int,
-    ) -> list[Result[T]]:
-        """
-        Executes the given async tasks in multiple threads and returns the results.
-
-        Args:
-        tasks (list[Awaitable[T]]): list of async callables to execute in parallel.
-        max_threads (int): Maximum number of threads.
-        max_tasks (int): Maximum number of tasks per thread run in parallel.
-
-        Returns:
-        list[Result]: list of results from the executed tasks.
-        """
-
-        async def run_in_thread(task_chunk: list[Awaitable[T]]) -> list[Result]:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            async with self.context_manager():
-                return await self.run_async_tasks(task_chunk, max_tasks)
-
-        def thread_worker(
-            task_chunk: list[Awaitable[T]], chunk_id: int
-        ) -> list[Result]:
-            thread = threading.current_thread()
-            self.logger.info(
-                f"Thread {thread.name} (ID: {thread.ident}) starting chunk {chunk_id} with {len(task_chunk)} tasks"
-            )
-
-            start_time = time.time()
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-            try:
-                results = loop.run_until_complete(run_in_thread(task_chunk))
-                end_time = time.time()
-                duration = end_time - start_time
-                self.logger.info(
-                    f"Thread {thread.name} (ID: {thread.ident}) finished chunk {chunk_id} in {duration:.2f} seconds"
-                )
-                return results
-            except Exception as e:
-                self.logger.error(
-                    f"Thread {thread.name} (ID: {thread.ident}) encountered an error in chunk {chunk_id}: {str(e)}"
-                )
-                raise
-            finally:
-                loop.close()
-
-        start_time = time.time()
-        # Calculate the number of tasks per thread
-        tasks_per_thread: int = ceil(len(tasks) / max_threads)
-
-        # Split tasks into chunks
-        task_chunks: list[Sequence[Awaitable[T]]] = [
-            tasks[i : i + tasks_per_thread]
-            for i in range(0, len(tasks), tasks_per_thread)
-        ]
-
-        self.logger.info(
-            f"Splitting {len(tasks)} tasks into {len(task_chunks)} chunks across {max_threads} threads"
-        )
-
-        # Use ThreadPoolExecutor to manage threads
-        with ThreadPoolExecutor(max_workers=max_threads) as executor:
-            # Submit each chunk of tasks to a thread
-            future_results: list[list[Result]] = list(
-                executor.map(
-                    thread_worker,
-                    task_chunks,
-                    range(len(task_chunks)),  # chunk_id
-                )
-            )
-
-        # Flatten the results from all threads
-        results: list[Result] = [item for sublist in future_results for item in sublist]
-        end_time = time.time()
-        duration = end_time - start_time
-        self.logger.info(
-            f"All threads completed. Total results: {len(results)}. Duration: {duration:.2f} seconds"
-        )
-
-        return results