everysk-lib 1.10.2__cp312-cp312-win_amd64.whl

everysk/core/string.py

@@ -0,0 +1,199 @@
+###############################################################################
+#
+# (C) Copyright 2023 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+import re
+from typing import Any
+from re import compile as compile_re
+from importlib import import_module
+from unicodedata import normalize
+from six import string_types, ensure_str, text_type
+
+
+RE_ISIN = compile_re(r'^[a-zA-Z]{2}\s*[0-9a-zA-Z]{9}[0-9](?![0-9a-zA-Z-])$')
+
+
+###############################################################################
+#   Public Functions Implementation
+###############################################################################
+def import_from_string(dotted_path: str) -> type:
+    """
+    Import and return a Python class or module based on a dotted path.
+
+    Args:
+        dotted_path (str): The dotted path to the Python class or module.
+
+    Returns:
+        type: The imported Python class or module.
+
+    Raises:
+        ImportError: If the provided dotted path is invalid or if the class/module cannot be imported.
+
+    Example:
+        >>> import_from_string("module_name.ClassName")
+        <class 'module_name.ClassName'>
+    """
+    try:
+        module_path, class_name = dotted_path.rsplit(".", 1)
+    except ValueError as error:
+        raise ImportError(f"{dotted_path} doesn't look like a module path.") from error
+
+    module = import_module(module_path)
+    try:
+        return getattr(module, class_name)
+    except AttributeError as error:
+        raise ImportError(f'Module "{module_path}" does not define a "{class_name}" class.') from error
+
+def is_string_object(obj: Any) -> bool:
+    """
+    Check if the provided object is a string object.
+
+    Args:
+        obj (Any): The object to check.
+
+    Returns:
+        bool: True if the object is a string, False otherwise.
+
+    Example:
+        >>> from everysk.core.string import is_string_object
+        >>> is_string_object('Hello, World!')
+        >>> True
+
+        >>> is_string_object(42)
+        >>> False
+    """
+    return isinstance(obj, string_types)
+
+def to_string(value: str) -> str:
+    """
+    Convert a value to a string representation.
+
+    Args:
+        value (str): The value to convert to a string.
+
+    Returns:
+        str: The string representation of the value.
+
+    Example:
+        Convert a value to a string:
+        >>> to_string(42)
+        '42'
+    """
+    if is_string_object(value):
+        return ensure_str(value)
+    return text_type(value)
+
+def normalize_string(value: str):
+    """
+    Normalize a string by applying Unicode normalization (NFKD).
+
+    Args:
+        value (str): The string to normalize.
+
+    Returns:
+        str: The normalized string.
+
+    Example:
+        >>> from everysk.core.string import normalize_string
+        >>> result = normalize_string("Café")
+        >>> print(result)
+        >>> "Cafe"
+
+    """
+    value = normalize('NFKD', value)
+    return value
+
+def normalize_string_to_search(value):
+    """
+    Normalize a string for search purposes by lowercasing and applying Unicode normalization (NFKD).
+
+    Args:
+        value: The string to normalize.
+
+    Returns:
+        str: The normalized and lowercase string suitable for searching.
+    """
+    value = value.lower().strip()
+    value = to_string(value)
+    return normalize_string(value)
+
+def is_isin_string_regex(isin: str) -> bool:
+    """
+    Check if a provided string matches the ISIN (International Securities Identification Number) format using regex.
+
+    Args:
+        isin (str): The string to check.
+
+    Returns:
+        bool: True if the string matches the ISIN format, False otherwise.
+
+    Example:
+        >>> from everysk.core.string import is_isin_string_regex
+        >>> result = is_isin_string_regex("US0378331005")
+        >>> print(result)
+        >>> True
+    """
+    if not isinstance(isin, string_types):
+        return False
+    return True if RE_ISIN.match(isin) else False
+
+def pluralize(string: str) -> str:
+    """
+    Transform the string into its pluralized version.
+
+    Args:
+        string (str): The string that we want to pluralize.
+
+    Example:
+        >>> from.everysk.core.string import pluralize
+        >>> pluralize('study')
+        'studies'
+
+        >>> pluralize('class')
+        'classes'
+
+        >>> pluralize('tax')
+        'taxes'
+
+        >>> pluralize('system')
+        'systems'
+
+    Returns:
+        string (str): The pluralized version of the string
+    """
+    if string[-1] in ('s', 'x'):
+        string += 'es'
+    elif string[-1] in ('y'):
+        string = string[:-1] + 'ies'
+    else:
+        string += 's'
+    return string
+
+def snake_case(string: str) -> str:
+    """
+    Convert the current string into the snake case format.
+
+    Args:
+        string (str): The string for conversion
+
+    Example:
+        >>> from everysk.core.string import snake_case
+        >>> snake_case('CustomIndex')
+        'custom_index'
+
+        >>> snake_case('Security')
+        'security'
+
+        >>> snake_case('ClassOrObjectByTest')
+        'class_or_object_by_test'
+
+    Returns:
+        string (str): The string converted to to snake case format
+    """
+    _snake_case = re.compile(r'(?<!^)(?=[A-Z])')
+    return _snake_case.sub('_', string).lower()

everysk/core/tests.py

@@ -0,0 +1,240 @@
+###############################################################################
+#
+# (C) Copyright 2023 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+# ruff: noqa: F401
+
+## Remember to prefix all import with EveryskLib to avoid clash with other tests
+
+## Cloud function Test Cases
+try:
+    from everysk.core.cloud_function.tests import CloudFunctionTestCase as EveryskLibCloudFunctionTestCase
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if redis is not installed
+    if not error.args[0].startswith("No module named 'redis'"):
+        raise
+
+## Compress Test Cases
+from everysk.core._tests.compress import CompressGzipJsonTestCase as EveryskLibCompressGzipJsonTestCase
+from everysk.core._tests.compress import CompressGzipPickleTestCase as EveryskLibCompressGzipPickleTestCase
+from everysk.core._tests.compress import CompressTestCase as EveryskLibCompressTestCase
+from everysk.core._tests.compress import CompressZlibJsonTestCase as EveryskLibCompressZlibJsonTestCase
+from everysk.core._tests.compress import CompressZlibPickleTestCase as EveryskLibCompressZlibPickleTestCase
+from everysk.core._tests.compress import FileHandlingTestCase as EveryskLibFileHandlingTestCase
+
+## Config Test Cases
+from everysk.core._tests.config import SettingsManagerTestCase as EveryskLibSettingsManagerTestCase
+from everysk.core._tests.config import SettingsModulesTestCase as EveryskLibSettingsModulesTestCase
+from everysk.core._tests.config import SettingsTestCase as EveryskLibSettingsTestCase
+
+## Exceptions Test Cases
+from everysk.core._tests.exceptions import BaseExceptionTestCase as EveryskLibBaseExceptionTestCase
+from everysk.core._tests.exceptions import DefaultErrorTestCase as EveryskLibDefaultErrorTestCase
+from everysk.core._tests.exceptions import FieldValueErrorTestCase as EveryskLibFieldValueErrorTestCase
+from everysk.core._tests.exceptions import HandledExceptionTestCase as EveryskLibHandledExceptionTestCase
+from everysk.core._tests.exceptions import HttpErrorTestCase as EveryskLibHttpErrorTestCase
+from everysk.core._tests.exceptions import ReadonlyErrorTestCase as EveryskLibReadonlyErrorTestCase
+from everysk.core._tests.exceptions import RequiredErrorTestCase as EveryskLibRequiredErrorTestCase
+from everysk.core._tests.exceptions import SDKExceptionsTestCase as EveryskLibSDKExceptionsTestCase
+from everysk.core._tests.exceptions import TestAPIError as EveryskLibTestAPIError
+
+## Fields Test Cases
+from everysk.core._tests.fields import BoolFieldTestCase as EveryskLibBoolFieldTestCase
+from everysk.core._tests.fields import ChoiceFieldTestCase as EveryskLibChoiceFieldTestCase
+from everysk.core._tests.fields import COD3770TestCase as EveryskLibCOD3770TestCase
+from everysk.core._tests.fields import DateFieldTestCase as EveryskLibDateFieldTestCase
+from everysk.core._tests.fields import DateTimeFieldTestCase as EveryskLibDateTimeFieldTestCase
+from everysk.core._tests.fields import DictFieldTestCase as EveryskLibDictFieldTestCase
+from everysk.core._tests.fields import EmailFieldTestCase as EveryskLibEmailFieldTestCase
+from everysk.core._tests.fields import FieldTestCase as EveryskLibFieldTestCase
+from everysk.core._tests.fields import FieldUndefinedTestCase as EveryskLibFieldUndefinedTestCase
+from everysk.core._tests.fields import FloatFieldTestCase as EveryskLibFloatFieldTestCase
+from everysk.core._tests.fields import IntFieldTestCase as EveryskLibIntFieldTestCase
+from everysk.core._tests.fields import IteratorFieldTestCase as EveryskLibIteratorFieldTestCase
+from everysk.core._tests.fields import ListFieldTestCase as EveryskLibListFieldTestCase
+from everysk.core._tests.fields import ObjectInitPropertyTestCase as EveryskLibObjectInitPropertyTestCase
+from everysk.core._tests.fields import SetFieldTestCase as EveryskLibSetFieldTestCase
+from everysk.core._tests.fields import StrFieldTestCase as EveryskLibStrFieldTestCase
+from everysk.core._tests.fields import TupleFieldTestCase as EveryskLibTupleFieldTestCase
+from everysk.core._tests.fields import URLFieldTestCase as EveryskLibURLFieldTestCase
+
+## Date, DateTime Test Cases
+from everysk.core.datetime.tests.calendar import CalendarTestCase as EveryskLibCalendarTestCase
+from everysk.core.datetime.tests.date import DateTestCase as EveryskLibDateTestCase
+from everysk.core.datetime.tests.date_mixin import GetHolidaysTestCase as EveryskLibDateMixinGetHolidaysTestCase
+from everysk.core.datetime.tests.datetime import DateTimeTestCase as EveryskLibDateTimeTestCase
+
+## Firestore Test Cases
+try:
+    from everysk.core._tests.firestore import (
+        BaseDocumentCachedConfigTestCase as EveryskLibBaseDocumentCachedConfigTestCase,
+    )
+    from everysk.core._tests.firestore import BaseDocumentConfigTestCase as EveryskLibBaseDocumentConfigTestCase
+    from everysk.core._tests.firestore import DocumentCachedTestCase as EveryskLibDocumentCachedTestCase
+    from everysk.core._tests.firestore import DocumentTestCase as EveryskLibDocumentTestCase
+    from everysk.core._tests.firestore import FirestoreClientTestCase as EveryskLibFirestoreClientTestCase
+    from everysk.core._tests.firestore import LoadsPaginatedTestCase as EveryskLibLoadsPaginatedTestCase
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if google-cloud-firestore is not installed
+    if not error.args[0].startswith("No module named 'google"):
+        raise
+
+## Http Test Cases
+try:
+    from everysk.core._tests.http import HttpConnectionConfigTestCase as EveryskLibHttpConnectionConfigTestCase
+    from everysk.core._tests.http import HttpConnectionTestCase as EveryskLibHttpConnectionTestCase
+    from everysk.core._tests.http import HttpDELETEConnectionTestCase as EveryskLibHttpDELETEConnectioNTestCase
+    from everysk.core._tests.http import HttpGETConnectionTestCase as EveryskLibHttpGETConnectionTestCase
+    from everysk.core._tests.http import HttpHEADConnectionTestCase as EveryskLibHttpHEADConnectionTestCase
+    from everysk.core._tests.http import HttpOPTIONSConnectionTestCase as EveryskLibHttpOPTIONSConnectionTestCase
+    from everysk.core._tests.http import HttpPATCHConnectionTestCase as EveryskLibHttpPATCHConnectionTestCase
+    from everysk.core._tests.http import (
+        HttpPOSTCompressedConnectionTestCase as EveryskLibHttpPOSTCompressedConnectionTestCase,
+    )
+    from everysk.core._tests.http import HttpPOSTConnectionTestCase as EveryskLibHttpPOSTConnectionTestCase
+    from everysk.core._tests.http import HttpPUTConnectionTestCase as EveryskLibHttpPUTCompressedConnectionTestCase
+    from everysk.core._tests.http import HttpSDKPOSTConnectionTestCase as EveryskLibHttpSDKPOSTConnectionTestCase
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if requests is not installed
+    if not error.args[0].startswith("No module named 'requests'"):
+        raise
+
+## Lists Test Cases
+from everysk.core._tests.lists import SlicesTestCase as EveryskLibSlicesTestCase
+from everysk.core._tests.lists import SortListDictTestCase as EveryskLibSortListDictTestCase
+from everysk.core._tests.lists import SplitInSlicesTestCase as EveryskLibSplitInSlicesTestCase
+
+## Log Test Cases
+from everysk.core._tests.log import LoggerExtraDataTestCase as EveryskLibLoggerExtraDataTestCase
+from everysk.core._tests.log import LoggerFormatterTestCase as EveryskLibLoggerFormatterTestCase
+from everysk.core._tests.log import LoggerJsonTestCase as EveryskLibLoggerJsonTestCase
+from everysk.core._tests.log import LoggerManagerTestCase as EveryskLibLoggerManagerTestCase
+from everysk.core._tests.log import LoggerMethodsTestCase as EveryskLibLoggerMethodsTestCase
+from everysk.core._tests.log import LoggerStackLevelTestCase as EveryskLibLoggerStackLevelTestCase
+from everysk.core._tests.log import LoggerStdoutTestCase as EveryskLibLoggerStdoutTestCase
+from everysk.core._tests.log import LoggerTestCase as EveryskLibLoggerTestCase
+from everysk.core._tests.log import LoggerTraceTestCase as EveryskLibLogTraceTestCase
+
+try:
+    # We need requests to run this test
+    from everysk.core._tests.log import LoggerSlackTestCase as EveryskLibLoggerSlackTestCase
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if requests is not installed
+    if not error.args[0].startswith("No module named 'requests'"):
+        raise
+
+## Number Test Cases
+from everysk.core._tests.number import NumberTestCase as EveryskLibNumberTestCase
+
+## Object Test Cases
+from everysk.core._tests.object import AfterInitTestCase as EveryskLibAfterInitTestCase
+from everysk.core._tests.object import BaseDictPropertyTestCase as EveryskLibBaseDictPropertyTestCase
+from everysk.core._tests.object import BaseDictSuperTestCase as EveryskLibBaseDictSuperTestCase
+from everysk.core._tests.object import BaseDictTestCase as EveryskLibBaseDictTestCase
+from everysk.core._tests.object import BaseFieldTestCase as EveryskLibBaseFieldTestCase
+from everysk.core._tests.object import BaseObjectTestCase as EveryskLibBaseObjectTestCase
+from everysk.core._tests.object import BeforeInitTestCase as EveryskLibBeforeInitTestCase
+from everysk.core._tests.object import ConfigHashTestCase as EveryskLibConfigHashTestCase
+from everysk.core._tests.object import FrozenDictTestCase as EveryskLibFrozenDictTestCase
+from everysk.core._tests.object import FrozenObjectTestCase as EveryskLibFrozenObjectTestCase
+from everysk.core._tests.object import MetaClassAttributesTestCase as EveryskLibMetaClassAttributesTestCase
+from everysk.core._tests.object import MetaClassConfigTestCase as EveryskLibMetaClassConfigTestCase
+from everysk.core._tests.object import NpArrayTestCase as EveryskLibNpArrayTestCase
+from everysk.core._tests.object import RequiredTestCase as EveryskLibRequiredTestCase
+from everysk.core._tests.object import SilentTestCase as EveryskLibSilentTestCase
+from everysk.core._tests.object import TypingCheckingTestCase as EveryskLibTypingCheckingTestCase
+from everysk.core._tests.object import ValidateTestCase as EveryskLibValidateTestCase
+
+## Redis Test Cases
+try:
+    from everysk.core._tests.redis import CacheDecoratorTestCase as EveryskLibCacheDecoratorTestCase
+    from everysk.core._tests.redis import RedisCacheCompressedTestCase as EveryskLibRedisCacheCompressedTestCase
+    from everysk.core._tests.redis import RedisCacheGetSetTestCase as EveryskLibRedisCacheGetSetTestCase
+    from everysk.core._tests.redis import RedisCacheTestCase as EveryskLibRedisCacheTestCase
+    from everysk.core._tests.redis import RedisChannelTestCase as EveryskLibRedisChannelTestCase
+    from everysk.core._tests.redis import RedisClientTestCase as EveryskLibRedisClientTestCase
+    from everysk.core._tests.redis import RedisListTestCase as EveryskLibRedisListTestCase
+    from everysk.core._tests.redis import RedisLockTestCase as EveryskLibRedisLockTestCase
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if redis is not installed
+    if not error.args[0].startswith("No module named 'redis'"):
+        raise
+
+## Retry Test Cases
+from everysk.core._tests.retry import RetryTestCase as EveryskLibRetryTestCase
+
+## Serialize Test Cases
+from everysk.core._tests.serialize.test_json import SerializeJsonDumpsTestCase as EveryskLibSerializeJsonDumpsTestCase
+from everysk.core._tests.serialize.test_json import SerializeJsonLoadsTestCase as EveryskLibSerializeJsonLoadsTestCase
+from everysk.core._tests.serialize.test_pickle import (
+    SerializePickleDumpsTestCase as EveryskLibSerializePickleDumpsTestCase,
+)
+from everysk.core._tests.serialize.test_pickle import (
+    SerializePickleLoadsTestCase as EveryskLibSerializePickleLoadsTestCase,
+)
+
+try:
+    from everysk.core._tests.serialize.test_orjson import (
+        SerializeOrjsonDumpsTestCase as EveryskLibSerializeOrjsonDumpsTestCase,
+    )
+    from everysk.core._tests.serialize.test_orjson import (
+        SerializeOrjsonLoadsTestCase as EveryskLibSerializeOrjsonLoadsTestCase,
+    )
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if orjson is not installed
+    if not error.args[0].startswith("No module named 'orjson'"):
+        raise
+
+## SFTP Test Cases
+try:
+    from everysk.core._tests.sftp import KnownHostsTestCase as EveryskLibKnownHostsTestCase
+    from everysk.core._tests.sftp import SFTPTestCase as EveryskLibSFTPTestCase
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if Paramiko is not installed
+    if not error.args[0].startswith("No module named 'paramiko'"):
+        raise
+
+## Signing Test Cases
+from everysk.core._tests.signing import SignTestCase as EveryskLibSignTestCase
+from everysk.core._tests.signing import UnsignTestCase as EveryskLibUnsignTestCase
+
+## String Test Cases
+from everysk.core._tests.string import StringTestCase as EveryskLibStringTestCase
+
+## Slack Test Cases
+try:
+    from everysk.core._tests.slack import SlackTestCase as EveryskLibSlackTestCase
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if requests is not installed
+    if not error.args[0].startswith("No module named 'requests'"):
+        raise
+
+
+## Thread Test Cases
+from everysk.core._tests.threads import ThreadPoolTestCase as EveryskLibThreadPoolTestCase
+from everysk.core._tests.threads import ThreadTestCase as EveryskLibThreadTestCase
+
+## Undefined Test Cases
+from everysk.core._tests.undefined import UndefinedTestCase as EveryskLibUndefinedTestCase
+
+## Unittest Test Cases
+from everysk.core._tests.unittests import SDKUnittestTestCase as EveryskLibSDKUnittestTestCase
+
+## Utils Test Cases
+from everysk.core._tests.utils import BoolConverterTestCase as EveryskLibBoolConverterTestCase
+from everysk.core._tests.utils import SearchKeyTestCase as EveryskLibSearchKeyTestCase
+
+## Workers Test Cases
+try:
+    from everysk.core._tests.workers import BaseGoogleTestCase as EveryskLibBaseGoogleTestCase
+    from everysk.core._tests.workers import TaskGoogleTestCase as EveryskLibTaskGoogleTestCase
+    from everysk.core._tests.workers import WorkerGoogleTestCase as EveryskLibWorkerGoogleTestCase
+except ModuleNotFoundError as error:
+    # This will prevent running these tests if google-cloud-tasks is not installed
+    if not error.args[0].startswith("No module named 'google"):
+        raise

everysk/core/threads.py

@@ -0,0 +1,199 @@
+###############################################################################
+#
+# (C) Copyright 2023 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+from concurrent.futures import ThreadPoolExecutor, Future, wait
+from contextvars import Context, copy_context
+from typing import Any
+
+from everysk.core.log import Logger
+from everysk.core.object import BaseObject
+
+
+log = Logger(name='everysk-thread-error-log')
+
+
+###############################################################################
+#   Thread Class Implementation
+###############################################################################
+class Thread(BaseObject):
+    ## Private attributes
+    _pool: 'ThreadPool' = None
+
+    ## Public attributes
+    args: tuple = None
+    kwargs: dict = None
+    target: callable = None
+
+    def __init__(self, target: callable, args: tuple = (), kwargs: dict = None):
+        """
+        Use to execute the target inside a Thread and do parallel process.
+        This differs from the Python Threads for the capacity to use contextVars
+        and return the result.
+        AnOther ability
+
+        Args:
+            target (callable): The function that will be executed.
+            args (tuple, optional): The args attributes to be sent to the function. Defaults to ().
+            kwargs (dict, optional): The args attributes to be sent to the function. Defaults to None.
+
+        Example:
+            >>> from everysk.core.threads import Thread
+            >>> def sum(a, b):
+            ...     return a + b
+            ...
+            >>> thread = Thread(target=sum, args=(1, 2))
+            >>> thread.start()
+            >>> thread.join()
+            3
+            >>> thread = Thread(target=sum, kwargs={'a': 1, 'b': 2})
+            >>> thread.start()
+            >>> thread.join()
+            3
+        """
+        super().__init__(target=target, args=args, kwargs=kwargs)
+        if self.kwargs is None:
+            self.kwargs = {}
+
+        self._pool = ThreadPool(concurrency=1, silent=True)
+
+    def join(self) -> Any | None:
+        """
+        Wait for the Thread to finish and returns the result.
+        """
+        self._pool.wait()
+        return self._pool.results[0]
+
+    def run(self) -> Any:
+        """
+        The method used to run the target inside the Thread.
+        """
+        self._pool.add(target=self.target, args=self.args, kwargs=self.kwargs)
+
+    def start(self) -> None:
+        """
+        The method used to start the Thread.
+        """
+        self.run()
+
+
+###############################################################################
+#   ThreadPool Class Implementation
+###############################################################################
+class ThreadPool(ThreadPoolExecutor):
+    context: Context = None
+    default_error_value: Any = Undefined
+    futures: list[Future] = None
+    results: list = None
+    silent: bool = True
+
+    def __init__(self, concurrency: int | None = None, silent: bool = True, default_error_value: Any = Undefined) -> None:
+        """
+        ThreadPool is a queue to execute threads and control the concurrency.
+        If some error occur inside a Thread, we raise the exception or just log the exception.
+        If concurrency is not passed, then the default value is min(32, os.cpu_count() + 4).
+
+        Args:
+            concurrency (int | None, optional): The number of Threads that will be running simultaneously. Defaults to None.
+            silent (bool, optional): To log the error or raise. Defaults to True.
+            default_error (Any, optional): The default value to be stored as result if an error occur. Defaults to Undefined.
+
+        Example:
+
+            >>> from time import sleep
+            >>> from everysk.core.datetime import DateTime
+            >>> from everysk.core.threads import ThreadPool
+
+            >>> def sum(a: int, b: int) -> int:
+            ...     print(DateTime.now().strftime('%H:%M:%S'))
+            ...     sleep(1)
+            ...     return a + b
+
+            >>> pool = ThreadPool(6)
+            >>> for i in range(0, 6):
+            ...     pool.add(target=sum, args=(i, i))
+            >>> pool.wait()
+            19:24:22
+            19:24:22
+            19:24:22
+            19:24:22
+            19:24:22
+            19:24:22
+            >>> pool.results
+            [0, 2, 4, 6, 8, 10]
+
+            >>> pool = ThreadPool(2)
+            >>> for i in range(0, 6):
+            ...     pool.add(target=sum, args=(i,i))
+            >>> pool.wait()
+            19:25:09
+            19:25:09
+            19:25:10
+            19:25:10
+            19:25:11
+            19:25:11
+            >>> pool.results
+            [0, 2, 4, 6, 8, 10]
+        """
+        self.context = copy_context()
+        self.futures = []
+        self.results = []
+        self.silent = silent
+        self.default_error_value = default_error_value
+        super().__init__(concurrency, initializer=self._set_child_context)
+
+    def _set_child_context(self) -> None:
+        """ Used to pass the context values to the child Threads. """
+        for var, value in self.context.items():
+            var.set(value)
+
+    def add(self, target: callable, args: tuple = (), kwargs: dict = None) -> None:
+        """
+        Add the target to the queue to be processed later in a Thread.
+
+        Args:
+            target (callable): The function that will be executed in the Thread.
+            args (tuple, optional): The arguments that are needed to this function. Defaults to ().
+            kwargs (dict, optional): The keyword arguments that are needed to this function. Defaults to None.
+        """
+        if kwargs is None:
+            kwargs = {}
+
+        future = self.submit(target, *args, **kwargs)
+        # We add these info on the future to be used later if some error occur
+        future.target = target
+        future.args = args
+        future.kwargs = kwargs
+
+        self.futures.append(future)
+
+    def wait(self) -> None:
+        """ This method is used to wait for all threads to complete and generate the results. """
+        wait(self.futures)
+
+        for future in self.futures:
+            try:
+                self.results.append(future.result())
+            except Exception as error: # pylint: disable=broad-exception-caught
+                if self.silent:
+                    self.results.append(self.default_error_value)
+                    log.error(
+                        'Thread execution error -> target: %s',
+                        future.target.__name__,
+                        extra={
+                            'labels': {
+                                'args': future.args,
+                                'kwargs': future.kwargs,
+                            }
+                        }
+                    )
+                else:
+                    raise error
+
+        # This is a Garbage Collector for the ThreadPool
+        self.shutdown()