ez-a-sync 0.22.5__tar.gz → 0.22.7__tar.gz

ez_a_sync-0.22.7/.sourcery.yaml

@@ -0,0 +1,85 @@
+# 🪄 This is your project's Sourcery configuration file.
+
+# You can use it to get Sourcery working in the way you want, such as
+# ignoring specific refactorings, skipping directories in your project,
+# or writing custom rules.
+
+# 📚 For a complete reference to this file, see the documentation at
+# https://docs.sourcery.ai/Configuration/Project-Settings/
+
+# This file was auto-generated by Sourcery on 2024-09-06 at 01:04.
+
+version: '1'  # The schema version of this config file
+
+ignore: # A list of paths or files which Sourcery will ignore.
+- .git
+- env
+- .env
+- .tox
+- node_modules
+- vendor
+- venv
+- .venv
+- ~/.pyenv
+- ~/.rye
+- ~/.vscode
+- .vscode
+- ~/.cache
+- ~/.config
+- ~/.local
+
+rule_settings:
+  enable:
+  - default
+  disable: [
+    no-conditionals-in-tests, 
+    no-loop-in-tests, 
+    dict-assign-update-to-union, # we want to be backward compatible with many pythons
+  ]  # A list of rule IDs Sourcery will never suggest.
+  rule_types:
+  - refactoring
+  - suggestion
+  - comment
+  python_version: '3.9' # A string specifying the lowest Python version your project supports. Sourcery will not suggest refactorings requiring a higher Python version.
+
+# rules:  # A list of custom rules Sourcery will include in its analysis.
+# - id: no-print-statements
+#   description: Do not use print statements in the test directory.
+#   pattern: print(...)
+#   language: python
+#   replacement:
+#   condition:
+#   explanation:
+#   paths:
+#     include:
+#     - test
+#     exclude:
+#     - conftest.py
+#   tests: []
+#   tags: []
+
+# rule_tags: {} # Additional rule tags.
+
+# metrics:
+#   quality_threshold: 25.0
+
+# github:
+#   labels: []
+#   ignore_labels:
+#   - sourcery-ignore
+#   request_review: author
+#   sourcery_branch: sourcery/{base_branch}
+
+# clone_detection:
+#   min_lines: 3
+#   min_duplicates: 2
+#   identical_clones_only: false
+
+# proxy:
+#   url:
+#   ssl_certs_file:
+#   no_ssl_verify: false
+
+# coding_assistant:
+#   project_description: ''
+#   enabled: true

{ez_a_sync-0.22.5 → ez_a_sync-0.22.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ez-a-sync
-Version: 0.22.5
+Version: 0.22.7
 Summary: A library that makes it easy to define objects that can be used for both sync and async use cases.
 Home-page: https://github.com/BobTheBuidler/a-sync
 Author: BobTheBuidler

{ez_a_sync-0.22.5 → ez_a_sync-0.22.7}/a_sync/_typing.py

@@ -1,6 +1,7 @@
 """
 This module provides type definitions and type-related utilities for the a_sync library.
-It includes various type aliases, protocols, and TypedDicts used throughout the library.
+It includes various type aliases, protocols, and TypedDicts used throughout the library
+to enhance type checking and provide better IDE support.
 """
 
 import asyncio
@@ -24,15 +25,19 @@ T = TypeVar("T")
 K = TypeVar("K")
 V = TypeVar("V")
 I = TypeVar("I")
+"""A :class:`TypeVar` that is used to represent instances of a common class."""
+
 E = TypeVar('E', bound=Exception)
 TYPE = TypeVar("TYPE", bound=Type)
+
 P = ParamSpec("P")
+"""A :class:`ParamSpec` used everywhere in the lib."""
 
 Numeric = Union[int, float, Decimal]
-"Type alias for numeric values int, float, and Decimal."
+"""Type alias for numeric values of types int, float, or Decimal."""
 
 MaybeAwaitable = Union[Awaitable[T], T]
-"Type alias for values that may or may not be awaitable."
+"""Type alias for values that may or may not be awaitable. Useful for functions that can return either an awaitable or a direct value."""
 
 MaybeCoro = Union[Coroutine[Any, Any, T], T]
 "Type alias for values that may or may not be coroutine."
@@ -41,7 +46,7 @@ CoroFn = Callable[P, Awaitable[T]]
 "Type alias for any function that returns an awaitable."
 
 SyncFn = Callable[P, T]
-"Type alias for synchronous functions."
+"""Type alias for synchronous functions."""
 
 AnyFn = Union[CoroFn[P, T], SyncFn[P, T]]
 "Type alias for any function, whether synchronous or asynchronous."
@@ -49,6 +54,14 @@ AnyFn = Union[CoroFn[P, T], SyncFn[P, T]]
 class CoroBoundMethod(Protocol[I, P, T]):
     """
     Protocol for coroutine bound methods.
+
+    Example:
+        class MyClass:
+            async def my_method(self, x: int) -> str:
+                return str(x)
+        
+        instance = MyClass()
+        bound_method: CoroBoundMethod[MyClass, [int], str] = instance.my_method
     """
     __self__: I
     __call__: Callable[P, Awaitable[T]]
@@ -56,6 +69,14 @@ class CoroBoundMethod(Protocol[I, P, T]):
 class SyncBoundMethod(Protocol[I, P, T]):
     """
     Protocol for synchronous bound methods.
+
+    Example:
+        class MyClass:
+            def my_method(self, x: int) -> str:
+                return str(x)
+        
+        instance = MyClass()
+        bound_method: SyncBoundMethod[MyClass, [int], str] = instance.my_method
     """
     __self__: I
     __call__: Callable[P, T]
@@ -67,6 +88,9 @@ AnyBoundMethod = Union[CoroBoundMethod[Any, P, T], SyncBoundMethod[Any, P, T]]
 class AsyncUnboundMethod(Protocol[I, P, T]):
     """
     Protocol for unbound asynchronous methods.
+    
+    An unbound method is a method that hasn't been bound to an instance of a class yet.
+    It's essentially the function object itself, before it's accessed through an instance.
     """
     __get__: Callable[[I, Type], CoroBoundMethod[I, P, T]]
 
@@ -74,6 +98,9 @@ class AsyncUnboundMethod(Protocol[I, P, T]):
 class SyncUnboundMethod(Protocol[I, P, T]):
     """
     Protocol for unbound synchronous methods.
+    
+    An unbound method is a method that hasn't been bound to an instance of a class yet.
+    It's essentially the function object itself, before it's accessed through an instance.
     """
     __get__: Callable[[I, Type], SyncBoundMethod[I, P, T]]
 
@@ -122,4 +149,7 @@ AnyIterable = Union[AsyncIterable[K], Iterable[K]]
 "Type alias for any iterable, whether synchronous or asynchronous."
 
 AnyIterableOrAwaitableIterable = Union[AnyIterable[K], Awaitable[AnyIterable[K]]]
-"Type alias for any iterable, whether synchronous or asynchronous, or an awaitable that resolves to any iterable, whether synchronous or asynchronous."
+"""
+Type alias for any iterable, whether synchronous or asynchronous, 
+or an awaitable that resolves to any iterable, whether synchronous or asynchronous.
+"""

ez_a_sync-0.22.7/a_sync/a_sync/_descriptor.py

@@ -0,0 +1,219 @@
+"""
+This module contains the ASyncDescriptor class, which is used to create sync/async methods
+and properties.
+
+It also includes utility methods for mapping operations across multiple instances.
+"""
+
+import functools
+
+from a_sync._typing import *
+from a_sync.a_sync import decorator
+from a_sync.a_sync.function import ASyncFunction, ModifiedMixin, ModifierManager
+
+if TYPE_CHECKING:
+    from a_sync import TaskMapping
+
+class ASyncDescriptor(ModifiedMixin, Generic[I, P, T]):
+    """
+    A descriptor base class for asynchronous methods and properties.
+
+    This class provides functionality for mapping operations across multiple instances
+    and includes utility methods for common operations.
+    """
+
+    __wrapped__: AnyFn[Concatenate[I, P], T]
+    """The wrapped function or method."""
+
+    __slots__ = "field_name", "_fget"
+
+    def __init__(
+        self, 
+        _fget: AnyFn[Concatenate[I, P], T], 
+        field_name: Optional[str] = None, 
+        **modifiers: ModifierKwargs,
+    ) -> None:
+        """
+        Initialize the {cls}.
+
+        Args:
+            _fget: The function to be wrapped.
+            field_name: Optional name for the field. If not provided, the function's name will be used.
+            **modifiers: Additional modifier arguments.
+
+        Raises:
+            ValueError: If _fget is not callable.
+        """
+        if not callable(_fget):
+            raise ValueError(f'Unable to decorate {_fget}')
+        self.modifiers = ModifierManager(modifiers)
+        if isinstance(_fget, ASyncFunction):
+            self.modifiers.update(_fget.modifiers)
+            self.__wrapped__ = _fget
+        elif asyncio.iscoroutinefunction(_fget):
+            self.__wrapped__: AsyncUnboundMethod[I, P, T] = self.modifiers.apply_async_modifiers(_fget)
+        else:
+            self.__wrapped__ = _fget
+
+        self.field_name = field_name or _fget.__name__
+        """The name of the field the {cls} is bound to."""
+        
+        functools.update_wrapper(self, self.__wrapped__)
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} for {self.__wrapped__}>"
+
+    def __set_name__(self, owner, name):
+        """
+        Set the field name when the {cls} is assigned to a class.
+
+        Args:
+            owner: The class owning this descriptor.
+            name: The name assigned to this descriptor in the class.
+        """
+        self.field_name = name
+
+    def map(self, *instances: AnyIterable[I], **bound_method_kwargs: P.kwargs) -> "TaskMapping[I, T]":
+        """
+        Create a TaskMapping for the given instances.
+
+        Args:
+            *instances: Iterable of instances to map over.
+            **bound_method_kwargs: Additional keyword arguments for the bound method.
+
+        Returns:
+            A TaskMapping object.
+        """
+        from a_sync.task import TaskMapping
+        return TaskMapping(self, *instances, **bound_method_kwargs)
+
+    @functools.cached_property
+    def all(self) -> ASyncFunction[Concatenate[AnyIterable[I], P], bool]:
+        """
+        Create an :class:`~ASyncFunction` that checks if all results are truthy.
+
+        Returns:
+            An ASyncFunction object.
+        """
+        return decorator.a_sync(default=self.default)(self._all)
+
+    @functools.cached_property
+    def any(self) -> ASyncFunction[Concatenate[AnyIterable[I], P], bool]:
+        """
+        Create an :class:`~ASyncFunction` that checks if any result is truthy.
+
+        Returns:
+            An ASyncFunction object.
+        """
+        return decorator.a_sync(default=self.default)(self._any)
+
+    @functools.cached_property
+    def min(self) -> ASyncFunction[Concatenate[AnyIterable[I], P], T]:
+        """
+        Create an :class:`~ASyncFunction` that returns the minimum result.
+
+        Returns:
+            An ASyncFunction object.
+        """
+        return decorator.a_sync(default=self.default)(self._min)
+
+    @functools.cached_property
+    def max(self) -> ASyncFunction[Concatenate[AnyIterable[I], P], T]:
+        """
+        Create an :class:`~ASyncFunction` that returns the maximum result.
+
+        Returns:
+            An ASyncFunction object.
+        """
+        return decorator.a_sync(default=self.default)(self._max)
+
+    @functools.cached_property
+    def sum(self) -> ASyncFunction[Concatenate[AnyIterable[I], P], T]:
+        """
+        Create an :class:`~ASyncFunction` that returns the sum of results.
+
+        Returns:
+            An ASyncFunction object.
+        """
+        return decorator.a_sync(default=self.default)(self._sum)
+
+    async def _all(self, *instances: AnyIterable[I], concurrency: Optional[int] = None, name: str = "", **kwargs: P.kwargs) -> bool:
+        """
+        Check if all results are truthy.
+
+        Args:
+            *instances: Iterable of instances to check.
+            concurrency: Optional maximum number of concurrent tasks.
+            name: Optional name for the task.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            A boolean indicating if all results are truthy.
+        """
+        return await self.map(*instances, concurrency=concurrency, name=name, **kwargs).all(pop=True, sync=False)
+
+    async def _any(self, *instances: AnyIterable[I], concurrency: Optional[int] = None, name: str = "", **kwargs: P.kwargs) -> bool:
+        """
+        Check if any result is truthy.
+
+        Args:
+            *instances: Iterable of instances to check.
+            concurrency: Optional maximum number of concurrent tasks.
+            name: Optional name for the task.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            A boolean indicating if any result is truthy.
+        """
+        return await self.map(*instances, concurrency=concurrency, name=name, **kwargs).any(pop=True, sync=False)
+
+    async def _min(self, *instances: AnyIterable[I], concurrency: Optional[int] = None, name: str = "", **kwargs: P.kwargs) -> T:
+        """
+        Find the minimum result.
+
+        Args:
+            *instances: Iterable of instances to check.
+            concurrency: Optional maximum number of concurrent tasks.
+            name: Optional name for the task.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The minimum result.
+        """
+        return await self.map(*instances, concurrency=concurrency, name=name, **kwargs).min(pop=True, sync=False)
+
+    async def _max(self, *instances: AnyIterable[I], concurrency: Optional[int] = None, name: str = "", **kwargs: P.kwargs) -> T:
+        """
+        Find the maximum result.
+
+        Args:
+            *instances: Iterable of instances to check.
+            concurrency: Optional maximum number of concurrent tasks.
+            name: Optional name for the task.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The maximum result.
+        """
+        return await self.map(*instances, concurrency=concurrency, name=name, **kwargs).max(pop=True, sync=False)
+
+    async def _sum(self, *instances: AnyIterable[I], concurrency: Optional[int] = None, name: str = "", **kwargs: P.kwargs) -> T:
+        """
+        Calculate the sum of results.
+
+        Args:
+            *instances: Iterable of instances to sum.
+            concurrency: Optional maximum number of concurrent tasks.
+            name: Optional name for the task.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The sum of the results.
+        """
+        return await self.map(*instances, concurrency=concurrency, name=name, **kwargs).sum(pop=True, sync=False)
+
+    def __init_subclass__(cls) -> None:
+        for attr in cls.__dict__.values():
+            if attr.__doc__ and "{cls}" in attr.__doc__:
+                attr.__doc__ = attr.__doc__.replace("{cls}", f":class:`{cls.__name__}`")
+        return super().__init_subclass__()

ez_a_sync-0.22.7/a_sync/a_sync/_flags.py

@@ -0,0 +1,59 @@
+"""
+This module provides functionality for handling synchronous and asynchronous flags
+in the ez-a-sync library.
+
+ez-a-sync uses 'flags' to indicate whether objects / function calls will be sync or async.
+
+You can use any of the provided flags, whichever makes most sense for your use case.
+"""
+
+from typing import Any
+
+from a_sync import exceptions
+
+AFFIRMATIVE_FLAGS = {'sync'}
+"""Set of flags indicating synchronous behavior."""
+
+NEGATIVE_FLAGS = {'asynchronous'}
+"""Set of flags indicating asynchronous behavior."""
+
+VIABLE_FLAGS = AFFIRMATIVE_FLAGS | NEGATIVE_FLAGS
+"""Set of all valid flags."""
+
+def negate_if_necessary(flag: str, flag_value: bool) -> bool:
+    """Negate the flag value if necessary based on the flag type.
+
+    Args:
+        flag: The flag to check.
+        flag_value: The value of the flag.
+
+    Returns:
+        The potentially negated flag value.
+
+    Raises:
+        :class:`exceptions.InvalidFlag`: If the flag is not recognized.
+    """
+    validate_flag_value(flag, flag_value)
+    if flag in AFFIRMATIVE_FLAGS:
+        return bool(flag_value)
+    elif flag in NEGATIVE_FLAGS:
+        return bool(not flag_value)
+    raise exceptions.InvalidFlag(flag)
+
+def validate_flag_value(flag: str, flag_value: Any) -> bool:
+    """
+    Validate that the flag value is a boolean.
+
+    Args:
+        flag: The flag being validated.
+        flag_value: The value to validate.
+
+    Returns:
+        The validated flag value.
+
+    Raises:
+        :class:`exceptions.InvalidFlagValue`: If the flag value is not a boolean.
+    """
+    if not isinstance(flag_value, bool):
+        raise exceptions.InvalidFlagValue(flag, flag_value)
+    return flag_value

{ez_a_sync-0.22.5 → ez_a_sync-0.22.7}/a_sync/a_sync/_helpers.py

@@ -1,3 +1,7 @@
+"""
+This module provides utility functions for handling asynchronous operations
+and converting synchronous functions to asynchronous ones.
+"""
 
 import asyncio
 import functools
@@ -9,6 +13,18 @@ from a_sync._typing import *
 
 
 def _await(awaitable: Awaitable[T]) -> T:
+    """
+    Await an awaitable object in a synchronous context.
+
+    Args:
+        awaitable: The awaitable object to be awaited.
+
+    Returns:
+        The result of the awaitable.
+
+    Raises:
+        :class:`exceptions.SyncModeInAsyncContextError`: If the event loop is already running.
+    """
     try:
         return a_sync.asyncio.get_event_loop().run_until_complete(awaitable)
     except RuntimeError as e:
@@ -17,6 +33,19 @@ def _await(awaitable: Awaitable[T]) -> T:
         raise
 
 def _asyncify(func: SyncFn[P, T], executor: Executor) -> CoroFn[P, T]:  # type: ignore [misc]
+    """
+    Convert a synchronous function to a coroutine function.
+
+    Args:
+        func: The synchronous function to be converted.
+        executor: The executor to run the synchronous function.
+
+    Returns:
+        A coroutine function wrapping the input function.
+
+    Raises:
+        :class:`exceptions.FunctionNotSync`: If the input function is already asynchronous.
+    """
     from a_sync.a_sync.function import ASyncFunction
     if asyncio.iscoroutinefunction(func) or isinstance(func, ASyncFunction):
         raise exceptions.FunctionNotSync(func)

ez_a_sync-0.22.7/a_sync/a_sync/_kwargs.py

@@ -0,0 +1,44 @@
+"""
+This module provides utility functions for handling keyword arguments related to synchronous and asynchronous flags.
+"""
+
+from typing import Optional
+
+from a_sync import exceptions
+from a_sync.a_sync import _flags
+
+
+def get_flag_name(kwargs: dict) -> Optional[str]:
+    """
+    Get the name of the flag present in the kwargs.
+
+    Args:
+        kwargs: A dictionary of keyword arguments.
+
+    Returns:
+        The name of the flag if present, None otherwise.
+
+    Raises:
+        :class:`exceptions.TooManyFlags`: If more than one flag is present in the kwargs.
+    """
+    present_flags = [flag for flag in _flags.VIABLE_FLAGS if flag in kwargs]
+    if len(present_flags) == 0:
+        return None
+    if len(present_flags) != 1:
+        raise exceptions.TooManyFlags('kwargs', present_flags)
+    return present_flags[0]
+
+def is_sync(flag: str, kwargs: dict, pop_flag: bool = False) -> bool:
+    """
+    Determine if the operation should be synchronous based on the flag value.
+
+    Args:
+        flag: The name of the flag to check.
+        kwargs: A dictionary of keyword arguments.
+        pop_flag: Whether to remove the flag from kwargs. Defaults to False.
+
+    Returns:
+        True if the operation should be synchronous, False otherwise.
+    """
+    flag_value = kwargs.pop(flag) if pop_flag else kwargs[flag]
+    return _flags.negate_if_necessary(flag, flag_value)

{ez_a_sync-0.22.5 → ez_a_sync-0.22.7}/a_sync/a_sync/abstract.py

@@ -29,6 +29,8 @@ class ASyncABC(metaclass=ASyncMeta):
     @functools.cached_property
     def __a_sync_instance_should_await__(self) -> bool:
         """
+        A flag indicating whether the instance should default to asynchronous execution.
+        
         You can override this if you want. 
         If you want to be able to hotswap instance modes, you can redefine this as a non-cached property.
         """

{ez_a_sync-0.22.5 → ez_a_sync-0.22.7}/a_sync/a_sync/base.py

@@ -1,4 +1,3 @@
-
 import functools
 import inspect
 import logging
@@ -14,10 +13,51 @@ logger = logging.getLogger(__name__)
 
 class ASyncGenericBase(ASyncABC):
     """
-    Inherit from this class to a-syncify all of your bound methods.
-    Allows for the use of a variety of flags out-of-box.
-    You can choose which flag(s) work best for your subclass implementation.
+    Base class for creating dual-function sync/async-capable classes without writing all your code twice.
+
+    This class provides the foundation for creating hybrid sync/async classes. It allows methods
+    and properties to be defined once and used in both synchronous and asynchronous contexts.
+
+    The class uses the :func:`a_sync` decorator internally to create dual-mode methods and properties.
+    Subclasses should define their methods as coroutines (using `async def`) where possible, and
+    use the `@a_sync.property` or `@a_sync.cached_property` decorators for properties that need to support both modes.
+
+    Example:
+        ```python
+        class MyClass(ASyncGenericBase):
+            def __init__(self, sync: bool):
+                self.sync = sync
+
+            @a_sync.property
+            async def my_property(self):
+                return await some_async_operation()
+
+            @a_sync
+            async def my_method(self):
+                return await another_async_operation()
+        
+        # Synchronous usage
+        obj = MyClass(sync=True)
+        sync_result = obj.my_property
+        sync_method_result = obj.my_method()
+
+        # Asynchronous usage
+        obj = MyClass(sync=False)
+        async_result = await obj.my_property
+        async_method_result = await obj.my_method()
+        ```
+
+    Note:
+        When subclassing, be aware that all async methods and properties will be
+        automatically wrapped to support both sync and async calls. This allows for
+        seamless usage in different contexts without changing the underlying implementation.
     """
+
+    def __init__(self):
+        if type(self) is ASyncGenericBase:
+            cls_name = type(self).__name__
+            raise NotImplementedError(f"You should not create instances of `{cls_name}` directly, you should subclass `ASyncGenericBase` instead.")
+                                  
     @functools.cached_property
     def __a_sync_flag_name__(self) -> str:
         logger.debug("checking a_sync flag for %s", self)
@@ -29,10 +69,10 @@ class ASyncGenericBase(ASyncABC):
             # Let's check the instance's atributes
             logger.debug("unable to find flag name using `%s.__init__` signature, checking for flag attributes defined on %s", self.__class__.__name__, self)
             present_flags = [flag for flag in _flags.VIABLE_FLAGS if hasattr(self, flag)]
-            if len(present_flags) == 0:
-                raise exceptions.NoFlagsFound(self)
+            if not present_flags:
+                raise exceptions.NoFlagsFound(self) from None
             if len(present_flags) > 1:
-                raise exceptions.TooManyFlags(self, present_flags)
+                raise exceptions.TooManyFlags(self, present_flags) from None
             flag = present_flags[0]
         if not isinstance(flag, str):
             raise exceptions.InvalidFlag(flag)
@@ -106,7 +146,7 @@ class ASyncGenericBase(ASyncABC):
     @classmethod
     def __parse_flag_name_from_list(cls, items: Dict[str, Any]) -> str:
         present_flags = [flag for flag in _flags.VIABLE_FLAGS if flag in items]
-        if len(present_flags) == 0:
+        if not present_flags:
             logger.debug("There are too many flags defined on %s", cls)
             raise exceptions.NoFlagsFound(cls, items.keys())
         if len(present_flags) > 1:

{ez_a_sync-0.22.5 → ez_a_sync-0.22.7}/a_sync/a_sync/config.py

@@ -1,3 +1,10 @@
+"""
+Configuration module for a_sync library.
+
+This module provides configuration options and default settings for the a_sync library.
+It includes functionality for setting up executors, defining default modifiers,
+and handling environment variable configurations.
+"""
 
 import functools
 import os
@@ -11,6 +18,15 @@ EXECUTOR_VALUE = int(os.environ.get("A_SYNC_EXECUTOR_VALUE", 8))
 
 @functools.lru_cache(maxsize=1)
 def get_default_executor() -> Executor:
+    """
+    Get the default executor based on the :obj:`EXECUTOR_TYPE` environment variable.
+
+    Returns:
+        Executor: An instance of either ProcessPoolExecutor or ThreadPoolExecutor.
+
+    Raises:
+        :class:`ValueError`: If an invalid EXECUTOR_TYPE is specified.
+    """
     if EXECUTOR_TYPE.lower().startswith('p'): # p, P, proc, Processes, etc
         return ProcessPoolExecutor(EXECUTOR_VALUE)
     elif EXECUTOR_TYPE.lower().startswith('t'): # t, T, thread, THREADS, etc