sotkalib 0.0.3__tar.gz → 0.0.4.post1__tar.gz

{sotkalib-0.0.3 → sotkalib-0.0.4.post1}/PKG-INFO

@@ -1,14 +1,15 @@
 Metadata-Version: 2.3
 Name: sotkalib
-Version: 0.0.3
+Version: 0.0.4.post1
 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: 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.3 → sotkalib-0.0.4.post1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sotkalib"
-version = "0.0.3"
+version = "0.0.4.post1"
 description = ""
 authors = [
     { email = "me@pyrorhythm.dev", name = "alexey" }
@@ -8,11 +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",
+    "pydantic>=2.12.0",
+    "redis>=6.4.0,<8.0.0",
+    "sqlalchemy[asyncio]>=2.0.0",
 ]
 
 

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

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

sotkalib-0.0.4.post1/src/sotkalib/config/field.py

@@ -0,0 +1,11 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+
+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

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

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

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

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

{sotkalib-0.0.3 → sotkalib-0.0.4.post1}/src/sotkalib/exceptions/api/exc.py

@@ -7,7 +7,6 @@ from pydantic import BaseModel
 
 class ErrorSchema(BaseModel):
 	code: str | None = None
-	phrase: str | None = None
 	desc: str | None = None
 	ctx: Mapping[str, Any] | str | list[Any] | None = None
 
@@ -41,14 +40,12 @@ class APIError(BaseHTTPError):
 			status = http.HTTPStatus(status)
 
 		self.status = status
-		self.phrase = status.phrase
 		self.code = code
 		self.desc = desc
 		self.ctx = ctx
 
 		self.schema = ErrorSchema(
 			code=self.code,
-			phrase=self.phrase,
 			desc=self.desc,
 			ctx=self.ctx,
 		)

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

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

{sotkalib-0.0.3 → sotkalib-0.0.4.post1}/src/sotkalib/exceptions/handlers/args_incl_error.py

@@ -11,11 +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
-				| {
-					"frame_name": frame.f_code.co_name,
-				}
-				| f_locals
-			)
+			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.3 → sotkalib-0.0.4.post1}/src/sotkalib/http/__init__.py

@@ -1,14 +1,14 @@
 from .client_session import (
-	ClientSession,
 	ClientSettings,
 	ExceptionSettings,
 	Handler,
+	HTTPSession,
 	Middleware,
 	StatusSettings,
 )
 
 __all__ = (
-	"ClientSession",
+	"HTTPSession",
 	"ExceptionSettings",
 	"StatusSettings",
 	"ClientSettings",

{sotkalib-0.0.3 → sotkalib-0.0.4.post1}/src/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,18 +11,18 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from sotkalib.log import get_logger
 
+MAXIMUM_BACKOFF: float = 120
+
 try:
-	certifi = importlib.import_module("certifi")
+	import certifi
 except ImportError:
 	certifi = None
 
-
-MAXIMUM_BACKOFF: float = 120
-
-
-class RunOutOfAttemptsError(Exception):
+class RanOutOfAttemptsError(Exception):
 	pass
 
+class CriticalStatusError(Exception):
+	pass
 
 class StatusRetryError(Exception):
 	status: int
@@ -33,10 +33,11 @@ class StatusRetryError(Exception):
 		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)
@@ -45,8 +46,11 @@ class StatusSettings(BaseModel):
 	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)
@@ -70,7 +74,7 @@ class ExceptionSettings(BaseModel):
 	)
 
 	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")
 
 
@@ -89,11 +93,11 @@ class ClientSettings(BaseModel):
 	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:
@@ -119,22 +123,23 @@ def _make_ssl_context(disable_tls13: bool = False) -> ssl.SSLContext:
 	return ctx
 
 
-class ClientSession[R = aiohttp.ClientResponse | None]:
+
+class HTTPSession[R = aiohttp.ClientResponse | None]:
 	config: ClientSettings
 	_session: aiohttp.ClientSession
-	_middlewares: list[Callable[[Handler[Any]], Handler[Any]]]
+	_middlewares: list[Middleware]
 
 	def __init__(
 		self,
 		config: ClientSettings | None = None,
-		_middlewares: list[Callable[[Handler[Any]], Handler[Any]]] | 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[NewR](self, mw: Middleware[R, NewR]) -> ClientSession[NewR]:
-		new_session: ClientSession[NewR] = ClientSession(
+	def use[**P, NewR](self, mw: Middleware[P, R, NewR]) -> HTTPSession[NewR]:
+		new_session: HTTPSession[NewR] = HTTPSession(
 			config=self.config,
 			_middlewares=[*self._middlewares, mw],
 		)
@@ -159,75 +164,81 @@ class ClientSession[R = aiohttp.ClientResponse | None]:
 
 		return self
 
-	async def __aexit__(self, exc_type, exc_val, exc_tb):
+	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:
-			raise self.config.status_settings.exc_to_raise(f"status code: {sc} | {await response.text()}")
+			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) -> Handler[R]:
+	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))
 
-		handler: Handler[Any] = _make_request
-		for mw in reversed(self._middlewares):
-			handler = mw(handler)
-
-		return handler
+		return reduce(lambda t, s: s(t), reversed(self._middlewares), _make_request)
 
 	async def _handle_request(
 		self,
 		method: str,
 		url: str,
-		make_request_func: Handler[R],
-		**kw,
+		make_request_func: Callable[..., Any],
+		**kw: Any,
 	) -> 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)
+			kw["headers"] = kw.get("headers", {}) | user_agent_header
+
+		return await make_request_func(method, url, **kw)
 
-	async def _handle_retry(self, attempt: int, e: Exception, _: str, __: str, **___) -> None:
+	async def _handle_retry(self, e: Exception, attempt: int, url: str, method: str, **kws: Any) -> None:
 		if attempt == self.config.maximum_retries:
-			raise RunOutOfAttemptsError(f"failed after {self.config.maximum_retries} retries: {type(e)} {e}") from e
+			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, url: str, method: str, **kw) -> None:
+	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
 
-		raise self.config.exception_settings.exc_to_raise(f"EXC: {type(e)} {e}; {url} {method} {kw}") from 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, url: str, method: str, attempt: int, **kw) -> None:
+	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(attempt, e, url, method, **kw)
+		await self._handle_retry(e, attempt, url, method, **kw)
 
-	async def _request_with_retry(self, method: str, url: str, **kw) -> R:
+	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(attempt, e, url, method, **kw)
+				await self._handle_retry(e, attempt, url, method, **kw)
 			except self.config.exception_settings.to_raise as e:
-				await self._handle_to_raise(e, url, method, **kw)
+				await self._handle_to_raise(e, attempt, url, method, **kw)
 			except Exception as e:
-				await self._handle_exception(e, url, method, attempt, **kw)
+				await self._handle_exception(e, attempt, url, method, **kw)
 
 		return await _make_request()
 

sotkalib-0.0.4.post1/src/sotkalib/log/factory.py

@@ -0,0 +1,12 @@
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    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(".", " -> "))

sotkalib-0.0.4.post1/src/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-0.0.3 → sotkalib-0.0.4.post1}/src/sotkalib/redis/lock.py

@@ -1,13 +1,11 @@
 import asyncio
 from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from time import time
 from typing import Any
 
 from redis.asyncio import Redis
 
-from sotkalib.redis.client import RedisPool
-
 
 class ContextLockError(Exception):
 	def __init__(self, *args, can_retry: bool = True):
@@ -15,27 +13,18 @@ class ContextLockError(Exception):
 		self.can_retry = can_retry
 
 
-async def _try_acquire(rc: Redis, key_to_lock: str, acquire_timeout: int) -> bool:
+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(
+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:
-	"""
-	Wait until lock is free with exponential backoff.
-
-	:param key_to_lock: Redis key for the lock
-	:param lock_timeout: Maximum time to wait in seconds
-	:param base_delay: Initial delay between checks in seconds
-	:param max_delay: Maximum delay between checks in seconds
-	:raises ContextLockError: If timeout is reached
-	"""
 	start = time()
 	attempt = 0
 	while await client.get(key_to_lock) is not None:
@@ -51,7 +40,7 @@ async def wait_till_lock_free(
 
 @asynccontextmanager
 async def redis_context_lock(
-	client: Redis | RedisPool,
+	client: AbstractAsyncContextManager[Redis],
 	key_to_lock: str,
 	can_retry_if_lock_catched: bool = True,
 	wait_for_lock: bool = False,
@@ -62,21 +51,25 @@ async def redis_context_lock(
 	"""
 	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)
+			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)
+			acquired = await __try_acquire(rc, key_to_lock, acquire_timeout)
 			if not acquired:
 				raise ContextLockError(
 					f"{key_to_lock} lock already acquired",

sotkalib-0.0.4.post1/src/sotkalib/sqla/__init__.py

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

sotkalib-0.0.4.post1/src/sotkalib/sqla/db.py

@@ -0,0 +1,101 @@
+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.3/src/sotkalib/__init__.py

@@ -1,5 +0,0 @@
-"""
-
-Library with utils, made for s0tka.ru
-
-"""

sotkalib-0.0.3/src/sotkalib/config/field.py

@@ -1,27 +0,0 @@
-from collections.abc import Callable
-from dataclasses import dataclass
-
-type AllowedTypes = int | float | complex | str | bool | None
-
-
-@dataclass(init=True, slots=True, frozen=True)
-class SettingsField[T: AllowedTypes]:
-    """
-
-    Typed field declaration for AppSettings.
-
-    **Parameters:**
-
-    - `T`: Python type of the value (see AllowedTypes).
-
-    **Attributes:**
-
-    - `default`: Optional fallback value when the variable is missing.
-    - `factory`: A callable returning a value, or a name of a @property on the class that will be evaluated after initialization.
-    - `nullable`: Whether None is allowed when no value is provided and no default/factory is set.
-
-    """
-
-    default: T | None = None
-    factory: Callable[[], T] | str | None = None
-    nullable: bool = False

sotkalib-0.0.3/src/sotkalib/log/factory.py

@@ -1,29 +0,0 @@
-from functools import lru_cache
-from typing import TYPE_CHECKING
-
-from loguru import logger
-
-if TYPE_CHECKING:
-    from loguru import Logger
-
-
-@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('.', ' -> ')} ")