ez-a-sync 0.22.15__py3-none-any.whl → 0.22.16__py3-none-any.whl

a_sync/a_sync/modifiers/cache/__init__.py

@@ -11,16 +11,38 @@ class CacheArgs(TypedDict):
     """Typed dictionary for cache arguments."""
 
     cache_type: CacheType
+    """The type of cache to use. Currently, only 'memory' is implemented."""
+
     cache_typed: bool
+    """Whether to consider types for cache keys."""
+
     ram_cache_maxsize: Optional[int]
+    """The maximum size for the LRU cache."""
+
     ram_cache_ttl: Optional[int]
+    """The time-to-live for items in the LRU cache."""
 
 
 @overload
 def apply_async_cache(
     **modifiers: Unpack[CacheArgs],
 ) -> AsyncDecorator[P, T]:
-    """Overload for when no coroutine function is provided."""
+    """Creates a decorator to apply an asynchronous cache.
+
+    This overload is used when no coroutine function is provided. The returned
+    decorator can be applied to a coroutine function later.
+
+    Args:
+        **modifiers: Cache configuration options such as `cache_type`, `cache_typed`, `ram_cache_maxsize`, and `ram_cache_ttl`.
+
+    Examples:
+        >>> @apply_async_cache(cache_type='memory', ram_cache_maxsize=100)
+        ... async def my_function():
+        ...     pass
+
+    See Also:
+        :func:`apply_async_memory_cache`
+    """
 
 
 @overload
@@ -28,7 +50,24 @@ def apply_async_cache(
     coro_fn: int,
     **modifiers: Unpack[CacheArgs],
 ) -> AsyncDecorator[P, T]:
-    """Overload for when an integer is provided as the coroutine function."""
+    """Creates a decorator with `ram_cache_maxsize` set by an integer.
+
+    This overload is used when an integer is provided as the first argument,
+    which sets the `ram_cache_maxsize` for the cache. The returned decorator
+    can be applied to a coroutine function later.
+
+    Args:
+        coro_fn: An integer to set as the max size for the cache.
+        **modifiers: Additional cache configuration options.
+
+    Examples:
+        >>> @apply_async_cache(100, cache_type='memory')
+        ... async def my_function():
+        ...     pass
+
+    See Also:
+        :func:`apply_async_memory_cache`
+    """
 
 
 @overload
@@ -36,7 +75,23 @@ def apply_async_cache(
     coro_fn: CoroFn[P, T],
     **modifiers: Unpack[CacheArgs],
 ) -> CoroFn[P, T]:
-    """Overload for when a coroutine function is provided."""
+    """Applies an asynchronous cache directly to a coroutine function.
+
+    This overload is used when a coroutine function is provided. The cache is
+    applied directly to the function.
+
+    Args:
+        coro_fn: The coroutine function to be cached.
+        **modifiers: Cache configuration options such as `cache_type`, `cache_typed`, `ram_cache_maxsize`, and `ram_cache_ttl`.
+
+    Examples:
+        >>> async def my_function():
+        ...     pass
+        >>> cached_function = apply_async_cache(my_function, cache_type='memory', ram_cache_maxsize=100)
+
+    See Also:
+        :func:`apply_async_memory_cache`
+    """
 
 
 def apply_async_cache(
@@ -48,6 +103,8 @@ def apply_async_cache(
 ) -> AsyncDecoratorOrCoroFn[P, T]:
     """Applies an asynchronous cache to a coroutine function.
 
+    This function can be used to apply a cache to a coroutine function, either by passing the function directly or by using it as a decorator. The cache type is currently limited to 'memory'. If an unsupported cache type is specified, a `NotImplementedError` is raised.
+
     Args:
         coro_fn: The coroutine function to apply the cache to, or an integer to set as the max size.
         cache_type: The type of cache to use. Currently, only 'memory' is implemented.
@@ -60,8 +117,21 @@ def apply_async_cache(
         FunctionNotAsync: If the provided function is not asynchronous.
         NotImplementedError: If an unsupported cache type is specified.
 
-    Returns:
-        A decorator or the decorated coroutine function.
+    Examples:
+        >>> @apply_async_cache(cache_type='memory', ram_cache_maxsize=100)
+        ... async def my_function():
+        ...     pass
+
+        >>> async def my_function():
+        ...     pass
+        >>> cached_function = apply_async_cache(my_function, cache_type='memory', ram_cache_maxsize=100)
+
+        >>> @apply_async_cache(100, cache_type='memory')
+        ... async def another_function():
+        ...     pass
+
+    See Also:
+        :func:`apply_async_memory_cache`
     """
 
     # Parse Inputs

a_sync/a_sync/modifiers/cache/memory.py

@@ -18,7 +18,8 @@ class CacheKwargs(TypedDict):
 
 @overload
 def apply_async_memory_cache(**kwargs: Unpack[CacheKwargs]) -> AsyncDecorator[P, T]:
-    """Creates a decorator to apply an asynchronous LRU cache.
+    """
+    Creates a decorator to apply an asynchronous LRU cache.
 
     This overload is used when no coroutine function is provided. The returned
     decorator can be applied to a coroutine function later.
@@ -26,6 +27,14 @@ def apply_async_memory_cache(**kwargs: Unpack[CacheKwargs]) -> AsyncDecorator[P,
     Args:
         **kwargs: Keyword arguments for cache configuration, including maxsize,
             ttl, and typed.
+
+    Examples:
+        >>> @apply_async_memory_cache(maxsize=128, ttl=60)
+        ... async def fetch_data():
+        ...     pass
+
+    See Also:
+        - :func:`alru_cache` for the underlying caching mechanism.
     """
 
 
@@ -43,6 +52,13 @@ def apply_async_memory_cache(
         coro_fn: An integer to set as maxsize for the cache.
         **kwargs: Additional keyword arguments for cache configuration, including
             ttl and typed.
+
+    Examples:
+        >>> # This usage is not supported
+        >>> apply_async_memory_cache(128, ttl=60)
+
+    See Also:
+        - :func:`apply_async_memory_cache` for correct usage.
     """
 
 
@@ -50,7 +66,8 @@ def apply_async_memory_cache(
 def apply_async_memory_cache(
     coro_fn: CoroFn[P, T], **kwargs: Unpack[CacheKwargs]
 ) -> CoroFn[P, T]:
-    """Applies an asynchronous LRU cache to a provided coroutine function.
+    """
+    Applies an asynchronous LRU cache to a provided coroutine function.
 
     This overload is used when a coroutine function is provided. The cache is
     applied directly to the function.
@@ -59,6 +76,14 @@ def apply_async_memory_cache(
         coro_fn: The coroutine function to be cached.
         **kwargs: Keyword arguments for cache configuration, including maxsize,
             ttl, and typed.
+
+    Examples:
+        >>> async def fetch_data():
+        ...     pass
+        >>> cached_fetch = apply_async_memory_cache(fetch_data, maxsize=128, ttl=60)
+
+    See Also:
+        - :func:`alru_cache` for the underlying caching mechanism.
     """
 
 
@@ -66,7 +91,8 @@ def apply_async_memory_cache(
 def apply_async_memory_cache(
     coro_fn: Literal[None], **kwargs: Unpack[CacheKwargs]
 ) -> AsyncDecorator[P, T]:
-    """Creates a decorator to apply an asynchronous LRU cache.
+    """
+    Creates a decorator to apply an asynchronous LRU cache.
 
     This duplicate overload is used when no coroutine function is provided. The
     returned decorator can be applied to a coroutine function later.
@@ -75,6 +101,14 @@ def apply_async_memory_cache(
         coro_fn: None, indicating no coroutine function is provided.
         **kwargs: Keyword arguments for cache configuration, including maxsize,
             ttl, and typed.
+
+    Examples:
+        >>> @apply_async_memory_cache(maxsize=128, ttl=60)
+        ... async def fetch_data():
+        ...     pass
+
+    See Also:
+        - :func:`alru_cache` for the underlying caching mechanism.
     """
 
 
@@ -84,7 +118,8 @@ def apply_async_memory_cache(
     ttl: Optional[int] = None,
     typed: bool = False,
 ) -> AsyncDecoratorOrCoroFn[P, T]:
-    """Applies an asynchronous LRU cache to a coroutine function.
+    """
+    Applies an asynchronous LRU cache to a coroutine function.
 
     This function uses the `alru_cache` from the `async_lru` library to cache
     the results of an asynchronous coroutine function. The cache can be configured
@@ -102,8 +137,17 @@ def apply_async_memory_cache(
         TypeError: If `maxsize` is not a positive integer or None when `coro_fn` is None.
         exceptions.FunctionNotAsync: If `coro_fn` is not an asynchronous function.
 
-    Returns:
-        A decorator if `coro_fn` is None, otherwise the cached coroutine function.
+    Examples:
+        >>> @apply_async_memory_cache(maxsize=128, ttl=60)
+        ... async def fetch_data():
+        ...     pass
+
+        >>> async def fetch_data():
+        ...     pass
+        >>> cached_fetch = apply_async_memory_cache(fetch_data, maxsize=128, ttl=60)
+
+    See Also:
+        - :func:`alru_cache` for the underlying caching mechanism.
     """
     # Parse Inputs
     if isinstance(coro_fn, int):

a_sync/a_sync/modifiers/limiter.py

@@ -17,8 +17,20 @@ def apply_rate_limit(
 ) -> AsyncDecorator[P, T]:
     """Decorator to apply a rate limit to an asynchronous function.
 
+    This overload allows specifying the number of allowed executions per minute.
+
     Args:
         runs_per_minute: The number of allowed executions per minute.
+
+    Examples:
+        Applying a rate limit of 60 executions per minute:
+
+        >>> @apply_rate_limit(60)
+        ... async def my_function():
+        ...     pass
+
+    See Also:
+        :class:`aiolimiter.AsyncLimiter`
     """
 
 
@@ -29,9 +41,23 @@ def apply_rate_limit(
 ) -> CoroFn[P, T]:
     """Decorator to apply a rate limit to an asynchronous function.
 
+    This overload allows specifying either the number of allowed executions per minute
+    or an :class:`aiolimiter.AsyncLimiter` instance.
+
     Args:
         coro_fn: The coroutine function to be rate-limited.
-        runs_per_minute: The number of allowed executions per minute or an AsyncLimiter instance.
+        runs_per_minute: The number of allowed executions per minute or an :class:`aiolimiter.AsyncLimiter` instance.
+
+    Examples:
+        Using an :class:`aiolimiter.AsyncLimiter` instance:
+
+        >>> async_limiter = AsyncLimiter(60)
+        >>> @apply_rate_limit(async_limiter)
+        ... async def my_function():
+        ...     pass
+
+    See Also:
+        :class:`aiolimiter.AsyncLimiter`
     """
 
 
@@ -44,15 +70,38 @@ def apply_rate_limit(
     This function can be used as a decorator to limit the number of times
     an asynchronous function can be called per minute. It can be configured
     with either an integer specifying the number of runs per minute or an
-    AsyncLimiter instance.
+    :class:`aiolimiter.AsyncLimiter` instance.
 
     Args:
-        coro_fn: The coroutine function to be rate-limited. If an integer is provided, it is treated as runs per minute, and runs_per_minute should be None.
-        runs_per_minute: The number of allowed executions per minute or an AsyncLimiter instance. If coro_fn is an integer, this should be None.
+        coro_fn: The coroutine function to be rate-limited. If an integer is provided, it is treated as runs per minute, and `runs_per_minute` should be None.
+        runs_per_minute: The number of allowed executions per minute or an :class:`aiolimiter.AsyncLimiter` instance. If `coro_fn` is an integer, this should be None.
 
     Raises:
-        TypeError: If 'runs_per_minute' is neither an integer nor an AsyncLimiter when 'coro_fn' is None.
-        exceptions.FunctionNotAsync: If 'coro_fn' is not an asynchronous function.
+        TypeError: If `runs_per_minute` is neither an integer nor an :class:`aiolimiter.AsyncLimiter` when `coro_fn` is None.
+        exceptions.FunctionNotAsync: If `coro_fn` is not an asynchronous function.
+
+    Examples:
+        Applying a rate limit of 60 executions per minute:
+
+        >>> @apply_rate_limit(60)
+        ... async def my_function():
+        ...     pass
+
+        Using an :class:`aiolimiter.AsyncLimiter` instance:
+
+        >>> async_limiter = AsyncLimiter(60)
+        >>> @apply_rate_limit(async_limiter)
+        ... async def my_function():
+        ...     pass
+
+        Specifying the rate limit directly in the decorator:
+
+        >>> @apply_rate_limit
+        ... async def my_function():
+        ...     pass
+
+    See Also:
+        :class:`aiolimiter.AsyncLimiter`
     """
     # Parse Inputs
     if isinstance(coro_fn, (int, AsyncLimiter)):

a_sync/a_sync/modifiers/manager.py

@@ -5,6 +5,7 @@ from a_sync._typing import *
 from a_sync.a_sync.config import user_set_default_modifiers, null_modifiers
 from a_sync.a_sync.modifiers import cache, limiter, semaphores
 
+# TODO give me a docstring
 valid_modifiers = [
     key
     for key in ModifierKwargs.__annotations__
@@ -16,9 +17,35 @@ class ModifierManager(Dict[str, Any]):
     """Manages modifiers for asynchronous and synchronous functions.
 
     This class is responsible for applying modifiers to functions, such as
-    caching, rate limiting, and semaphores for asynchronous functions.
+    caching, rate limiting, and semaphores for asynchronous functions. It also
+    handles synchronous functions, although no sync modifiers are currently
+    implemented.
+
+    Examples:
+        Creating a ModifierManager with specific modifiers:
+
+        >>> modifiers = ModifierKwargs(cache_type='memory', runs_per_minute=60)
+        >>> manager = ModifierManager(modifiers)
+
+        Applying modifiers to an asynchronous function:
+
+        >>> async def my_coro():
+        ...     pass
+        >>> modified_coro = manager.apply_async_modifiers(my_coro)
+
+        Applying modifiers to a synchronous function (no sync modifiers applied):
+
+        >>> def my_function():
+        ...     pass
+        >>> modified_function = manager.apply_sync_modifiers(my_function)
+
+    See Also:
+        - :class:`a_sync.a_sync.modifiers.cache`
+        - :class:`a_sync.a_sync.modifiers.limiter`
+        - :class:`a_sync.a_sync.modifiers.semaphores`
     """
 
+    # TODO give us docstrings
     default: DefaultMode
     cache_type: CacheType
     cache_typed: bool
@@ -26,9 +53,13 @@ class ModifierManager(Dict[str, Any]):
     ram_cache_ttl: Optional[int]
     runs_per_minute: Optional[int]
     semaphore: SemaphoreSpec
+
     # sync modifiers
     executor: Executor
-    """This is not applied like a typical modifier. The executor is used to run the sync function in an asynchronous context."""
+    """
+    This is not applied like a typical modifier but is still passed through the library with them for convenience. 
+    The executor is used to run the sync function in an asynchronous context.
+    """
 
     __slots__ = ("_modifiers",)
 
@@ -95,6 +126,12 @@ class ModifierManager(Dict[str, Any]):
 
         Returns:
             The modified coroutine function.
+
+        Examples:
+            >>> async def my_coro():
+            ...     pass
+            >>> manager = ModifierManager(ModifierKwargs(runs_per_minute=60))
+            >>> modified_coro = manager.apply_async_modifiers(my_coro)
         """
         # NOTE: THESE STACK IN REVERSE ORDER
         if self.use_limiter:
@@ -122,6 +159,12 @@ class ModifierManager(Dict[str, Any]):
 
         Returns:
             The wrapped synchronous function.
+
+        Examples:
+            >>> def my_function():
+            ...     pass
+            >>> manager = ModifierManager(ModifierKwargs())
+            >>> modified_function = manager.apply_sync_modifiers(my_function)
         """
 
         @functools.wraps(function)
@@ -167,5 +210,6 @@ class ModifierManager(Dict[str, Any]):
         return self._modifiers[modifier_key]  # type: ignore [literal-required]
 
 
+# TODO give us docstrings
 nulls = ModifierManager(null_modifiers)
 user_defaults = ModifierManager(user_set_default_modifiers)

a_sync/a_sync/modifiers/semaphores.py

@@ -14,13 +14,39 @@ from a_sync.primitives import ThreadsafeSemaphore, DummySemaphore
 def apply_semaphore(  # type: ignore [misc]
     semaphore: SemaphoreSpec,
 ) -> AsyncDecorator[P, T]:
-    """Applies a semaphore to a coroutine function.
+    """Create a decorator to apply a semaphore to a coroutine function.
 
     This overload is used when the semaphore is provided as a single argument,
     returning a decorator that can be applied to a coroutine function.
 
     Args:
-        semaphore: The semaphore to apply, which can be an integer or an asyncio.Semaphore object.
+        semaphore (Union[int, asyncio.Semaphore, primitives.Semaphore]):
+            The semaphore to apply, which can be an integer, an `asyncio.Semaphore`, or a `primitives.Semaphore`.
+
+    Examples:
+        Using as a decorator with an integer semaphore:
+        >>> @apply_semaphore(2)
+        ... async def limited_concurrent_function():
+        ...     pass
+
+        Using as a decorator with an `asyncio.Semaphore`:
+        >>> sem = asyncio.Semaphore(2)
+        >>> @apply_semaphore(sem)
+        ... async def another_function():
+        ...     pass
+
+        Using as a decorator with a `primitives.Semaphore`:
+        >>> sem = primitives.ThreadsafeSemaphore(2)
+        >>> @apply_semaphore(sem)
+        ... async def yet_another_function():
+        ...     pass
+
+    See Also:
+        - :class:`asyncio.Semaphore`
+        - :class:`primitives.Semaphore`
+
+    Note:
+        `primitives.Semaphore` is a subclass of `asyncio.Semaphore`. Therefore, when the documentation refers to `asyncio.Semaphore`, it also includes `primitives.Semaphore` and any other subclasses.
     """
 
 
@@ -29,14 +55,36 @@ def apply_semaphore(
     coro_fn: CoroFn[P, T],
     semaphore: SemaphoreSpec,
 ) -> CoroFn[P, T]:
-    """Applies a semaphore to a coroutine function.
+    """Apply a semaphore directly to a coroutine function.
 
     This overload is used when both the coroutine function and semaphore are provided,
     directly applying the semaphore to the coroutine function.
 
     Args:
-        coro_fn: The coroutine function to which the semaphore will be applied.
-        semaphore: The semaphore to apply, which can be an integer or an asyncio.Semaphore object.
+        coro_fn (Callable): The coroutine function to which the semaphore will be applied.
+        semaphore (Union[int, asyncio.Semaphore, primitives.Semaphore]):
+            The semaphore to apply, which can be an integer, an `asyncio.Semaphore`, or a `primitives.Semaphore`.
+
+    Examples:
+        Applying directly to a function with an integer semaphore:
+        >>> async def my_coroutine():
+        ...     pass
+        >>> my_coroutine = apply_semaphore(my_coroutine, 3)
+
+        Applying directly with an `asyncio.Semaphore`:
+        >>> sem = asyncio.Semaphore(3)
+        >>> my_coroutine = apply_semaphore(my_coroutine, sem)
+
+        Applying directly with a `primitives.Semaphore`:
+        >>> sem = primitives.ThreadsafeSemaphore(3)
+        >>> my_coroutine = apply_semaphore(my_coroutine, sem)
+
+    See Also:
+        - :class:`asyncio.Semaphore`
+        - :class:`primitives.Semaphore`
+
+    Note:
+        `primitives.Semaphore` is a subclass of `asyncio.Semaphore`. Therefore, when the documentation refers to `asyncio.Semaphore`, it also includes `primitives.Semaphore` and any other subclasses.
     """
 
 
@@ -44,21 +92,46 @@ def apply_semaphore(
     coro_fn: Optional[Union[CoroFn[P, T], SemaphoreSpec]] = None,
     semaphore: SemaphoreSpec = None,
 ) -> AsyncDecoratorOrCoroFn[P, T]:
-    """Applies a semaphore to a coroutine function or returns a decorator.
+    """Apply a semaphore to a coroutine function or return a decorator.
 
     This function can be used to apply a semaphore to a coroutine function either by
     passing the coroutine function and semaphore as arguments or by using the semaphore
     as a decorator. It raises exceptions if the inputs are not valid.
 
     Args:
-        coro_fn: The coroutine function to which the semaphore will be applied, or None
-            if the semaphore is to be used as a decorator.
-        semaphore: The semaphore to apply, which can be an integer or an asyncio.Semaphore object.
+        coro_fn (Optional[Callable]): The coroutine function to which the semaphore will be applied,
+            or None if the semaphore is to be used as a decorator.
+        semaphore (Union[int, asyncio.Semaphore, primitives.Semaphore]):
+            The semaphore to apply, which can be an integer, an `asyncio.Semaphore`, or a `primitives.Semaphore`.
 
     Raises:
-        ValueError: If both coro_fn and semaphore are provided as invalid inputs.
+        ValueError: If both `coro_fn` and `semaphore` are provided and the first argument is an integer or `asyncio.Semaphore`.
         exceptions.FunctionNotAsync: If the provided function is not a coroutine.
-        TypeError: If the semaphore is not an integer or an asyncio.Semaphore object.
+        TypeError: If the semaphore is not an integer, an `asyncio.Semaphore`, or a `primitives.Semaphore`.
+
+    Examples:
+        Using as a decorator:
+        >>> @apply_semaphore(2)
+        ... async def limited_concurrent_function():
+        ...     pass
+
+        Applying directly to a function:
+        >>> async def my_coroutine():
+        ...     pass
+        >>> my_coroutine = apply_semaphore(my_coroutine, 3)
+
+        Handling invalid inputs:
+        >>> try:
+        ...     apply_semaphore(3, 2)
+        ... except ValueError as e:
+        ...     print(e)
+
+    See Also:
+        - :class:`asyncio.Semaphore`
+        - :class:`primitives.Semaphore`
+
+    Note:
+        `primitives.Semaphore` is a subclass of `asyncio.Semaphore`. Therefore, when the documentation refers to `asyncio.Semaphore`, it also includes `primitives.Semaphore` and any other subclasses.
     """
     # Parse Inputs
     if isinstance(coro_fn, (int, asyncio.Semaphore)):

a_sync/a_sync/singleton.py

@@ -6,32 +6,56 @@ class ASyncGenericSingleton(ASyncGenericBase, metaclass=ASyncSingletonMeta):
     """
     A base class for creating singleton-esque ASync classes.
 
-    This class combines the functionality of ASyncGenericBase with a singleton pattern,
+    This class combines the functionality of :class:`ASyncGenericBase` with a singleton pattern,
     ensuring that only one instance of the class exists per execution mode (sync/async).
-    It uses a custom metaclass to manage instance creation and caching.
+    It uses a custom metaclass :class:`ASyncSingletonMeta` to manage instance creation and caching.
 
-    Subclasses of ASyncGenericSingleton will have two instances instead of one:
+    Subclasses of :class:`ASyncGenericSingleton` will have two instances instead of one:
     - one synchronous instance
     - one asynchronous instance
 
     This allows for proper behavior in both synchronous and asynchronous contexts
     while maintaining the singleton pattern within each context.
 
+    Note:
+        This class is abstract and cannot be instantiated directly. Subclasses should define
+        the necessary properties and methods to specify the asynchronous behavior, as outlined
+        in :class:`ASyncABC`.
+
     Example:
-        class MyAsyncSingleton(ASyncGenericSingleton):
-            @a_sync
-            def my_method(self):
-                # Method implementation
-
-        # These will return the same synchronous instance
-        sync_instance1 = MyAsyncSingleton(sync=True)
-        sync_instance2 = MyAsyncSingleton(sync=True)
-
-        # These will return the same asynchronous instance
-        async_instance1 = MyAsyncSingleton(asynchronous=True)
-        async_instance2 = MyAsyncSingleton(asynchronous=True)
-
-        assert sync_instance1 is sync_instance2
-        assert async_instance1 is async_instance2
-        assert sync_instance1 is not async_instance1
+        .. code-block:: python
+
+            class MyAsyncSingleton(ASyncGenericSingleton):
+                @property
+                def __a_sync_flag_name__(self):
+                    return "asynchronous"
+
+                @property
+                def __a_sync_flag_value__(self):
+                    return self.asynchronous
+
+                @classmethod
+                def __a_sync_default_mode__(cls):
+                    return False
+
+                @a_sync
+                def my_method(self):
+                    # Method implementation
+
+            # These will return the same synchronous instance
+            sync_instance1 = MyAsyncSingleton(sync=True)
+            sync_instance2 = MyAsyncSingleton(sync=True)
+
+            # These will return the same asynchronous instance
+            async_instance1 = MyAsyncSingleton(asynchronous=True)
+            async_instance2 = MyAsyncSingleton(asynchronous=True)
+
+            assert sync_instance1 is sync_instance2
+            assert async_instance1 is async_instance2
+            assert sync_instance1 is not async_instance1
+
+    See Also:
+        - :class:`ASyncGenericBase` for base functionality.
+        - :class:`ASyncSingletonMeta` for the metaclass managing the singleton behavior.
+        - :class:`ASyncABC` for defining asynchronous and synchronous behavior.
     """