sotkalib 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

sotkalib/http/client_session.py

@@ -1,7 +1,7 @@
 import asyncio
-import importlib
 import ssl
-from collections.abc import Callable
+from collections.abc import Callable, Mapping, Sequence
+from functools import reduce
 from http import HTTPStatus
 from typing import Any, Literal, Protocol, Self
 
@@ -11,237 +11,248 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from sotkalib.log import get_logger
 
-try:
-    certifi = importlib.import_module("certifi")
-except ImportError:
-    certifi = None
-
-
 MAXIMUM_BACKOFF: float = 120
 
+try:
+	import certifi
+except ImportError:
+	certifi = None
 
-class RunOutOfAttemptsError(Exception):
-    pass
+class RanOutOfAttemptsError(Exception):
+	pass
 
+class CriticalStatusError(Exception):
+	pass
 
 class StatusRetryError(Exception):
-    status: int
-    context: str
+	status: int
+	context: str
 
-    def __init__(self, status: int, context: str) -> None:
-        super().__init__(f"{status}: {context}")
-        self.status = status
-        self.context = context
+	def __init__(self, status: int, context: str) -> None:
+		super().__init__(f"{status}: {context}")
+		self.status = status
+		self.context = context
 
+type ExcArgFunc = Callable[..., tuple[Sequence[Any], Mapping[str, Any] | None]]
+type StatArgFunc = Callable[..., Any]
 
-class CriticalStatusError(Exception):
-    pass
-
+async def default_stat_arg_func(resp: aiohttp.ClientResponse) -> tuple[Sequence[Any], None]:
+	return (f"[{resp.status}]; {await resp.text()=}",), None
 
 class StatusSettings(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+	model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    to_raise: set[HTTPStatus] = Field(default={HTTPStatus.FORBIDDEN})
-    to_retry: set[HTTPStatus] = Field(default={HTTPStatus.TOO_MANY_REQUESTS, HTTPStatus.FORBIDDEN})
-    exc_to_raise: type[Exception] = Field(default=CriticalStatusError)
-    not_found_as_none: bool = Field(default=True)
-    unspecified: Literal["retry", "raise"] = Field(default="retry")
+	to_raise: set[HTTPStatus] = Field(default={HTTPStatus.FORBIDDEN})
+	to_retry: set[HTTPStatus] = Field(default={HTTPStatus.TOO_MANY_REQUESTS, HTTPStatus.FORBIDDEN})
+	exc_to_raise: type[Exception] = Field(default=CriticalStatusError)
+	not_found_as_none: bool = Field(default=True)
+	args_for_exc_func: StatArgFunc = Field(default=default_stat_arg_func)
+	unspecified: Literal["retry", "raise"] = Field(default="retry")
 
+def default_exc_arg_func(exc: Exception, attempt: int, url: str, method: str, **kw) -> tuple[Sequence[Any], None]:
+	return (f"exception {type(exc)}: ({exc=}) {attempt=}; {url=} {method=} {kw=}",), None
 
 class ExceptionSettings(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    to_raise: tuple[type[Exception]] = Field(
-        default=(
-            client_exceptions.ConnectionTimeoutError,
-            client_exceptions.ClientProxyConnectionError,
-            client_exceptions.ContentTypeError,
-        ),
-    )
+	model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    to_retry: tuple[type[Exception]] = Field(
-        default=(
-            TimeoutError,
-            client_exceptions.ServerDisconnectedError,
-            client_exceptions.ClientConnectionResetError,
-            client_exceptions.ClientOSError,
-            client_exceptions.ClientHttpProxyError,
-        ),
-    )
+	to_raise: tuple[type[Exception]] = Field(
+		default=(
+			client_exceptions.ConnectionTimeoutError,
+			client_exceptions.ClientProxyConnectionError,
+			client_exceptions.ContentTypeError,
+		),
+	)
 
-    exc_to_raise: type[Exception] | None = Field(default=None)
+	to_retry: tuple[type[Exception]] = Field(
+		default=(
+			TimeoutError,
+			client_exceptions.ServerDisconnectedError,
+			client_exceptions.ClientConnectionResetError,
+			client_exceptions.ClientOSError,
+			client_exceptions.ClientHttpProxyError,
+		),
+	)
 
-    unspecified: Literal["retry", "raise"] = Field(default="retry")
+	exc_to_raise: type[Exception] | None = Field(default=None)
+	args_for_exc_func: ExcArgFunc = Field(default=default_exc_arg_func)
+	unspecified: Literal["retry", "raise"] = Field(default="retry")
 
 
-class RetryableClientSettings(BaseModel):
-    timeout: float = Field(default=5.0, gt=0)
-    base: float = Field(default=1.0, gt=0)
-    backoff: float = Field(default=2.0, gt=0)
-    maximum_retries: int = Field(default=3, ge=1)
+class ClientSettings(BaseModel):
+	timeout: float = Field(default=5.0, gt=0)
+	base: float = Field(default=1.0, gt=0)
+	backoff: float = Field(default=2.0, gt=0)
+	maximum_retries: int = Field(default=3, ge=1)
 
-    useragent_factory: Callable[[], str] | None = Field(default=None)
+	useragent_factory: Callable[[], str] | None = Field(default=None)
 
-    status_settings: StatusSettings = Field(default_factory=StatusSettings)
-    exception_settings: ExceptionSettings = Field(default_factory=ExceptionSettings)
+	status_settings: StatusSettings = Field(default_factory=StatusSettings)
+	exception_settings: ExceptionSettings = Field(default_factory=ExceptionSettings)
 
-    session_kwargs: dict[str, Any] = Field(default_factory=dict)
-    use_cookies_from_response: bool = Field(default=False)
+	session_kwargs: dict[str, Any] = Field(default_factory=dict)
+	use_cookies_from_response: bool = Field(default=False)
 
 
-class Handler[T](Protocol):
-    async def __call__(self, *args: Any, **kwargs: Any) -> T: ...
+class Handler[**P, T](Protocol):
+	async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T: ...
 
 
-type Middleware[T, R] = Callable[[Handler[T]], Handler[R]]
+type Middleware[**P, T, R] = Callable[[Handler[P, T]], Handler[P, R]]
 
 
 def _make_ssl_context(disable_tls13: bool = False) -> ssl.SSLContext:
-    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-    ctx.load_default_certs()
-
-    if certifi:
-        ctx.load_verify_locations(certifi.where())
-
-    ctx.minimum_version = ssl.TLSVersion.TLSv1_2
-    ctx.maximum_version = ssl.TLSVersion.TLSv1_2 if disable_tls13 else ssl.TLSVersion.TLSv1_3
-
-    ctx.set_ciphers(
-        "TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:"
-        "TLS_CHACHA20_POLY1305_SHA256:"
-        "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:"
-        "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256"
-    )
-
-    ctx.check_hostname = True
-    ctx.verify_mode = ssl.CERT_REQUIRED
-
-    return ctx
-
-
-class RetryableClientSession[R = aiohttp.ClientResponse | None]:
-    config: RetryableClientSettings
-    _session: aiohttp.ClientSession
-    _middlewares: list[Callable[[Handler[Any]], Handler[Any]]]
-
-    def __init__(
-        self,
-        config: RetryableClientSettings | None = None,
-        _middlewares: list[Callable[[Handler[Any]], Handler[Any]]] | None = None,
-    ) -> None:
-        self.config = config if config is not None else RetryableClientSettings()
-        self._session = None
-        self._middlewares = _middlewares or []
-
-    def use[NewR](self, mw: Middleware[R, NewR]) -> RetryableClientSession[NewR]:
-        new_session: RetryableClientSession[NewR] = RetryableClientSession(
-            config=self.config,
-            _middlewares=[*self._middlewares, mw],
-        )
-        return new_session
-
-    async def __aenter__(self) -> Self:
-        ctx = _make_ssl_context(disable_tls13=False)
-
-        if self.config.session_kwargs.get("connector") is None:
-            self.config.session_kwargs["connector"] = aiohttp.TCPConnector(ssl=ctx)
-        if self.config.session_kwargs.get("trust_env") is None:
-            self.config.session_kwargs["trust_env"] = False
-
-        self._session = aiohttp.ClientSession(
-            timeout=aiohttp.ClientTimeout(total=self.config.timeout),
-            **self.config.session_kwargs,
-        )
-
-        get_logger("http.client_session").debug(
-            f"RetryableClientSession initialized with timeout: {self.config.timeout}"
-        )
-
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        if self._session:
-            await self._session.close()
-
-    async def _handle_statuses(self, response: aiohttp.ClientResponse) -> aiohttp.ClientResponse | None:
-        sc = response.status
-        if self.config.use_cookies_from_response:
-            self._session.cookie_jar.update_cookies(response.cookies)
-        if sc in self.config.status_settings.to_retry:
-            raise StatusRetryError(status=sc, context=(await response.text()))
-        elif sc in self.config.status_settings.to_raise:
-            raise self.config.status_settings.exc_to_raise(f"status code: {sc} | {await response.text()}")
-        elif self.config.status_settings.not_found_as_none and sc == HTTPStatus.NOT_FOUND:
-            return None
-
-        return response
-
-    def _get_make_request_func(self) -> Handler[R]:
-        async def _make_request(*args: Any, **kwargs: Any) -> aiohttp.ClientResponse | None:
-            return await self._handle_statuses(await self._session.request(*args, **kwargs))
-
-        handler: Handler[Any] = _make_request
-        for mw in reversed(self._middlewares):
-            handler = mw(handler)
-
-        return handler
-
-    async def _handle_request(
-        self,
-        method: str,
-        url: str,
-        make_request_func: Handler[R],
-        **kw,
-    ) -> R:
-        kw_for_request = kw.copy()
-        if self.config.useragent_factory is not None:
-            user_agent_header = {"User-Agent": self.config.useragent_factory()}
-            kw_for_request["headers"] = kw_for_request.get("headers", {}) | user_agent_header
-        return await make_request_func(method, url, **kw_for_request)
-
-    async def _handle_retry(self, attempt: int, e: Exception, _: str, __: str, **___) -> None:
-        if attempt == self.config.maximum_retries:
-            raise RunOutOfAttemptsError(f"failed after {self.config.maximum_retries} retries: {type(e)} {e}") from e
-
-        await asyncio.sleep(self.config.base * min(MAXIMUM_BACKOFF, self.config.backoff**attempt))
-
-    async def _handle_to_raise(self, e: Exception, url: str, method: str, **kw) -> None:
-        if self.config.exception_settings.exc_to_raise is None:
-            raise e
-
-        raise self.config.exception_settings.exc_to_raise(f"EXC: {type(e)} {e}; {url} {method} {kw}") from e
-
-    async def _handle_exception(self, e: Exception, url: str, method: str, attempt: int, **kw) -> None:
-        if self.config.exception_settings.unspecified == "raise":
-            raise e
-
-        await self._handle_retry(attempt, e, url, method, **kw)
-
-    async def _request_with_retry(self, method: str, url: str, **kw) -> R:
-        _make_request = self._get_make_request_func()
-        for attempt in range(self.config.maximum_retries + 1):
-            try:
-                return await self._handle_request(method, url, _make_request, **kw)
-            except self.config.exception_settings.to_retry + (StatusRetryError,) as e:
-                await self._handle_retry(attempt, e, url, method, **kw)
-            except self.config.exception_settings.to_raise as e:
-                await self._handle_to_raise(e, url, method, **kw)
-            except Exception as e:
-                await self._handle_exception(e, url, method, attempt, **kw)
-
-        return await _make_request()
-
-    async def get(self, url: str, **kwargs: Any) -> R:
-        return await self._request_with_retry("GET", url, **kwargs)
-
-    async def post(self, url: str, **kwargs: Any) -> R:
-        return await self._request_with_retry("POST", url, **kwargs)
-
-    async def put(self, url: str, **kwargs: Any) -> R:
-        return await self._request_with_retry("PUT", url, **kwargs)
-
-    async def delete(self, url: str, **kwargs: Any) -> R:
-        return await self._request_with_retry("DELETE", url, **kwargs)
-
-    async def patch(self, url: str, **kwargs: Any) -> R:
-        return await self._request_with_retry("PATCH", url, **kwargs)
+	ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+	ctx.load_default_certs()
+
+	if certifi:
+		ctx.load_verify_locations(certifi.where())
+
+	ctx.minimum_version = ssl.TLSVersion.TLSv1_2
+	ctx.maximum_version = ssl.TLSVersion.TLSv1_2 if disable_tls13 else ssl.TLSVersion.TLSv1_3
+
+	ctx.set_ciphers(
+		"TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:"
+		"TLS_CHACHA20_POLY1305_SHA256:"
+		"ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:"
+		"ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256"
+	)
+
+	ctx.check_hostname = True
+	ctx.verify_mode = ssl.CERT_REQUIRED
+
+	return ctx
+
+
+
+class HTTPSession[R = aiohttp.ClientResponse | None]:
+	config: ClientSettings
+	_session: aiohttp.ClientSession
+	_middlewares: list[Middleware]
+
+	def __init__(
+		self,
+		config: ClientSettings | None = None,
+		_middlewares: list[Middleware] | None = None,
+	) -> None:
+		self.config = config if config is not None else ClientSettings()
+		self._session = None
+		self._middlewares = _middlewares or []
+
+	def use[**P, NewR](self, mw: Middleware[P, R, NewR]) -> HTTPSession[NewR]:
+		new_session: HTTPSession[NewR] = HTTPSession(
+			config=self.config,
+			_middlewares=[*self._middlewares, mw],
+		)
+		return new_session
+
+	async def __aenter__(self) -> Self:
+		ctx = _make_ssl_context(disable_tls13=False)
+
+		if self.config.session_kwargs.get("connector") is None:
+			self.config.session_kwargs["connector"] = aiohttp.TCPConnector(ssl=ctx)
+		if self.config.session_kwargs.get("trust_env") is None:
+			self.config.session_kwargs["trust_env"] = False
+
+		self._session = aiohttp.ClientSession(
+			timeout=aiohttp.ClientTimeout(total=self.config.timeout),
+			**self.config.session_kwargs,
+		)
+
+		get_logger("http.client_session").debug(
+			f"RetryableClientSession initialized with timeout: {self.config.timeout}"
+		)
+
+		return self
+
+	async def __aexit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any) -> None:
+		if self._session:
+			await self._session.close()
+
+	async def _handle_statuses(self, response: aiohttp.ClientResponse) -> aiohttp.ClientResponse | None:
+		sc = response.status
+		exc, argfunc = self.config.status_settings.exc_to_raise, self.config.status_settings.args_for_exc_func
+		if self.config.use_cookies_from_response:
+			self._session.cookie_jar.update_cookies(response.cookies)
+		if sc in self.config.status_settings.to_retry:
+			raise StatusRetryError(status=sc, context=(await response.text()))
+		elif sc in self.config.status_settings.to_raise:
+			a, kw = await argfunc(response)
+			if kw is None:
+				raise exc(*a)
+			raise exc(*a, **kw)
+		elif self.config.status_settings.not_found_as_none and sc == HTTPStatus.NOT_FOUND:
+			return None
+
+		return response
+
+	def _get_make_request_func(self) -> Callable[..., Any]:
+		async def _make_request(*args: Any, **kwargs: Any) -> aiohttp.ClientResponse | None:
+			return await self._handle_statuses(await self._session.request(*args, **kwargs))
+
+		return reduce(lambda t, s: s(t), reversed(self._middlewares), _make_request)
+
+	async def _handle_request(
+		self,
+		method: str,
+		url: str,
+		make_request_func: Callable[..., Any],
+		**kw: Any,
+	) -> R:
+		if self.config.useragent_factory is not None:
+			user_agent_header = {"User-Agent": self.config.useragent_factory()}
+			kw["headers"] = kw.get("headers", {}) | user_agent_header
+
+		return await make_request_func(method, url, **kw)
+
+	async def _handle_retry(self, e: Exception, attempt: int, url: str, method: str, **kws: Any) -> None:
+		if attempt == self.config.maximum_retries:
+			raise RanOutOfAttemptsError(f"failed after {self.config.maximum_retries} retries: {type(e)} {e}") from e
+
+		await asyncio.sleep(self.config.base * min(MAXIMUM_BACKOFF, self.config.backoff**attempt))
+
+	async def _handle_to_raise(self, e: Exception, attempt: int, url: str, method: str, **kw: Any) -> None:
+		if self.config.exception_settings.exc_to_raise is None:
+			raise e
+
+		exc, argfunc = self.config.exception_settings.exc_to_raise, self.config.exception_settings.args_for_exc_func
+
+		a, exckw = argfunc(e, attempt, url, method, **kw)
+		if exckw is None:
+			raise exc(*a) from e
+
+		raise exc(*a, **exckw) from e
+
+	async def _handle_exception(self, e: Exception, attempt: int, url: str, method: str, **kw: Any) -> None:
+		if self.config.exception_settings.unspecified == "raise":
+			raise e
+
+		await self._handle_retry(e, attempt, url, method, **kw)
+
+	async def _request_with_retry(self, method: str, url: str, **kw: Any) -> R:
+		_make_request = self._get_make_request_func()
+		for attempt in range(self.config.maximum_retries + 1):
+			try:
+				return await self._handle_request(method, url, _make_request, **kw)
+			except self.config.exception_settings.to_retry + (StatusRetryError,) as e:
+				await self._handle_retry(e, attempt, url, method, **kw)
+			except self.config.exception_settings.to_raise as e:
+				await self._handle_to_raise(e, attempt, url, method, **kw)
+			except Exception as e:
+				await self._handle_exception(e, attempt, url, method, **kw)
+
+		return await _make_request()
+
+	async def get(self, url: str, **kwargs: Any) -> R:
+		return await self._request_with_retry("GET", url, **kwargs)
+
+	async def post(self, url: str, **kwargs: Any) -> R:
+		return await self._request_with_retry("POST", url, **kwargs)
+
+	async def put(self, url: str, **kwargs: Any) -> R:
+		return await self._request_with_retry("PUT", url, **kwargs)
+
+	async def delete(self, url: str, **kwargs: Any) -> R:
+		return await self._request_with_retry("DELETE", url, **kwargs)
+
+	async def patch(self, url: str, **kwargs: Any) -> R:
+		return await self._request_with_retry("PATCH", url, **kwargs)

sotkalib/log/factory.py

@@ -9,21 +9,4 @@ if TYPE_CHECKING:
 
 @lru_cache
 def get_logger(logger_name: str | None = None) -> Logger:
-    """
-
-    Return a cached loguru Logger optionally bound with a humanized name.
-
-    If a name is provided, the returned logger is bound with extra["logger_name"]
-    in a " src -> sub -> leaf " format so it can be referenced in loguru sinks.
-
-    **Parameters:**
-
-    - `logger_name`: Dotted logger name (e.g., "src.database.service"). If None, return the global logger.
-
-    **Returns:**
-
-    A cached loguru Logger with the extra context bound when name is provided.
-
-    """
-
-    return logger if logger_name is None else logger.bind(logger_name=f" {logger_name.replace('.', ' -> ')} ")
+    return logger if logger_name is None else logger.bind(name=logger_name.replace(".", " -> "))

sotkalib/redis/__init__.py

@@ -0,0 +1,8 @@
+from .client import RedisPool, RedisPoolSettings
+from .lock import redis_context_lock
+
+__all__ = [
+    "redis_context_lock",
+    "RedisPool",
+    "RedisPoolSettings"
+]

sotkalib/redis/client.py

@@ -0,0 +1,38 @@
+import asyncio
+from contextlib import AbstractAsyncContextManager
+
+from pydantic import BaseModel, Field
+from redis.asyncio import ConnectionPool, Redis
+
+
+class RedisPoolSettings(BaseModel):
+	uri: str = Field(default="redis://localhost:6379")
+	db_num: int = Field(default=4)
+	max_connections: int = Field(default=50)
+	socket_timeout: float = Field(default=5)
+	socket_connect_timeout: float = Field(default=5)
+	retry_on_timeout: bool = Field(default=True)
+	health_check_interval: float = Field(default=30)
+	decode_responses: bool = Field(default=True)
+
+
+class RedisPool(AbstractAsyncContextManager):
+	def __init__(self, settings: RedisPoolSettings | None = None):
+		if not settings:
+			settings = RedisPoolSettings()
+
+		self._pool = ConnectionPool.from_url(
+			settings.uri + "/" + str(settings.db_num),
+			**settings.model_dump(exclude={"uri", "db_num"}),
+		)
+
+		self._usage_counter = 0
+		self._usage_lock = asyncio.Lock()
+
+	async def __aenter__(self: RedisPool) -> Redis:
+		try:
+			return Redis(connection_pool=self._pool)
+		except Exception:
+			raise
+
+	async def __aexit__(self, exc_type, exc_value, traceback): ...

sotkalib/redis/lock.py

@@ -0,0 +1,82 @@
+import asyncio
+from collections.abc import AsyncGenerator
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from time import time
+from typing import Any
+
+from redis.asyncio import Redis
+
+
+class ContextLockError(Exception):
+	def __init__(self, *args, can_retry: bool = True):
+		super().__init__(*args)
+		self.can_retry = can_retry
+
+
+async def __try_acquire(rc: Redis, key_to_lock: str, acquire_timeout: int) -> bool:
+	"""Atomically acquire a lock using SET NX (set-if-not-exists)."""
+	return bool(await rc.set(key_to_lock, "acquired", nx=True, ex=acquire_timeout))
+
+
+async def __wait_till_lock_free(
+	client: Redis,
+	key_to_lock: str,
+	lock_timeout: float = 10.0,
+	base_delay: float = 0.1,
+	max_delay: float = 5.0,
+) -> None:
+	start = time()
+	attempt = 0
+	while await client.get(key_to_lock) is not None:
+		if (time() - start) > lock_timeout:
+			raise ContextLockError(
+				f"{key_to_lock} lock already acquired, timeout after {lock_timeout}s",
+				can_retry=False,
+			)
+		delay = min(base_delay * (2**attempt), max_delay)
+		await asyncio.sleep(delay)
+		attempt += 1
+
+
+@asynccontextmanager
+async def redis_context_lock(
+	client: AbstractAsyncContextManager[Redis],
+	key_to_lock: str,
+	can_retry_if_lock_catched: bool = True,
+	wait_for_lock: bool = False,
+	wait_timeout: float = 60.0,
+	acquire_timeout: int = 5,
+	args_to_lock_exception: list[Any] | None = None,
+) -> AsyncGenerator[None]:
+	"""
+	Acquire a Redis lock atomically using SET NX.
+
+	:param client: async context mng for redis
+	:param key_to_lock: Redis key for the lock
+	:param can_retry_if_lock_catched: Whether task should retry if lock is taken (only used if wait_for_lock=False)
+	:param wait_for_lock: If True, wait for lock to be free instead of immediately failing
+	:param wait_timeout: Maximum time to wait for lock in seconds (only used if wait_for_lock=True)
+	:param acquire_timeout: Timeout for acquiring lock
+	:param args_to_lock_exception: Args to pass to ContextLockError
+
+	"""
+	if args_to_lock_exception is None:
+		args_to_lock_exception = []
+
+	if wait_for_lock:
+		async with client as rc:
+			await __wait_till_lock_free(key_to_lock=key_to_lock, client=rc, lock_timeout=wait_timeout)
+
+	try:
+		async with client as rc:
+			acquired = await __try_acquire(rc, key_to_lock, acquire_timeout)
+			if not acquired:
+				raise ContextLockError(
+					f"{key_to_lock} lock already acquired",
+					*args_to_lock_exception,
+					can_retry=can_retry_if_lock_catched,
+				)
+		yield
+	finally:
+		async with client as rc:
+			await rc.delete(key_to_lock)

sotkalib/sqla/__init__.py

@@ -0,0 +1,3 @@
+from .db import Database, DatabaseSettings
+
+__all__ = ("Database", "DatabaseSettings")