sotkalib 0.0.4__tar.gz → 0.0.5__tar.gz

{sotkalib-0.0.4 → sotkalib-0.0.5}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.3
 Name: sotkalib
-Version: 0.0.4
+Version: 0.0.5
 Summary: 
 Author: alexey
 Author-email: alexey <me@pyrorhythm.dev>
-Requires-Dist: aiohttp>=3.13.3
+Requires-Dist: aiohttp>=3.13.0
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: pydantic>=2.12.5
-Requires-Dist: redis>=7.1.0
-Requires-Dist: sqlalchemy[asyncio]>=2.0.46
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: redis>=6.4.0,<8.0.0
+Requires-Dist: sqlalchemy[asyncio]>=2.0.0
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 

{sotkalib-0.0.4 → sotkalib-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sotkalib"
-version = "0.0.4"
+version = "0.0.5"
 description = ""
 authors = [
     { email = "me@pyrorhythm.dev", name = "alexey" }
@@ -8,12 +8,12 @@ authors = [
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
-    "aiohttp>=3.13.3",
+    "aiohttp>=3.13.0",
     "dotenv>=0.9.9",
     "loguru>=0.7.3",
-    "pydantic>=2.12.5",
-    "redis>=7.1.0",
-    "sqlalchemy[asyncio]>=2.0.46",
+    "pydantic>=2.12.0",
+    "redis>=6.4.0,<8.0.0",
+    "sqlalchemy[asyncio]>=2.0.0",
 ]
 
 

{sotkalib-0.0.4 → sotkalib-0.0.5}/src/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-0.0.4 → sotkalib-0.0.5}/src/sotkalib/config/__init__.py

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

{sotkalib-0.0.4 → sotkalib-0.0.5}/src/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-0.0.5/src/sotkalib/enum/mixins.py

@@ -0,0 +1,59 @@
+from collections.abc import Sequence
+from enum import Enum
+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()
+
+
+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)

sotkalib-0.0.5/src/sotkalib/exceptions/__init__.py

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

sotkalib-0.0.5/src/sotkalib/exceptions/api/__init__.py

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

{sotkalib-0.0.4 → sotkalib-0.0.5}/src/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-0.0.4 → sotkalib-0.0.5}/src/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-0.0.4 → sotkalib-0.0.5}/src/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-0.0.5/src/sotkalib/http/client_session.py

@@ -0,0 +1,457 @@
+import asyncio
+import ssl
+import time
+from collections.abc import Awaitable, Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+from http import HTTPStatus
+from typing import Any, Literal, Self
+
+import aiohttp
+from aiohttp import client_exceptions
+from pydantic import BaseModel, ConfigDict, Field
+
+from sotkalib.log import get_logger
+
+MAXIMUM_BACKOFF: float = 120
+
+try:
+	import certifi
+except ImportError:
+	certifi = None
+
+
+class RanOutOfAttemptsError(Exception):
+	pass
+
+
+class CriticalStatusError(Exception):
+	pass
+
+
+class StatusRetryError(Exception):
+	status: int
+	context: str
+
+	def __init__(self, status: int, context: str) -> None:
+		super().__init__(f"{status}: {context}")
+		self.status = status
+		self.context = context
+
+
+@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[..., tuple[Sequence[Any], Mapping[str, Any] | None]]
+type StatArgFunc = Callable[..., Any]
+
+
+async def default_stat_arg_func(resp: aiohttp.ClientResponse) -> tuple[Sequence[Any], None]:
+	return (f"[{resp.status}]; {await resp.text()=}",), None
+
+
+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 StatusSettings(BaseModel):
+	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)
+	args_for_exc_func: StatArgFunc = Field(default=default_stat_arg_func)
+	unspecified: Literal["retry", "raise"] = Field(default="retry")
+
+
+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,
+		),
+	)
+
+	to_retry: tuple[type[Exception], ...] = Field(
+		default=(
+			TimeoutError,
+			client_exceptions.ServerDisconnectedError,
+			client_exceptions.ClientConnectionResetError,
+			client_exceptions.ClientOSError,
+			client_exceptions.ClientHttpProxyError,
+		),
+	)
+
+	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 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)
+
+	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)
+
+
+# ============================================================================
+# SSL Context
+# ============================================================================
+
+
+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
+
+
+# ============================================================================
+# HTTP Session
+# ============================================================================
+
+
+class HTTPSession[R = aiohttp.ClientResponse | None]:
+	config: ClientSettings
+	_session: aiohttp.ClientSession | None
+	_middlewares: list[Middleware[Any, Any]]
+	_logger: Any
+
+	def __init__(
+		self,
+		config: ClientSettings | 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[NewR](self, middleware: Middleware[R, NewR]) -> HTTPSession[NewR]:
+		return HTTPSession[NewR](
+			config=self.config,
+			_middlewares=[*self._middlewares, middleware],
+		)
+
+	async def __aenter__(self) -> Self:
+		ctx = _make_ssl_context(disable_tls13=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),
+			**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:
+		if self._session:
+			await self._session.close()
+
+	def _build_pipeline(self) -> Next[R]:
+		"""Build the middleware pipeline with the core request at the end."""
+
+		async def core_request(ctx: RequestContext) -> aiohttp.ClientResponse | None:
+			"""The innermost handler that actually makes the HTTP request."""
+			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)
+
+		return pipeline
+
+	async def _execute_request(self, ctx: RequestContext) -> aiohttp.ClientResponse | None:
+		"""Execute the actual HTTP request and handle status codes."""
+		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:
+		"""Handle HTTP status codes according to settings."""
+		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 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 = await settings.args_for_exc_func(response)
+			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
+
+
+	async def _request_with_retry(self, ctx: RequestContext) -> R:
+		"""Execute request with retry logic."""
+		ctx.started_at = time.monotonic()
+		ctx.max_attempts = self.config.maximum_retries + 1
+
+		pipeline = self._build_pipeline()
+
+		for attempt in range(ctx.max_attempts):
+			ctx.attempt = attempt
+			ctx.attempt_started_at = time.monotonic()
+			ctx.response = None
+
+			try:
+				result = await pipeline(ctx)
+				ctx.finished_at = time.monotonic()
+				return result
+
+			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)
+
+			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)
+
+			except Exception as e:
+				ctx.errors.append(e)
+				ctx.last_error = e
+				await self._handle_exception(ctx, e)
+
+		ctx.finished_at = time.monotonic()
+		raise RanOutOfAttemptsError(
+			f"failed after {self.config.maximum_retries} retries: {type(ctx.last_error).__name__}: {ctx.last_error}"
+		)
+
+	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
+
+		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_to_raise(self, ctx: RequestContext, e: Exception) -> None:
+		"""Handle exceptions that should be re-raised (possibly wrapped)."""
+		exc_cls = self.config.exception_settings.exc_to_raise
+		if exc_cls is None:
+			raise e
+
+		args, kwargs = self.config.exception_settings.args_for_exc_func(
+			e, ctx.attempt, ctx.url, ctx.method, **ctx.to_request_kwargs()
+		)
+		if kwargs is None:
+			raise exc_cls(*args) from e
+		raise exc_cls(*args, **kwargs) from e
+
+	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)
+
+	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:
+		"""Make a GET request."""
+		return await self.request("GET", url, **kwargs)
+
+	async def post(self, url: str, **kwargs: Any) -> R:
+		"""Make a POST request."""
+		return await self.request("POST", url, **kwargs)
+
+	async def put(self, url: str, **kwargs: Any) -> R:
+		"""Make a PUT request."""
+		return await self.request("PUT", url, **kwargs)
+
+	async def delete(self, url: str, **kwargs: Any) -> R:
+		"""Make a DELETE request."""
+		return await self.request("DELETE", url, **kwargs)
+
+	async def patch(self, url: str, **kwargs: Any) -> R:
+		"""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-0.0.4 → sotkalib-0.0.5}/src/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-0.0.4 → sotkalib-0.0.5}/src/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-0.0.4 → sotkalib-0.0.5}/src/sotkalib/sqla/__init__.py

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

sotkalib-0.0.5/src/sotkalib/sqla/db.py

@@ -0,0 +1,102 @@
+from pydantic import BaseModel, Field
+from sqlalchemy import Engine, create_engine
+from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
+from sqlalchemy.ext.asyncio.session import AsyncSession
+from sqlalchemy.orm import Session, sessionmaker
+
+from sotkalib.log import get_logger
+
+
+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
+
+	@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

sotkalib-0.0.4/src/sotkalib/enum/mixins.py

@@ -1,59 +0,0 @@
-from collections.abc import Sequence
-from enum import Enum
-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()
-
-
-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)

sotkalib-0.0.4/src/sotkalib/exceptions/__init__.py

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

sotkalib-0.0.4/src/sotkalib/exceptions/api/__init__.py

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

sotkalib-0.0.4/src/sotkalib/http/client_session.py

@@ -1,258 +0,0 @@
-import asyncio
-import ssl
-from collections.abc import Callable, Mapping, Sequence
-from functools import reduce
-from http import HTTPStatus
-from typing import Any, Literal, Protocol, Self
-
-import aiohttp
-from aiohttp import client_exceptions
-from pydantic import BaseModel, ConfigDict, Field
-
-from sotkalib.log import get_logger
-
-MAXIMUM_BACKOFF: float = 120
-
-try:
-	import certifi
-except ImportError:
-	certifi = None
-
-class RanOutOfAttemptsError(Exception):
-	pass
-
-class CriticalStatusError(Exception):
-	pass
-
-class StatusRetryError(Exception):
-	status: int
-	context: str
-
-	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]
-
-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)
-
-	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,
-		),
-	)
-
-	to_retry: tuple[type[Exception]] = Field(
-		default=(
-			TimeoutError,
-			client_exceptions.ServerDisconnectedError,
-			client_exceptions.ClientConnectionResetError,
-			client_exceptions.ClientOSError,
-			client_exceptions.ClientHttpProxyError,
-		),
-	)
-
-	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 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)
-
-	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)
-
-
-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()
-
-	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-0.0.4/src/sotkalib/sqla/db.py

@@ -1,101 +0,0 @@
-from pydantic import BaseModel, Field
-from sqlalchemy import Engine, create_engine
-from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
-from sqlalchemy.ext.asyncio.session import AsyncSession
-from sqlalchemy.orm import Session, sessionmaker
-
-from sotkalib.log import get_logger
-
-
-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
-
-    @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