sotkalib 0.0.4.post1__py3-none-any.whl → 0.0.5.post1__py3-none-any.whl

sotkalib/__init__.py

@@ -1,3 +1,3 @@
 from . import config, enum, exceptions, http, log, redis, sqla
 
-__all__ = ["config", "enum", "exceptions", "http", "log", "redis", "sqla"]
+__all__ = ["config", "enum", "exceptions", "http", "log", "redis", "sqla"]

sotkalib/config/__init__.py

@@ -1,6 +1,6 @@
 from .struct import AppSettings, SettingsField
 
 __all__ = [
-    "AppSettings",
-    "SettingsField",
+	"AppSettings",
+	"SettingsField",
 ]

sotkalib/config/field.py

@@ -6,6 +6,6 @@ type AllowedTypes = int | float | complex | str | bool | None
 
 @dataclass(init=True, slots=True, frozen=True)
 class SettingsField[T: AllowedTypes]:
-    default: T | None = None
-    factory: Callable[[], T] | str | None = None
-    nullable: bool = False
+	default: T | None = None
+	factory: Callable[[], T] | str | None = None
+	nullable: bool = False

sotkalib/enum/mixins.py

@@ -4,56 +4,56 @@ from typing import Any, Literal, Self, overload
 
 
 class UppercaseStrEnumMixin(str, Enum):
-    @staticmethod
-    def _generate_next_value_(name: str, start: int, count: int, last_values: Sequence) -> str:  # noqa
-        return name.upper()
+	@staticmethod
+	def _generate_next_value_(name: str, start: int, count: int, last_values: Sequence) -> str:  # noqa
+		return name.upper()
 
 
 class ValidatorStrEnumMixin(str, Enum):
-    @classmethod
-    def _normalize_value(cls, val: Any) -> str:
-        if isinstance(val, (str, bytes, bytearray)):
-            return val.decode("utf-8") if isinstance(val, (bytes, bytearray)) else val
-        raise TypeError("value must be str-like")
-
-    @overload
-    @classmethod
-    def validate(cls, *, val: Any, req: Literal[False] = False) -> Self | None: ...
-
-    @overload
-    @classmethod
-    def validate(cls, *, val: Any, req: Literal[True]) -> Self: ...
-
-    @classmethod
-    def validate(cls, *, val: Any, req: bool = False) -> Self | None:
-        if val is None:
-            if req:
-                raise ValueError("value is None and req=True")
-            return None
-        normalized = cls._normalize_value(val)
-        try:
-            return cls(normalized)
-        except ValueError as e:
-            raise TypeError(f"{normalized=} not valid: {e}") from e
-
-    @overload
-    @classmethod
-    def get(cls, val: Any, default: Literal[None] = None) -> Self | None: ...
-
-    @overload
-    @classmethod
-    def get(cls, val: Any, default: Self) -> Self: ...
-
-    @classmethod
-    def get(cls, val: Any, default: Self | None = None) -> Self | None:
-        try:
-            return cls.validate(val=val, req=False) or default
-        except (ValueError, TypeError):
-            return default
-
-    def in_(self, *enum_values: Self) -> bool:
-        return self in enum_values
-
-    @classmethod
-    def values(cls) -> Sequence[Self]:
-        return list(cls)
+	@classmethod
+	def _normalize_value(cls, val: Any) -> str:
+		if isinstance(val, (str, bytes, bytearray)):
+			return val.decode("utf-8") if isinstance(val, (bytes, bytearray)) else val
+		raise TypeError("value must be str-like")
+
+	@overload
+	@classmethod
+	def validate(cls, *, val: Any, req: Literal[False] = False) -> Self | None: ...
+
+	@overload
+	@classmethod
+	def validate(cls, *, val: Any, req: Literal[True]) -> Self: ...
+
+	@classmethod
+	def validate(cls, *, val: Any, req: bool = False) -> Self | None:
+		if val is None:
+			if req:
+				raise ValueError("value is None and req=True")
+			return None
+		normalized = cls._normalize_value(val)
+		try:
+			return cls(normalized)
+		except ValueError as e:
+			raise TypeError(f"{normalized=} not valid: {e}") from e
+
+	@overload
+	@classmethod
+	def get(cls, val: Any, default: Literal[None] = None) -> Self | None: ...
+
+	@overload
+	@classmethod
+	def get(cls, val: Any, default: Self) -> Self: ...
+
+	@classmethod
+	def get(cls, val: Any, default: Self | None = None) -> Self | None:
+		try:
+			return cls.validate(val=val, req=False) or default
+		except (ValueError, TypeError):
+			return default
+
+	def in_(self, *enum_values: Self) -> bool:
+		return self in enum_values
+
+	@classmethod
+	def values(cls) -> Sequence[Self]:
+		return list(cls)

sotkalib/exceptions/__init__.py

@@ -1,3 +1,3 @@
 from . import api, handlers
 
-__all__ = ["api", "handlers"]
+__all__ = ["api", "handlers"]

sotkalib/exceptions/api/__init__.py

@@ -1 +1 @@
-from .exc import APIError, ErrorSchema
+from .exc import APIError, ErrorSchema

sotkalib/exceptions/handlers/__init__.py

@@ -1,4 +1,4 @@
 from .args_incl_error import ArgsIncludedError
 from .core import aexception_handler, exception_handler
 
-__all__ = ["aexception_handler", "exception_handler", "ArgsIncludedError"]
+__all__ = ["aexception_handler", "exception_handler", "ArgsIncludedError"]

sotkalib/exceptions/handlers/args_incl_error.py

@@ -11,5 +11,5 @@ class ArgsIncludedError(Exception):
 			args, _, _, values = inspect.getargvalues(frame)
 			f_locals = frame.f_locals
 			args_with_values = {arg: values[arg] for arg in args}
-			stack_args_to_exc.append(args_with_values | f_locals | { "frame_name": frame.f_code.co_name })
+			stack_args_to_exc.append(args_with_values | f_locals | {"frame_name": frame.f_code.co_name})
 		super().__init__(*_args, *stack_args_to_exc)

sotkalib/http/__init__.py

@@ -1,17 +1,29 @@
 from .client_session import (
 	ClientSettings,
+	# Exceptions
+	CriticalStatusError,
 	ExceptionSettings,
 	Handler,
 	HTTPSession,
 	Middleware,
+	Next,
+	RanOutOfAttemptsError,
+	RequestContext,
+	StatusRetryError,
 	StatusSettings,
 )
 
 __all__ = (
 	"HTTPSession",
+	"RequestContext",
 	"ExceptionSettings",
 	"StatusSettings",
 	"ClientSettings",
 	"Handler",
 	"Middleware",
+	"Next",
+	# Exceptions
+	"CriticalStatusError",
+	"RanOutOfAttemptsError",
+	"StatusRetryError",
 )

sotkalib/http/client_session.py

@@ -1,9 +1,10 @@
 import asyncio
 import ssl
-from collections.abc import Callable, Mapping, Sequence
-from functools import reduce
+import time
+from collections.abc import Awaitable, Callable, Mapping, Sequence
+from dataclasses import dataclass, field
 from http import HTTPStatus
-from typing import Any, Literal, Protocol, Self
+from typing import Any, Literal, Self
 
 import aiohttp
 from aiohttp import client_exceptions
@@ -18,12 +19,15 @@ try:
 except ImportError:
 	certifi = None
 
+
 class RanOutOfAttemptsError(Exception):
 	pass
 
+
 class CriticalStatusError(Exception):
 	pass
 
+
 class StatusRetryError(Exception):
 	status: int
 	context: str
@@ -33,12 +37,93 @@ class StatusRetryError(Exception):
 		self.status = status
 		self.context = context
 
-type ExcArgFunc = Callable[..., tuple[Sequence[Any], Mapping[str, Any] | None]]
-type StatArgFunc = Callable[..., Any]
 
-async def default_stat_arg_func(resp: aiohttp.ClientResponse) -> tuple[Sequence[Any], None]:
+@dataclass
+class RequestContext:
+	method: str
+	url: str
+	params: dict[str, Any] | None = None
+	headers: dict[str, Any] | None = None
+	data: Any = None
+	json: Any = None
+	kwargs: dict[str, Any] = field(default_factory=dict)
+
+	attempt: int = 0
+	max_attempts: int = 1
+
+	response: aiohttp.ClientResponse | None = None
+	response_body: Any = None
+	response_text: str | None = None
+	response_json: Any = None
+
+	started_at: float | None = None
+	finished_at: float | None = None
+	attempt_started_at: float | None = None
+
+	errors: list[Exception] = field(default_factory=list)
+	last_error: Exception | None = None
+
+	state: dict[str, Any] = field(default_factory=dict)
+
+	@property
+	def elapsed(self) -> float | None:
+		if self.started_at is None:
+			return None
+		end = self.finished_at if self.finished_at else time.monotonic()
+		return end - self.started_at
+
+	@property
+	def attempt_elapsed(self) -> float | None:
+		if self.attempt_started_at is None:
+			return None
+		return time.monotonic() - self.attempt_started_at
+
+	@property
+	def is_retry(self) -> bool:
+		return self.attempt > 0
+
+	@property
+	def status(self) -> int | None:
+		return self.response.status if self.response else None
+
+	def merge_headers(self, headers: dict[str, str]) -> None:
+		if self.headers is None:
+			self.headers = {}
+		self.headers.update(headers)
+
+	def to_request_kwargs(self) -> dict[str, Any]:
+		kw = dict(self.kwargs)
+		if self.params is not None:
+			kw["params"] = self.params
+		if self.headers is not None:
+			kw["headers"] = self.headers
+		if self.data is not None:
+			kw["data"] = self.data
+		if self.json is not None:
+			kw["json"] = self.json
+		return kw
+
+
+type Next[T] = Callable[[RequestContext], Awaitable[T]]
+type Middleware[T, R] = Callable[[RequestContext, Next[T]], Awaitable[R]]
+
+type ExcArgFunc = Callable[[RequestContext], tuple[Sequence[Any], Mapping[str, Any] | None]]
+type StatArgFunc = Callable[[RequestContext], tuple[Sequence[Any], Mapping[str, Any] | None]]
+
+
+async def default_stat_arg_func(ctx: RequestContext) -> tuple[Sequence[Any], None]:
+	resp = ctx.response
+	if resp is None:
+		return (), None
 	return (f"[{resp.status}]; {await resp.text()=}",), None
 
+
+def default_exc_arg_func(ctx: RequestContext) -> tuple[Sequence[Any], None]:
+	exc = ctx.last_error
+	msg = f"exception {type(exc)}: ({exc=}) attempt={ctx.attempt}; url={ctx.url} method={ctx.method}"
+	return (msg,), None
+
+
 class StatusSettings(BaseModel):
 	model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -49,13 +134,11 @@ class StatusSettings(BaseModel):
 	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(
+	to_raise: tuple[type[Exception], ...] = Field(
 		default=(
 			client_exceptions.ConnectionTimeoutError,
 			client_exceptions.ClientProxyConnectionError,
@@ -63,7 +146,7 @@ class ExceptionSettings(BaseModel):
 		),
 	)
 
-	to_retry: tuple[type[Exception]] = Field(
+	to_retry: tuple[type[Exception], ...] = Field(
 		default=(
 			TimeoutError,
 			client_exceptions.ServerDisconnectedError,
@@ -93,13 +176,6 @@ class ClientSettings(BaseModel):
 	use_cookies_from_response: bool = Field(default=False)
 
 
-class Handler[**P, T](Protocol):
-	async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T: ...
-
-
-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()
@@ -123,136 +199,246 @@ def _make_ssl_context(disable_tls13: bool = False) -> ssl.SSLContext:
 	return ctx
 
 
-
 class HTTPSession[R = aiohttp.ClientResponse | None]:
 	config: ClientSettings
-	_session: aiohttp.ClientSession
-	_middlewares: list[Middleware]
+	_session: aiohttp.ClientSession | None
+	_middlewares: list[Middleware[Any, Any]]
+	_logger: Any
 
 	def __init__(
 		self,
 		config: ClientSettings | None = None,
-		_middlewares: list[Middleware] | None = None,
+		_middlewares: list[Middleware[Any, Any]] | None = None,
 	) -> None:
 		self.config = config if config is not None else ClientSettings()
 		self._session = None
 		self._middlewares = _middlewares or []
+		self._logger = get_logger("http.client_session")
 
-	def use[**P, NewR](self, mw: Middleware[P, R, NewR]) -> HTTPSession[NewR]:
-		new_session: HTTPSession[NewR] = HTTPSession(
+	def use[NewR](self, middleware: Middleware[R, NewR]) -> HTTPSession[NewR]:
+		return HTTPSession[NewR](
 			config=self.config,
-			_middlewares=[*self._middlewares, mw],
+			_middlewares=[*self._middlewares, middleware],
 		)
-		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
+		session_kwargs = dict(self.config.session_kwargs)
+		if session_kwargs.get("connector") is None:
+			session_kwargs["connector"] = aiohttp.TCPConnector(ssl=ctx)
+		if session_kwargs.get("trust_env") is None:
+			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}"
+			**session_kwargs,
 		)
 
+		self._logger.debug(f"HTTPSession 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:
+	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:
+	def _build_pipeline(self) -> Next[R]:
+		async def core_request(ctx: RequestContext) -> aiohttp.ClientResponse | None:
+			return await self._execute_request(ctx)
+
+		pipeline: Next[Any] = core_request
+		for middleware in reversed(self._middlewares):
+			pipeline = (lambda mw, nxt: lambda c: mw(c, nxt))(middleware, pipeline)  # noqa: PLC3002
+
+		return pipeline
+
+	async def _execute_request(self, ctx: RequestContext) -> aiohttp.ClientResponse | None:
+		if self._session is None:
+			raise RuntimeError("HTTPSession must be used as async context manager")
+
+		response = await self._session.request(ctx.method, ctx.url, **ctx.to_request_kwargs())
+		ctx.response = response
+
+		return await self._handle_status(ctx, response)
+
+	async def _handle_status(
+		self,
+		ctx: RequestContext,
+		response: aiohttp.ClientResponse,
+	) -> aiohttp.ClientResponse | None:
+		status = response.status
+		settings = self.config.status_settings
+
+		if self.config.use_cookies_from_response and self._session:
 			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:
+
+		if HTTPStatus(status) in settings.to_retry:
+			text = await response.text()
+			ctx.response_text = text
+			raise StatusRetryError(status=status, context=text)
+
+		if HTTPStatus(status) in settings.to_raise:
+			exc_cls = settings.exc_to_raise
+			args, kwargs = settings.args_for_exc_func(ctx)
+			if kwargs is None:
+				raise exc_cls(*args)
+			raise exc_cls(*args, **kwargs)
+
+		if settings.not_found_as_none and status == 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))
+	async def _request_with_retry(self, ctx: RequestContext) -> R:
+		ctx.started_at = time.monotonic()
+		ctx.max_attempts = self.config.maximum_retries + 1
 
-		return reduce(lambda t, s: s(t), reversed(self._middlewares), _make_request)
+		pipeline = self._build_pipeline()
 
-	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
+		for attempt in range(ctx.max_attempts):
+			ctx.attempt = attempt
+			ctx.attempt_started_at = time.monotonic()
+			ctx.response = None
 
-		return await make_request_func(method, url, **kw)
+			try:
+				result = await pipeline(ctx)
+				ctx.finished_at = time.monotonic()
+				return result
 
-	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
+			except merge_tuples(self.config.exception_settings.to_retry, (StatusRetryError,)) as e:
+				ctx.errors.append(e)
+				ctx.last_error = e
+				await self._handle_retry(ctx, e)
 
-		await asyncio.sleep(self.config.base * min(MAXIMUM_BACKOFF, self.config.backoff**attempt))
+			except self.config.exception_settings.to_raise as e:
+				ctx.errors.append(e)
+				ctx.last_error = e
+				ctx.finished_at = time.monotonic()
+				await self._handle_to_raise(ctx, e)
 
-	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
+			except Exception as e:
+				ctx.errors.append(e)
+				ctx.last_error = e
+				await self._handle_exception(ctx, e)
 
-		exc, argfunc = self.config.exception_settings.exc_to_raise, self.config.exception_settings.args_for_exc_func
+		ctx.finished_at = time.monotonic()
+		raise RanOutOfAttemptsError(
+			f"failed after {self.config.maximum_retries} retries: {type(ctx.last_error).__name__}: {ctx.last_error}"
+		)
 
-		a, exckw = argfunc(e, attempt, url, method, **kw)
-		if exckw is None:
-			raise exc(*a) from e
+	async def _handle_retry(self, ctx: RequestContext, e: Exception) -> None:
+		if ctx.attempt >= self.config.maximum_retries:
+			raise RanOutOfAttemptsError(
+				f"failed after {self.config.maximum_retries} retries: {type(e).__name__}: {e}"
+			) from e
 
-		raise exc(*a, **exckw) from e
+		delay = self.config.base * min(MAXIMUM_BACKOFF, self.config.backoff**ctx.attempt)
+		self._logger.debug(
+			f"Retry {ctx.attempt + 1}/{ctx.max_attempts} for {ctx.method} {ctx.url} "
+			f"after {delay:.2f}s (error: {type(e).__name__})"
+		)
+		await asyncio.sleep(delay)
 
-	async def _handle_exception(self, e: Exception, attempt: int, url: str, method: str, **kw: Any) -> None:
-		if self.config.exception_settings.unspecified == "raise":
+	async def _handle_to_raise(self, ctx: RequestContext, e: Exception) -> None:
+		exc_cls = self.config.exception_settings.exc_to_raise
+		if exc_cls is None:
 			raise e
 
-		await self._handle_retry(e, attempt, url, method, **kw)
+		args, kwargs = self.config.exception_settings.args_for_exc_func(ctx)
+		if kwargs is None:
+			raise exc_cls(*args) from e
+		raise exc_cls(*args, **kwargs) from e
 
-	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)
+	async def _handle_exception(self, ctx: RequestContext, e: Exception) -> None:
+		"""Handle unspecified exceptions according to settings."""
+		if self.config.exception_settings.unspecified == "raise":
+			raise e
+		await self._handle_retry(ctx, e)
 
-		return await _make_request()
+	def _create_context(
+		self,
+		method: str,
+		url: str,
+		params: dict[str, Any] | None = None,
+		headers: dict[str, Any] | None = None,
+		data: Any = None,
+		json: Any = None,
+		**kwargs: Any,
+	) -> RequestContext:
+		"""Create a RequestContext for the given request parameters."""
+		# Apply user agent if configured
+		if self.config.useragent_factory is not None:
+			if headers is None:
+				headers = {}
+			headers["User-Agent"] = self.config.useragent_factory()
+
+		return RequestContext(
+			method=method,
+			url=url,
+			params=params,
+			headers=headers,
+			data=data,
+			json=json,
+			kwargs=kwargs,
+		)
+
+	async def request(
+		self,
+		method: str,
+		url: str,
+		*,
+		params: dict[str, Any] | None = None,
+		headers: dict[str, Any] | None = None,
+		data: Any = None,
+		json: Any = None,
+		**kwargs: Any,
+	) -> R:
+		ctx = self._create_context(method, url, params, headers, data, json, **kwargs)
+		return await self._request_with_retry(ctx)
 
 	async def get(self, url: str, **kwargs: Any) -> R:
-		return await self._request_with_retry("GET", url, **kwargs)
+		"""Make a GET request."""
+		return await self.request("GET", url, **kwargs)
 
 	async def post(self, url: str, **kwargs: Any) -> R:
-		return await self._request_with_retry("POST", url, **kwargs)
+		"""Make a POST request."""
+		return await self.request("POST", url, **kwargs)
 
 	async def put(self, url: str, **kwargs: Any) -> R:
-		return await self._request_with_retry("PUT", url, **kwargs)
+		"""Make a PUT request."""
+		return await self.request("PUT", url, **kwargs)
 
 	async def delete(self, url: str, **kwargs: Any) -> R:
-		return await self._request_with_retry("DELETE", url, **kwargs)
+		"""Make a DELETE request."""
+		return await self.request("DELETE", url, **kwargs)
 
 	async def patch(self, url: str, **kwargs: Any) -> R:
-		return await self._request_with_retry("PATCH", url, **kwargs)
+		"""Make a PATCH request."""
+		return await self.request("PATCH", url, **kwargs)
+
+
+def merge_tuples[T](t1: tuple[T, ...], t2: tuple[T, ...]) -> tuple[T, ...]:
+	return t1 + t2
+
+
+# ============================================================================
+# Legacy compatibility aliases
+# ============================================================================
+
+# Old Handler protocol - kept for backwards compatibility but deprecated
+from typing import Protocol
+
+
+class Handler[**P, T](Protocol):
+	"""
+	DEPRECATED: Use Middleware type instead.
+
+	Old handler protocol for backwards compatibility.
+	"""
+
+	async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T: ...

sotkalib/log/factory.py

@@ -4,9 +4,9 @@ from typing import TYPE_CHECKING
 from loguru import logger
 
 if TYPE_CHECKING:
-    from loguru import Logger
+	from loguru import Logger
 
 
 @lru_cache
 def get_logger(logger_name: str | None = None) -> Logger:
-    return logger if logger_name is None else logger.bind(name=logger_name.replace(".", " -> "))
+	return logger if logger_name is None else logger.bind(name=logger_name.replace(".", " -> "))

sotkalib/redis/__init__.py

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

sotkalib/sqla/__init__.py

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

sotkalib/sqla/db.py

@@ -7,95 +7,96 @@ from sqlalchemy.orm import Session, sessionmaker
 from sotkalib.log import get_logger
 
 
-class ConnectionTimeoutError(Exception): pass
+class ConnectionTimeoutError(Exception):
+	pass
+
 
 class DatabaseSettings(BaseModel):
-    uri: str = Field(examples=[
-        "postgresql://username:password@localhost:5432/database"
-    ])
-    async_driver: str = "asyncpg"
-    echo: bool = False
-    pool_size: int = 10
+	uri: str = Field(examples=["postgresql://username:password@localhost:5432/database"])
+	async_driver: str = "asyncpg"
+	echo: bool = False
+	pool_size: int = 10
+
+	@property
+	def async_uri(self) -> str:
+		return self.uri.replace("postgresql://", "postgresql" + self.async_driver + "://")
 
-    @property
-    def async_uri(self) -> str:
-        return self.uri.replace("postgresql://", "postgresql" + self.async_driver + "://")
 
 class Database:
-    _sync_engine: Engine | None
-    _async_engine: AsyncEngine | None
-    _sync_session_factory: sessionmaker = None
-    _async_session_factory: async_sessionmaker = None
-
-    logger = get_logger("sqldb.instance")
-
-    def __init__(self, settings: DatabaseSettings):
-        self.__async_uri = settings.async_uri
-        self.__sync_uri = settings.uri
-        self.echo = settings.echo
-        self.pool_size = settings.pool_size
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if self._sync_engine:
-            self._sync_engine.dispose()
-            self.logger.info("closed sync db connection")
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, *args):
-        if self._async_engine:
-            await self._async_engine.dispose()
-            self.logger.info("closed async db connection")
-
-    def __async_init(self):
-        self._async_engine = create_async_engine(
-            url=self.__async_uri,
-            echo=self.echo,
-            pool_size=self.pool_size,
-        )
-        self._async_session_factory = async_sessionmaker(bind=self._async_engine, expire_on_commit=False)
-        self.logger.debug(  # noqa: PLE1205
-            "successfully initialized async db connection, engine.status = {} sessionmaker.status = {}",
-            self._async_engine.name is not None,
-            self._async_session_factory is not None,
-            )
-
-    @property
-    def async_session(self) -> async_sessionmaker[AsyncSession]:
-        if self._async_engine is None or self._async_session_factory is None:
-            self.logger.debug("async_sf not found, initializing")
-            self.__async_init()
-            if self._async_engine is None or self._async_session_factory is None:
-                self.logger.error(c := "could not asynchronously connect to pgsql")
-                raise ConnectionTimeoutError(c)
-        self.logger.debug("success getting (asyncmaker)")
-        return self._async_session_factory
-
-    def __sync_init(self):
-        self._sync_engine = create_engine(
-            url=self.__sync_uri,
-            echo=self.echo,
-            pool_size=self.pool_size,
-        )
-        self._sync_session_factory = sessionmaker(bind=self._sync_engine, expire_on_commit=False)
-        self.logger.debug(  # noqa
-            " -> (__sync_init) successfully initialized sync db connection,\n"
-            "\t\t\t\tengine.status = {} sessionmaker.status = {}",
-            self._sync_engine.name is not None,
-            self._sync_session_factory is not None,
-            )
-
-    @property
-    def session(self) -> sessionmaker[Session]:
-        if self._sync_engine is None or self._sync_session_factory is None:
-            self.logger.debug("not found, initializing...")
-            self.__sync_init()
-            if self._sync_engine is None or self._sync_session_factory is None:
-                self.logger.error(c := "could not synchronously connect to pgsql")
-                raise ConnectionTimeoutError(c)
-        self.logger.debug("success getting (syncmaker)")
-        return self._sync_session_factory
+	_sync_engine: Engine | None
+	_async_engine: AsyncEngine | None
+	_sync_session_factory: sessionmaker = None
+	_async_session_factory: async_sessionmaker = None
+
+	logger = get_logger("sqldb.instance")
+
+	def __init__(self, settings: DatabaseSettings):
+		self.__async_uri = settings.async_uri
+		self.__sync_uri = settings.uri
+		self.echo = settings.echo
+		self.pool_size = settings.pool_size
+
+	def __enter__(self):
+		return self
+
+	def __exit__(self, exc_type, exc_val, exc_tb):
+		if self._sync_engine:
+			self._sync_engine.dispose()
+			self.logger.info("closed sync db connection")
+
+	async def __aenter__(self):
+		return self
+
+	async def __aexit__(self, *args):
+		if self._async_engine:
+			await self._async_engine.dispose()
+			self.logger.info("closed async db connection")
+
+	def __async_init(self):
+		self._async_engine = create_async_engine(
+			url=self.__async_uri,
+			echo=self.echo,
+			pool_size=self.pool_size,
+		)
+		self._async_session_factory = async_sessionmaker(bind=self._async_engine, expire_on_commit=False)
+		self.logger.debug(  # noqa: PLE1205
+			"successfully initialized async db connection, engine.status = {} sessionmaker.status = {}",
+			self._async_engine.name is not None,
+			self._async_session_factory is not None,
+		)
+
+	@property
+	def async_session(self) -> async_sessionmaker[AsyncSession]:
+		if self._async_engine is None or self._async_session_factory is None:
+			self.logger.debug("async_sf not found, initializing")
+			self.__async_init()
+			if self._async_engine is None or self._async_session_factory is None:
+				self.logger.error(c := "could not asynchronously connect to pgsql")
+				raise ConnectionTimeoutError(c)
+		self.logger.debug("success getting (asyncmaker)")
+		return self._async_session_factory
+
+	def __sync_init(self):
+		self._sync_engine = create_engine(
+			url=self.__sync_uri,
+			echo=self.echo,
+			pool_size=self.pool_size,
+		)
+		self._sync_session_factory = sessionmaker(bind=self._sync_engine, expire_on_commit=False)
+		self.logger.debug(  # noqa
+			" -> (__sync_init) successfully initialized sync db connection,\n"
+			"\t\t\t\tengine.status = {} sessionmaker.status = {}",
+			self._sync_engine.name is not None,
+			self._sync_session_factory is not None,
+		)
+
+	@property
+	def session(self) -> sessionmaker[Session]:
+		if self._sync_engine is None or self._sync_session_factory is None:
+			self.logger.debug("not found, initializing...")
+			self.__sync_init()
+			if self._sync_engine is None or self._sync_session_factory is None:
+				self.logger.error(c := "could not synchronously connect to pgsql")
+				raise ConnectionTimeoutError(c)
+		self.logger.debug("success getting (syncmaker)")
+		return self._sync_session_factory

{sotkalib-0.0.4.post1.dist-info → sotkalib-0.0.5.post1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sotkalib
-Version: 0.0.4.post1
+Version: 0.0.5.post1
 Summary: 
 Author: alexey
 Author-email: alexey <me@pyrorhythm.dev>

sotkalib-0.0.5.post1.dist-info/RECORD

@@ -0,0 +1,25 @@
+sotkalib/__init__.py,sha256=TDJPQ_pOk73TTDkjgNpvn4nvn3siktb1sTogogLCwa0,139
+sotkalib/config/__init__.py,sha256=_F7rSYgBsSxnNL1JtxrJYlw3lBXyVg0JdsOrxbWtcDA,96
+sotkalib/config/field.py,sha256=vbKGAEevEmdvyw4eaZprfR2g7ZVAB-5AbYPx0f4uusc,317
+sotkalib/config/struct.py,sha256=gv1jFrSRytMC6bZTUDOUQf00Zo1iKxQvuTxGv9qnyHI,5679
+sotkalib/enum/__init__.py,sha256=pKpLPm8fqHO4Et21TWIybIPRiehN1KrmxcBh6hPRsxM,127
+sotkalib/enum/mixins.py,sha256=CQrgKftnmZSWkNb-56Z9PZ3um0_lHGEsnEYy9GwCmhM,1611
+sotkalib/exceptions/__init__.py,sha256=r-DwSwJIkuQ2UGAorKvkIVv87n4Yt8H0mk_uxKcBGTw,59
+sotkalib/exceptions/api/__init__.py,sha256=yTbg2p5mB0-8ZHtzlLL6e0ZkC3LRUZmjmWMxU9Uh8-Q,39
+sotkalib/exceptions/api/exc.py,sha256=gqx4GrHXUvKcR7tEmJpRqPbDWOT2AgKoyck8-FovQCc,1329
+sotkalib/exceptions/handlers/__init__.py,sha256=Pz1akT2x3SaRsPezNPYnCoTcejxy4n4_cO4cXRJUBIk,179
+sotkalib/exceptions/handlers/args_incl_error.py,sha256=rYiBximsXVw1YDUBbdsqeqsfTWxshyX4EdISXWYkPDE,533
+sotkalib/exceptions/handlers/core.py,sha256=5fhusoxBhUz59TaVWobplBvD-sbkZKBnmmu-fcSyRk4,836
+sotkalib/http/__init__.py,sha256=TGjBT5pgmNuBO1TpXU_YqSfXdWsGTEHpGO8Qwf2x2w4,457
+sotkalib/http/client_session.py,sha256=pIbTYbP8NT9ZGnuTi7LI7nE-UvxPx2G8RCgiEpNpMCA,12928
+sotkalib/log/__init__.py,sha256=xrBx--c8QU5xkb3_n61LuqF8ySUaxlQkHCxHyH_D8aE,58
+sotkalib/log/factory.py,sha256=oyvHOum8jwLGr_XC0c44VIVLzWQQqHSbQOnf85bP9Co,303
+sotkalib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sotkalib/redis/__init__.py,sha256=-0ZXD-cC-Xi6RmAvnrAgU-8Z6g4l88XmXf3kvIgBD9k,154
+sotkalib/redis/client.py,sha256=0TWe-gYqFiuCjqimCQrVrnTHSM0EROIoJL36M3qwOtQ,1118
+sotkalib/redis/lock.py,sha256=nEZjIyXmgq3vH-Urs8qXC_N8lmXNho00SaTZ7wJIEIo,2528
+sotkalib/sqla/__init__.py,sha256=n-I_hoRS-N7XN02yYCTtw6Dh4BBSQRmolS19tEB2KMM,87
+sotkalib/sqla/db.py,sha256=6ZckKQ8kmRlYrwCAzKidc_JNPwqp38tSGEy3XMGnv08,3376
+sotkalib-0.0.5.post1.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
+sotkalib-0.0.5.post1.dist-info/METADATA,sha256=qU3FtZwv03aV_0TcWvi_xgif-WyzqJVfgLkUclZbRNU,392
+sotkalib-0.0.5.post1.dist-info/RECORD,,

sotkalib-0.0.4.post1.dist-info/RECORD

@@ -1,25 +0,0 @@
-sotkalib/__init__.py,sha256=t3dEAlrtHABFRZdF7RM5K2N1fDUTVwUPmBPG4jFdvSY,138
-sotkalib/config/__init__.py,sha256=CSjn02NCnBPO14QOg4OzKI-lTxyKoBxQ4ODsiWamlIM,102
-sotkalib/config/field.py,sha256=596_6DLnUIMN86h2uob9YN5IrHnc7fguWScSbIYsTH4,326
-sotkalib/config/struct.py,sha256=gv1jFrSRytMC6bZTUDOUQf00Zo1iKxQvuTxGv9qnyHI,5679
-sotkalib/enum/__init__.py,sha256=pKpLPm8fqHO4Et21TWIybIPRiehN1KrmxcBh6hPRsxM,127
-sotkalib/enum/mixins.py,sha256=rgXb0eXaBSozrviOMJo1671x4DiN9SELtw3-x6PvhDM,1821
-sotkalib/exceptions/__init__.py,sha256=H2h-yW1o0_X1Z9O-hWgj6h2spFxpzJJQ_N2ITMr600A,58
-sotkalib/exceptions/api/__init__.py,sha256=tIFOiRlbPkgCRNv5OPZ1M98nRnAMkFIuqSK7dZpKMRI,38
-sotkalib/exceptions/api/exc.py,sha256=gqx4GrHXUvKcR7tEmJpRqPbDWOT2AgKoyck8-FovQCc,1329
-sotkalib/exceptions/handlers/__init__.py,sha256=rA6o6_LVa-0TToyPhT1vB_Lz2E0U8EUfHICAYgAUd78,178
-sotkalib/exceptions/handlers/args_incl_error.py,sha256=DB8TMhZdSkwZwEahOJ99zXWknqBTkSC4IKZsZ5psxdg,535
-sotkalib/exceptions/handlers/core.py,sha256=5fhusoxBhUz59TaVWobplBvD-sbkZKBnmmu-fcSyRk4,836
-sotkalib/http/__init__.py,sha256=HxOuGbHbz39MD0ICjOSh4zv-nGPZca9TgxP4rCceamw,241
-sotkalib/http/client_session.py,sha256=OtGTpwr8I7tsgOxRGS8c7tby5sGT_T6B0Zc8HTC9Sxs,8838
-sotkalib/log/__init__.py,sha256=xrBx--c8QU5xkb3_n61LuqF8ySUaxlQkHCxHyH_D8aE,58
-sotkalib/log/factory.py,sha256=Wl8qY2-vimpctRlRYSWPLjC0KgeEGgSSuDDJaxWtvK8,309
-sotkalib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sotkalib/redis/__init__.py,sha256=wv3AIRw3aXXLgTTrt6my8C8jSBl4-R3dWRfGLbGTHng,167
-sotkalib/redis/client.py,sha256=0TWe-gYqFiuCjqimCQrVrnTHSM0EROIoJL36M3qwOtQ,1118
-sotkalib/redis/lock.py,sha256=nEZjIyXmgq3vH-Urs8qXC_N8lmXNho00SaTZ7wJIEIo,2528
-sotkalib/sqla/__init__.py,sha256=fYT8O-bPcdXxJ3QVu3KbypwbZ_hpm8Eq1CuQgjvyNJ8,86
-sotkalib/sqla/db.py,sha256=lxE6XLgX-CowyhfRwTAA_FGJybiihaGWWzlNe8M41CE,3866
-sotkalib-0.0.4.post1.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
-sotkalib-0.0.4.post1.dist-info/METADATA,sha256=aHmKbSM7SWEwCVkr-557q0o_Q5_EJ59H5d5F5QMvnbs,392
-sotkalib-0.0.4.post1.dist-info/RECORD,,