everysk-lib 1.9.8__cp312-cp312-musllinux_1_2_x86_64.whl → 1.9.9__cp312-cp312-musllinux_1_2_x86_64.whl

everysk/core/retry.py

@@ -0,0 +1,51 @@
+###############################################################################
+#
+# (C) Copyright 2025 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 typing import Any
+
+from everysk.config import settings
+from everysk.core.log import Logger
+
+log = Logger('everysk-lib-core-retry')
+
+
+def retry(
+    func: callable, params: dict, retry_count: int = 0, retries: int = 5, exceptions: tuple | Exception = Exception
+) -> Any:
+    """
+    Retries a function call a number of times if it raises an exception.
+
+    Args:
+        func (callable): The function to be called.
+        params (dict): The parameters to be passed to the function.
+        retry_count (int, optional): The current retry count. Defaults to 0.
+        retries (int, optional): The maximum number of retries. Defaults to 5.
+        exceptions (tuple | Exception, optional): The exceptions to catch. Defaults to Exception.
+
+    Raises:
+        Exception: If the maximum number of retries is reached.
+    """
+    try:
+        return func(**params)
+    except exceptions:
+        if retry_count < retries:
+            if settings.RETRY_SHOW_LOGS:
+                msg = f'Retry {retry_count + 1} of {retries} for function {func.__name__} due to exception.'
+                log.warning(
+                    msg,
+                    extra={
+                        'function': func.__name__,
+                        'params': params,
+                        'retry_count': retry_count + 1,
+                        'max_retries': retries,
+                    },
+                )
+            return retry(func, params, retry_count + 1, retries, exceptions)
+
+        raise

everysk/core/tests.py

@@ -7,7 +7,7 @@
 # without authorization of EVERYSK TECHNOLOGIES is prohibited.
 #
 ###############################################################################
-# pylint: disable=unused-import
+# ruff: noqa: F401
 
 ## Remember to prefix all import with EveryskLib to avoid clash with other tests
 
@@ -17,200 +17,194 @@ try:
 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 error
+        raise
 
 ## Compress Test Cases
-from everysk.core._tests.compress import (
-    CompressTestCase as EveryskLibCompressTestCase,
-    CompressGzipJsonTestCase as EveryskLibCompressGzipJsonTestCase,
-    CompressGzipPickleTestCase as EveryskLibCompressGzipPickleTestCase,
-    CompressZlibJsonTestCase as EveryskLibCompressZlibJsonTestCase,
-    CompressZlibPickleTestCase as EveryskLibCompressZlibPickleTestCase,
-    FileHandlingTestCase as EveryskLibFileHandlingTestCase
-)
+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 (
-    SettingsModulesTestCase as EveryskLibSettingsModulesTestCase,
-    SettingsTestCase as EveryskLibSettingsTestCase,
-    SettingsManagerTestCase as EveryskLibSettingsManagerTestCase
-)
-
-## Date, DateTime Test Cases
-from everysk.core.datetime.tests.date import DateTestCase as EveryskLibDateTestCase
-from everysk.core.datetime.tests.datetime import DateTimeTestCase as EveryskLibDateTimeTestCase
-from everysk.core.datetime.tests.date_mixin import GetHolidaysTestCase as EveryskLibDateMixinGetHolidaysTestCase
-from everysk.core.datetime.tests.calendar import CalendarTestCase as EveryskLibCalendarTestCase
+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,
-    DefaultErrorTestCase as EveryskLibDefaultErrorTestCase,
-    HttpErrorTestCase as EveryskLibHttpErrorTestCase,
-    FieldValueErrorTestCase as EveryskLibFieldValueErrorTestCase,
-    ReadonlyErrorTestCase as EveryskLibReadonlyErrorTestCase,
-    RequiredErrorTestCase as EveryskLibRequiredErrorTestCase,
-    TestAPIError as EveryskLibTestAPIError,
-    HandledExceptionTestCase as EveryskLibHandledExceptionTestCase,
-    SDKExceptionsTestCase as EveryskLibSDKExceptionsTestCase
-)
+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,
-    ChoiceFieldTestCase as EveryskLibChoiceFieldTestCase,
-    DateFieldTestCase as EveryskLibDateFieldTestCase,
-    DateTimeFieldTestCase as EveryskLibDateTimeFieldTestCase,
-    DictFieldTestCase as EveryskLibDictFieldTestCase,
-    FieldTestCase as EveryskLibFieldTestCase,
-    FieldUndefinedTestCase as EveryskLibFieldUndefinedTestCase,
-    FloatFieldTestCase as EveryskLibFloatFieldTestCase,
-    IntFieldTestCase as EveryskLibIntFieldTestCase,
-    IteratorFieldTestCase as EveryskLibIteratorFieldTestCase,
-    ListFieldTestCase as EveryskLibListFieldTestCase,
-    StrFieldTestCase as EveryskLibStrFieldTestCase,
-    TupleFieldTestCase as EveryskLibTupleFieldTestCase,
-    ObjectInitPropertyTestCase as EveryskLibObjectInitPropertyTestCase,
-    COD3770TestCase as EveryskLibCOD3770TestCase,
-    URLFieldTestCase as EveryskLibURLFieldTestCase,
-    SetFieldTestCase as EveryskLibSetFieldTestCase,
-    EmailFieldTestCase as EveryskLibEmailFieldTestCase
-)
+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,
-        BaseDocumentConfigTestCase as EveryskLibBaseDocumentConfigTestCase,
-        DocumentCachedTestCase as EveryskLibDocumentCachedTestCase,
-        DocumentTestCase as EveryskLibDocumentTestCase,
-        FirestoreClientTestCase as EveryskLibFirestoreClientTestCase,
-        LoadsPaginatedTestCase as EveryskLibLoadsPaginatedTestCase
     )
+    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 error
+        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 (
-        HttpConnectionTestCase as EveryskLibHttpConnectionTestCase,
-        HttpConnectionConfigTestCase as EveryskLibHttpConnectionConfigTestCase,
-        HttpGETConnectionTestCase as EveryskLibHttpGETConnectionTestCase,
-        HttpPOSTConnectionTestCase as EveryskLibHttpPOSTConnectionTestCase,
-        HttpSDKPOSTConnectionTestCase as EveryskLibHttpSDKPOSTConnectionTestCase,
         HttpPOSTCompressedConnectionTestCase as EveryskLibHttpPOSTCompressedConnectionTestCase,
-        HttpDELETEConnectionTestCase as EveryskLibHttpDELETEConnectioNTestCase,
-        HttpHEADConnectionTestCase as EveryskLibHttpHEADConnectionTestCase,
-        HttpOPTIONSConnectionTestCase as EveryskLibHttpOPTIONSConnectionTestCase,
-        HttpPATCHConnectionTestCase as EveryskLibHttpPATCHConnectionTestCase,
-        HttpPUTConnectionTestCase as EveryskLibHttpPUTCompressedConnectionTestCase
     )
+    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 error
+        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,
-    LoggerFormatterTestCase as EveryskLibLoggerFormatterTestCase,
-    LoggerJsonTestCase as EveryskLibLoggerJsonTestCase,
-    LoggerManagerTestCase as EveryskLibLoggerManagerTestCase,
-    LoggerMethodsTestCase as EveryskLibLoggerMethodsTestCase,
-    LoggerStackLevelTestCase as EveryskLibLoggerStackLevelTestCase,
-    LoggerStdoutTestCase as EveryskLibLoggerStdoutTestCase,
-    LoggerTestCase as EveryskLibLoggerTestCase,
-    LoggerTraceTestCase as EveryskLibLogTraceTestCase,
-)
+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:
-    from everysk.core._tests.log import LoggerSlackTestCase as EveryskLibLoggerSlackTestCase # We need requests to run this test
+    # 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 error
-
-
-## Object Test Cases
-from everysk.core._tests.object import (
-    BaseDictPropertyTestCase as EveryskLibBaseDictPropertyTestCase,
-    BaseDictTestCase as EveryskLibBaseDictTestCase,
-    BaseFieldTestCase as EveryskLibBaseFieldTestCase,
-    BaseObjectTestCase as EveryskLibBaseObjectTestCase,
-    ConfigHashTestCase as EveryskLibConfigHashTestCase,
-    FrozenDictTestCase as EveryskLibFrozenDictTestCase,
-    FrozenObjectTestCase as EveryskLibFrozenObjectTestCase,
-    MetaClassConfigTestCase as EveryskLibMetaClassConfigTestCase,
-    RequiredTestCase as EveryskLibRequiredTestCase,
-    ValidateTestCase as EveryskLibValidateTestCase,
-    MetaClassAttributesTestCase as EveryskLibMetaClassAttributesTestCase,
-    NpArrayTestCase as EveryskLibNpArrayTestCase,
-    AfterInitTestCase as EveryskLibAfterInitTestCase,
-    BeforeInitTestCase as EveryskLibBeforeInitTestCase,
-    SilentTestCase as EveryskLibSilentTestCase,
-    TypingCheckingTestCase as EveryskLibTypingCheckingTestCase,
-    BaseDictSuperTestCase as EveryskLibBaseDictSuperTestCase
-)
+        raise
 
 ## Number Test Cases
 from everysk.core._tests.number import NumberTestCase as EveryskLibNumberTestCase
 
-## Signing Test Cases
-from everysk.core._tests.signing import (
-    SignTestCase as EveryskLibSignTestCase,
-    UnsignTestCase as EveryskLibUnsignTestCase
-)
-
-## String Test Cases
-from everysk.core._tests.string import StringTestCase as EveryskLibStringTestCase
+## 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 (
-        RedisCacheCompressedTestCase as EveryskLibRedisCacheCompressedTestCase,
-        RedisCacheTestCase as EveryskLibRedisCacheTestCase,
-        RedisChannelTestCase as EveryskLibRedisChannelTestCase,
-        RedisClientTestCase as EveryskLibRedisClientTestCase,
-        RedisListTestCase as EveryskLibRedisListTestCase,
-        RedisLockTestCase as EveryskLibRedisLockTestCase,
-        RedisCacheGetSetTestCase as EveryskLibRedisCacheGetSetTestCase,
-        CacheDecoratorTestCase as EveryskLibCacheDecoratorTestCase
-    )
+    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 error
+        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,
-    SerializeJsonLoadsTestCase as EveryskLibSerializeJsonLoadsTestCase
-)
+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,
-    SerializePickleLoadsTestCase as EveryskLibSerializePickleLoadsTestCase
 )
+from everysk.core._tests.serialize.test_pickle import (
+    SerializePickleLoadsTestCase as EveryskLibSerializePickleLoadsTestCase,
+)
+
 try:
     from everysk.core._tests.serialize.test_orjson import (
         SerializeOrjsonDumpsTestCase as EveryskLibSerializeOrjsonDumpsTestCase,
-        SerializeOrjsonLoadsTestCase as EveryskLibSerializeOrjsonLoadsTestCase
+    )
+    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 error
+        raise
 
 ## SFTP Test Cases
 try:
-    from everysk.core._tests.sftp import (
-        KnownHostsTestCase as EveryskLibKnownHostsTestCase,
-        SFTPTestCase as EveryskLibSFTPTestCase
-    )
+    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 error
+        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:
@@ -218,14 +212,12 @@ try:
 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 error
+        raise
 
 
 ## Thread Test Cases
-from everysk.core._tests.threads import (
-    ThreadPoolTestCase as EveryskLibThreadPoolTestCase,
-    ThreadTestCase as EveryskLibThreadTestCase
-)
+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
@@ -234,26 +226,15 @@ from everysk.core._tests.undefined import UndefinedTestCase as EveryskLibUndefin
 from everysk.core._tests.unittests import SDKUnittestTestCase as EveryskLibSDKUnittestTestCase
 
 ## Utils Test Cases
-from everysk.core._tests.utils import (
-    BoolConverterTestCase as EveryskLibBoolConverterTestCase,
-    SearchKeyTestCase as EveryskLibSearchKeyTestCase
-)
-
-## Lists Test Cases
-from everysk.core._tests.lists import (
-    SplitInSlicesTestCase as EveryskLibSplitInSlicesTestCase,
-    SlicesTestCase as EveryskLibSlicesTestCase,
-    SortListDictTestCase as EveryskLibSortListDictTestCase
-)
+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,
-        TaskGoogleTestCase as EveryskLibTaskGoogleTestCase,
-        WorkerGoogleTestCase as EveryskLibWorkerGoogleTestCase
-    )
+    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 error
+        raise

everysk/settings.py

@@ -93,3 +93,6 @@ HTTP_USE_RANDOM_USER_AGENT = BoolField(default=False)
 
 # Default directory to use the known_hosts file and other SFTP configurations
 EVERYSK_SFTP_DIR = StrField(default=f'{tempfile.gettempdir()}/sftp')
+
+# Enable to show retry logs
+RETRY_SHOW_LOGS = BoolField(default=False)

everysk/sql/connection.py

@@ -7,18 +7,21 @@
 # without authorization of EVERYSK TECHNOLOGIES is prohibited.
 #
 ###############################################################################
+from collections.abc import Callable
 from contextvars import ContextVar, Token
 from os import getpid
 from types import TracebackType
 from typing import Literal
 
-from psqlpy import Connection, ConnectionPool, QueryResult, SslMode
-from psqlpy import Transaction as _Transaction
+from psycopg import Connection, OperationalError
+from psycopg_pool import ConnectionPool as _ConnectionPool
 
 from everysk.config import settings
 from everysk.core.log import Logger
+from everysk.core.retry import retry
+from everysk.sql.row_factory import cls_row, dict_row
 
-_CONNECTIONS: dict[str, ConnectionPool] = {}
+_CONNECTIONS: dict[str, 'ConnectionPool'] = {}
 log = Logger('everysk-lib-sql-query')
 
 
@@ -27,37 +30,49 @@ def _log(message: str, extra: dict | None = None) -> None:
         log.debug(message, extra=extra)
 
 
+class ConnectionPool(_ConnectionPool):
+    def __del__(self) -> None:
+        # To close the connections when the pool is deleted
+        # https://everysk.atlassian.net/browse/COD-8885
+        try:
+            return super().__del__()
+        except RuntimeError:
+            # The connection is already closed or discarded because we cannot join the current thread
+            # RuntimeError: cannot join current thread
+            pass
+
+        return None
+
+
 class Transaction:
     ## Private attributes
     _connection: Connection
     _pool: ConnectionPool
     _token: Token
-    _transaction: _Transaction
 
     ## Public attributes
-    connection: ContextVar[_Transaction] = ContextVar('postgresql-psqlpy-transaction', default=None)
+    connection: ContextVar[Connection] = ContextVar('postgresql-psqlpy-transaction', default=None)
 
     def __init__(self, dsn: str | None = None) -> None:
         self._pool: ConnectionPool = get_pool(dsn=dsn)
 
-    async def __aenter__(self) -> None:
-        self._connection = await self._pool.connection()
-        self._transaction = self._connection.transaction()
-        await self._transaction.begin()
-        self._token = self.connection.set(self._transaction)
+    def __enter__(self) -> None:
+        self._connection = self._pool.getconn()
+        self._token = self.connection.set(self._connection)
 
         return self
 
-    async def __aexit__(
+    def __exit__(
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
     ) -> None:
         if exc_type is None:
-            await self._transaction.commit()
+            self._connection.commit()
         else:
-            await self._transaction.rollback()
+            self._connection.rollback()
 
         self.connection.reset(self._token)
-        self._connection.close()
+        # Return the connection to the pool
+        self._pool.putconn(self._connection)
 
         return False
 
@@ -89,7 +104,7 @@ def make_connection_dsn(
     return 'postgresql://{user}:{password}@{host}:{port}/{database}'.format(**options)
 
 
-def get_pool(dsn: str | None = None) -> ConnectionPool:
+def get_pool(dsn: str | None = None, **kwargs) -> ConnectionPool:
     """
     Retrieve a database connection pool for the given DSN.
 
@@ -102,28 +117,38 @@ def get_pool(dsn: str | None = None) -> ConnectionPool:
 
     Args:
         dsn (str | None): The Data Source Name for the database connection. If None, a default DSN is used.
+        **kwargs: Additional keyword arguments to configure the connection pool.
 
     Returns:
         ConnectionPool: The connection pool associated with the given DSN.
     """
     dsn = dsn or make_connection_dsn()
+    # https://www.psycopg.org/psycopg3/docs/api/pool.html
+    kwargs['check'] = ConnectionPool.check_connection
+    kwargs['min_size'] = kwargs.get('min_size', settings.POSTGRESQL_POOL_MIN_SIZE)
+    kwargs['max_size'] = kwargs.get('max_size', settings.POSTGRESQL_POOL_MAX_SIZE)
+    kwargs['max_idle'] = kwargs.get('max_idle', settings.POSTGRESQL_POOL_MAX_IDLE)
+    kwargs['max_lifetime'] = kwargs.get('max_lifetime', settings.POSTGRESQL_POOL_MAX_LIFETIME)
+    kwargs['max_waiting'] = kwargs.get('max_waiting', settings.POSTGRESQL_POOL_MAX_WAITING)
+    kwargs['reconnect_timeout'] = kwargs.get('reconnect_timeout', settings.POSTGRESQL_POOL_RECONNECT_TIMEOUT)
+    kwargs['timeout'] = kwargs.get('timeout', settings.POSTGRESQL_POOL_TIMEOUT)
+    kwargs['open'] = kwargs.get('open', settings.POSTGRESQL_POOL_OPEN)
+
     key = f'{getpid()}:{hash(dsn)}'
     if key not in _CONNECTIONS:
-        _CONNECTIONS[key] = ConnectionPool(
-            dsn=dsn,
-            max_db_pool_size=settings.POSTGRESQL_POOL_MAX_SIZE,
-            ssl_mode=getattr(SslMode, settings.POSTGRESQL_CONNECTION_ENCRYPTION, None),
-        )
+        _CONNECTIONS[key] = ConnectionPool(conninfo=dsn, **kwargs)
+
     return _CONNECTIONS[key]
 
 
-async def execute(
+def execute(
     query: str,
     params: dict | None = None,
     return_type: Literal['dict', 'list'] = 'list',
     dsn: str | None = None,
     cls: type | None = None,
-) -> list[dict] | list[object] | dict:
+    loads: Callable | None = None,
+) -> list[dict] | list[object] | dict | None:
     """
     Execute a query and return the results.
     If return_type is a class, return a list of instances of that class.
@@ -136,25 +161,48 @@ async def execute(
         return_type (Literal['dict', 'list'], optional): The type of return value. Defaults to 'list'.
         dsn (str | None, optional): The DSN to use for the connection. Defaults to None.
         cls (type | None, optional): The class to map the results to. Defaults to None.
+        loads (Callable | None, optional): Optional function to process each value. Defaults to None.
+        retry (int, optional): The current retry count. Defaults to 0.
     """
-    conn = Transaction.connection.get()
+    conn: Connection = Transaction.connection.get()
     if not conn:
         pool: ConnectionPool = get_pool(dsn=dsn)
-        conn = await pool.connection()
+        conn: Connection = pool.getconn()
+        is_transactional = False
         log_message = 'PostgreSQL query executed.'
     else:
+        is_transactional = True
         log_message = 'PostgreSQL query executed within transaction.'
 
     _log(log_message, extra={'labels': {'query': query, 'params': params}})
-    result: QueryResult = await conn.execute(query, params)
-    if not Transaction.connection.get():
-        conn.close()
 
-    if cls:
-        result = result.as_class(cls)
-        if return_type == 'dict':
-            return {row[cls._primary_key]: row for row in result}
+    row_factory = cls_row(cls, loads) if cls else dict_row(loads)
+    # For transactions we let it be controlled externally by the context manager
+    try:
+        with conn.cursor(row_factory=row_factory) as cur:
+            result = retry(cur.execute, {'query': query, 'params': params}, retries=3, exceptions=OperationalError)
+
+            if result.description:
+                result = cur.fetchall()
+            else:
+                result = None
+    except Exception:
+        # On error we need to rollback
+        if not is_transactional:
+            conn.rollback()
+        raise
+
+    else:
+        # Block that only executes if no exception was raised in the try block
+        if not is_transactional:
+            conn.commit()
+
+    finally:
+        # We only return the connection to the pool if we are not in a transaction
+        if not is_transactional:
+            pool.putconn(conn)
 
-        return result
+    if result and cls and return_type == 'dict':
+        return {row[cls._primary_key]: row for row in result}
 
-    return result.result()
+    return result

everysk/sql/model.py

@@ -7,7 +7,6 @@
 # without authorization of EVERYSK TECHNOLOGIES is prohibited.
 #
 ###############################################################################
-import asyncio
 import inspect
 from copy import deepcopy
 from types import GenericAlias, UnionType
@@ -260,12 +259,8 @@ class BaseModel(dict, metaclass=BaseModelMetaClass):
         return_type: Literal['dict', 'list'] = 'list',
         klass: type | None = None,
     ) -> Any:
-        loop = asyncio.get_event_loop()
         kwargs = {'query': query, 'params': params, 'return_type': return_type, 'dsn': cls._dsn, 'cls': klass}
-        if loop.is_running():
-            return asyncio.run_coroutine_threadsafe(execute(**kwargs), loop).result()
-
-        return loop.run_until_complete(execute(**kwargs))
+        return execute(**kwargs)
 
     @classmethod
     def _generate_attributes(cls) -> None:

everysk/sql/query.py

@@ -8,12 +8,29 @@
 #
 ###############################################################################
 import hashlib
+from functools import partial
 
-from psqlpy.extra_types import JSONB, Text
+from psycopg.types.json import Jsonb, set_json_dumps, set_json_loads
 
 from everysk.core.object import BaseDict
+from everysk.core.serialize import dumps, loads
 from everysk.sql.utils import ConditionOperator
 
+# https://www.psycopg.org/psycopg3/docs/basic/adapt.html#json-adaptation
+set_json_dumps(
+    partial(
+        dumps,
+        add_class_path=True,
+        date_format='%Y-%m-%d',
+        datetime_format='%Y-%m-%dT%H:%M:%S',
+        indent=None,
+        separators=(',', ':'),
+        use_undefined=True,
+    )
+)
+set_json_loads(partial(loads, use_undefined=True, instantiate_object=True))
+
+
 ## Constants
 _SQL_FIELDS = {
     'bool': 'BOOLEAN',
@@ -42,7 +59,7 @@ _SQL_CREATE_SCHEMA = 'CREATE SCHEMA IF NOT EXISTS "{schema}"'
 _SQL_CREATE_TABLE = 'CREATE TABLE IF NOT EXISTS "{schema}"."{table}" ({fields})'
 
 # https://www.postgresqltutorial.com/postgresql-delete/
-_SQL_DELETE = 'DELETE FROM "{schema}"."{table}" WHERE "{primary_key}" = ANY($(ids)p)'
+_SQL_DELETE = 'DELETE FROM "{schema}"."{table}" WHERE "{primary_key}" = ANY(%(ids)s)'
 
 # https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-upsert/
 # https://stackoverflow.com/a/30917361
@@ -201,11 +218,13 @@ class Query:
 
         try:
             offset = int(offset)
-        except (ValueError, TypeError):
-            raise TypeError('Offset must be an integer or a string representing it.')
+        except (ValueError, TypeError) as error:
+            msg = 'Offset must be an integer or a string representing it.'
+            raise TypeError(msg) from error
 
         if offset < 0:
-            raise TypeError('Offset must not be negative.')
+            msg = 'Offset must not be negative.'
+            raise TypeError(msg)
 
         if offset == 0:
             return ''
@@ -296,7 +315,7 @@ class Query:
         """
         # Create the values string
         # We do not use " here because we are using the values as placeholders
-        values = ', '.join(f'$({field})p' for field in fields)
+        values = ', '.join(f'%({field})s' for field in fields)
 
         # Create the SQL query
         update = ', '.join(f'"{field}" = EXCLUDED."{field}"' for field in fields)
@@ -320,17 +339,14 @@ class Query:
         Args:
             params (dict): A dictionary of parameters to prepare.
         """
-        # https://psqlpy-python.github.io/usage/types/extra_types.html
+        # https://www.psycopg.org/psycopg3/docs/basic/adapt.html#json-adaptation
         for key, value in params.items():
             if isinstance(value, (set, tuple)):
-                params[key] = JSONB(list(value))
-            elif isinstance(value, list):
-                params[key] = JSONB(value)
+                params[key] = Jsonb(list(value))
+            elif isinstance(value, (dict, list)):
+                params[key] = Jsonb(value)
             elif isinstance(value, BaseDict):
-                params[key] = JSONB(value.to_dict())
-            elif isinstance(value, str):
-                # Text is needed to differentiate between VARCHAR and TEXT
-                params[key] = Text(value)
+                params[key] = Jsonb(value.to_dict())
 
         return params
 

everysk/sql/row_factory.py

@@ -0,0 +1,63 @@
+###############################################################################
+#
+# (C) Copyright 2025 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 collections.abc import Callable, Iterable
+from typing import Any
+
+from psycopg import Cursor
+from psycopg.rows import _get_names, no_result
+
+
+def cls_row(cls: type, loads: Callable | None = None) -> Callable:
+    """
+    Function to convert a row from a cursor to an instance of the specified class.
+
+    Args:
+        cls (type): The class to instantiate for each row.
+        loads (callable | None, optional): Optional function to process each value. Defaults to None.
+    """
+
+    def inner(cursor: Cursor) -> Callable:
+        names = _get_names(cursor)
+        if names is None:
+            return no_result
+
+        def cls_row_(values: Iterable) -> Any:
+            if loads is None:
+                return cls(**dict(zip(names, values, strict=True)))
+
+            return cls(**dict(zip(names, map(loads, values), strict=True)))
+
+        return cls_row_
+
+    return inner
+
+
+def dict_row(loads: Callable | None = None) -> Callable:
+    """
+    Function to convert a row from a cursor to a dictionary.
+
+    Args:
+        loads (Callable | None): Optional function to process each value. Defaults to None.
+    """
+
+    def inner(cursor: Cursor) -> Callable:
+        names = _get_names(cursor)
+        if names is None:
+            return no_result
+
+        def dict_row_(values: Iterable) -> dict[str, Any]:
+            if loads is None:
+                return dict(zip(names, values, strict=True))
+
+            return dict(zip(names, map(loads, values), strict=True))
+
+        return dict_row_
+
+    return inner

everysk/sql/settings.py

@@ -17,6 +17,29 @@ POSTGRESQL_CONNECTION_PASSWORD: str = None
 POSTGRESQL_CONNECTION_PORT: int = 5432
 POSTGRESQL_CONNECTION_HOST: str = None
 POSTGRESQL_CONNECTION_USER: str = None
-# Disable, Allow, Prefer, Require, VerifyCA, VerifyFull
-POSTGRESQL_CONNECTION_ENCRYPTION: str = 'Prefer'
 POSTGRESQL_POOL_MAX_SIZE: int = 10
+POSTGRESQL_POOL_MIN_SIZE: int = 1
+
+# https://www.psycopg.org/psycopg3/docs/api/pool.html
+# Maximum time, in seconds, that a connection can stay unused in the pool before being closed, and the pool shrunk.
+# This only happens to connections more than min_size, if max_size allowed the pool to grow.
+POSTGRESQL_POOL_MAX_IDLE: int = 60 * 5  # 5 minutes
+
+# The maximum lifetime of a connection in the pool, in seconds. Connections used for longer get closed and replaced by
+# a new one. The amount is reduced by a random 10% to avoid mass eviction.
+POSTGRESQL_POOL_MAX_LIFETIME: int = 60 * 30  # 30 minutes
+
+# Maximum number of requests that can be queued to the pool, after which new requests will fail.
+# Raising TooManyRequests, 0 means no queue limit.
+POSTGRESQL_POOL_MAX_WAITING: int = 0
+
+# If the connections are opened on init or later.
+POSTGRESQL_POOL_OPEN: bool = True
+
+# Maximum time, in seconds, the pool will try to create a connection. If a connection attempt fails, the pool will try
+# to reconnect a few times, using an exponential backoff and some random factor to avoid mass attempts.
+POSTGRESQL_POOL_RECONNECT_TIMEOUT: int = 60 * 2  # 2 minutes
+
+# The default maximum time in seconds that a client can wait to receive a connection
+# from the pool (using connection() or getconn()).
+POSTGRESQL_POOL_TIMEOUT: int = 30  # 30 seconds

everysk/sql/utils.py

@@ -17,6 +17,7 @@ _SQL_OPERATORS = {
     'ilike': 'ILIKE',
     'in': 'IN',
     'inside': '?',
+    'insidebinary': '?|',
     'isnotnull': 'IS NOT NULL',
     'isnull': 'IS NULL',
     'like': 'LIKE',
@@ -58,8 +59,8 @@ class ConditionOperator:
 
     ## Operators methods
     def _operator_default(self) -> tuple[str, Any]:
-        """Default operator method "field" <operator> $(field)p."""
-        operation = f'{self.sql_operator} $({self.field_operator})p'
+        """Default operator method "field" <operator> %(field)s."""
+        operation = f'{self.sql_operator} %({self.field_operator})s'
         sql = f'"{self.field}" {operation}'
         return sql, self.value
 
@@ -69,9 +70,9 @@ class ConditionOperator:
         return sql, f'%{value}'
 
     def _operator_in(self) -> tuple[str, list]:
-        """Operator method for in: "field" = ANY($(field__in)p)."""
+        """Operator method for in: "field" = ANY(%(field__in)s)."""
         # https://www.psycopg.org/psycopg3/docs/basic/from_pg2.html#you-cannot-use-in-s-with-a-tuple
-        operation = f'ANY($({self.field_operator})p)'
+        operation = f'ANY(%({self.field_operator})s)'
         sql = f'"{self.field}" = {operation}'
         if isinstance(self.value, str):
             return sql, self.value.split(',')
@@ -98,8 +99,8 @@ class ConditionOperator:
         return self._operator_like()
 
     def _operator_nin(self) -> tuple[str, list]:
-        """Operator method for nin: "field" != ALL($(field__nin)p)."""
-        operation = f'ALL($({self.field_operator})p)'
+        """Operator method for nin: "field" != ALL(%(field__nin)s)."""
+        operation = f'ALL(%({self.field_operator})s)'
         sql = f'"{self.field}" != {operation}'
         if isinstance(self.value, str):
             return sql, self.value.split(',')
@@ -119,7 +120,7 @@ class ConditionOperator:
         Example:
             field__operator = 'age__gt'
             value = 30
-            returns: ('"age" > $(age__gt)p', 30)
+            returns: ('"age" > %(age__gt)s', 30)
         """
         method_name = f'_operator_{self.operator}'
         if hasattr(self, method_name):

{everysk_lib-1.9.8.dist-info → everysk_lib-1.9.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: everysk-lib
-Version: 1.9.8
+Version: 1.9.9
 Summary: Generic lib to share python code on Everysk.
 License-Expression: LicenseRef-Proprietary
 Project-URL: Homepage, https://everysk.com/
@@ -115,7 +115,9 @@ Requires-Dist: lark==1.2.2; extra == "expression"
 Requires-Dist: numpy==1.26.4; extra == "expression"
 Requires-Dist: pandas==2.1.4; extra == "expression"
 Provides-Extra: postgresql
-Requires-Dist: psqlpy==0.11.9; extra == "postgresql"
+Requires-Dist: psycopg-binary==3.3.0; extra == "postgresql"
+Requires-Dist: psycopg-pool==3.3.0; extra == "postgresql"
+Requires-Dist: psycopg==3.3.0; extra == "postgresql"
 Dynamic: license-file
 
 

{everysk_lib-1.9.8.dist-info → everysk_lib-1.9.9.dist-info}/RECORD

@@ -1,7 +1,7 @@
 everysk/__init__.py,sha256=JeZGK9kmTaBRR6H4et-3UYE6x8D7xsFtrTnJ_tQXG_Q,1039
 everysk/_version.py,sha256=_OPcym8X5j0fiafJLlKp8ADhMP5pHKqD2YySbH9f1PY,24501
 everysk/config.py,sha256=PKwYhzgBUIQ2m_cS5muBRWssZa4I3B6D5Qa9eSqAu18,16653
-everysk/settings.py,sha256=sU051hpzszM0SgZzn4vAOhEuEU_j9rEU7Gv9nWx1aEg,3936
+everysk/settings.py,sha256=Z_wPLDcAxjd6gW2lH6J8n6Q2j-x3V_AJGJmR5NapzBo,4008
 everysk/tests.py,sha256=-btpbhDDF2CGIIDr4vra38HrSu7kXrV3o9Hgci90lNc,844
 everysk/utils.py,sha256=nejrDn5n75YBk3BinEiDY5JhhdB7BaHX_9wpJ20RvXs,2654
 everysk/version.py,sha256=q8j2yDrdm4lEtGtOIt4tY4TUlctwQYJJcVqscDabikA,617
@@ -37,12 +37,13 @@ everysk/core/log.py,sha256=qFRW9bO6jaELwrJ0MIaEUm2-uYFIyTbH2bQ3j0XpPio,30239
 everysk/core/number.py,sha256=Al_9LLu7hj_4fTLPTiN3dzQvxctmMxB5i9I4Z4X5Lro,1204
 everysk/core/object.py,sha256=9XMSPDlgLtGTKJLVimRIND4a7U1e_rZrERJGZw2j_lQ,53924
 everysk/core/redis.py,sha256=HrG58dc_3EHnti2sBaijcyN8Hq4u3p1zst6-CSK9ySQ,36664
+everysk/core/retry.py,sha256=wLU0fNKP7cNYKkYxMTjR--YFYM0ahXWP-39O_FObwfo,1897
 everysk/core/serialize.py,sha256=8P5C7V98tB9vAQBEdu0NqMt8lktsD-Ol5REpTG1vNlw,25155
 everysk/core/sftp.py,sha256=01_iDxqhcAO3FFKUp-8myV7qtf3I-Mi_cLZ6KrAfsGw,15600
 everysk/core/signing.py,sha256=vImkFEiunqD-oO3e9Oi88z0x0jEEfO1lDIbC9RYxTn8,1956
 everysk/core/slack.py,sha256=r9QH6RRe74Jz4-8XWLqbYq21msIlsVuC4fr_VUMFZPE,4394
 everysk/core/string.py,sha256=K1BRlRNuhqlI7gdqOi40hjTHuxm1fF-RLqIAwm74eHc,5456
-everysk/core/tests.py,sha256=8zTef-BgIeMkV8QxWh-OEZy3wgJhVIRLNq9zj0VRg9E,11486
+everysk/core/tests.py,sha256=qrfAfUDmgCvBn99X73fL5MUTo1P33gq0ftP5CTJetCc,14491
 everysk/core/threads.py,sha256=CcL4Nv2Zzdxt1xjo0CbLSttSU29xHgSRiWF_JXr3GAA,7167
 everysk/core/undefined.py,sha256=sNvP9qJJi3TINPSJiIWjqKz4o5DNBBYparoTRrDtJ_0,2757
 everysk/core/unittests.py,sha256=ujGqGHCUAI25P4UgwHn9GpZAMBdqZ-lxxGERrckthIM,3289
@@ -120,14 +121,15 @@ everysk/server/routing.py,sha256=tHmmokv8msPY37T9F9_lovLZ9NP8bC8G_kxV92aM-tg,242
 everysk/server/settings.py,sha256=C9nM3PYZQOKjq9KB2DB4ojGkkTJtj5pslWrUdMGYEwk,1309
 everysk/server/tests.py,sha256=caw6jaXM0xjdi7Y10JpqUTCyUrUmKpG3uxigLcVRdew,1885
 everysk/sql/__init__.py,sha256=lXZAWXrI2tlzw9uvJyThaWnksZqdbemQ2tqe-e7wUiU,413
-everysk/sql/connection.py,sha256=uFp4EEsc4fX2rnmvQsHTpLZnWiUf1fpt4FSSZvPYhdk,5718
-everysk/sql/model.py,sha256=AzhGSYq9o_ekmpKmDcD6-9FEghd3_JzOiqGbapqhm_A,14756
-everysk/sql/query.py,sha256=vybpvTI4oieI6b9uGCPkRnb1YgZ3sNKOyzemKOHroaA,13757
-everysk/sql/settings.py,sha256=aQ6z1ZYtulmqwA4G7u-jx_OV_4IWPNgv5r9sfNWNh3A,864
-everysk/sql/utils.py,sha256=Or2Cs4wVp6fKQXuGP7e_bPvc88pP-PZ3AoSEDT7G_dA,4301
-everysk_lib-1.9.8.dist-info/.gitignore,sha256=0A1r9HzLhR7IQ1rGPjbaW5HC6oIQ7xzVYZ1z1ZaVfmw,183
-everysk_lib-1.9.8.dist-info/METADATA,sha256=wORt89Au8mLtyMGiy7gN-C5WEcWcgebKcEClkjtFWPQ,12962
-everysk_lib-1.9.8.dist-info/WHEEL,sha256=AwHYJA1Do1jwgPIoLQR4DiHSeYY_vU6Ht9Vljq5Yt_M,112
-everysk_lib-1.9.8.dist-info/top_level.txt,sha256=1s1Lfhd4gXolqzkh-ay3yy-EZKPiKnJfbZwx2fybxyk,14
-everysk_lib-1.9.8.dist-info/RECORD,,
-everysk_lib-1.9.8.dist-info/licenses/LICENSE.txt,sha256=Q5YxWA62m0TsmpEmHeoRHg4oPu_8ektkZ3FWWm1pQWo,311
+everysk/sql/connection.py,sha256=PujKm1i5gAvxU_FVT7IDuMb38D52dII52Gk8RI0vC_0,7928
+everysk/sql/model.py,sha256=syHHTTS4JRTj_2Mu9ugmMu4b6qUY12t3VgfE3hSxYIc,14559
+everysk/sql/query.py,sha256=yO2EoGoUoGace_9BNKN8jeyFV30yCrAhefAvGHqIFE4,14174
+everysk/sql/row_factory.py,sha256=FEtB4d12ACT3Bp6g2k_Ty2p2HpTkPoVqODUS1_kSXys,1936
+everysk/sql/settings.py,sha256=g5ZVm4Y3fhWGeXgTW6D309waGRBx2S6Ima4nY6ByTZw,2103
+everysk/sql/utils.py,sha256=Hbk9INEcz12FoBeDvHh9qh0dTSmTCWAn_S1anJOJb1o,4327
+everysk_lib-1.9.9.dist-info/.gitignore,sha256=0A1r9HzLhR7IQ1rGPjbaW5HC6oIQ7xzVYZ1z1ZaVfmw,183
+everysk_lib-1.9.9.dist-info/METADATA,sha256=LrZks9TN21b8JcX5EiJg2oIzB_o8mwCbusCghhXkYz4,13080
+everysk_lib-1.9.9.dist-info/WHEEL,sha256=AwHYJA1Do1jwgPIoLQR4DiHSeYY_vU6Ht9Vljq5Yt_M,112
+everysk_lib-1.9.9.dist-info/top_level.txt,sha256=1s1Lfhd4gXolqzkh-ay3yy-EZKPiKnJfbZwx2fybxyk,14
+everysk_lib-1.9.9.dist-info/RECORD,,
+everysk_lib-1.9.9.dist-info/licenses/LICENSE.txt,sha256=Q5YxWA62m0TsmpEmHeoRHg4oPu_8ektkZ3FWWm1pQWo,311