audex 1.0.7a3__py3-none-any.whl

audex/lifespan.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import asyncio
+import types
+import typing as t
+
+from audex.helper.mixin import AsyncContextMixin
+from audex.helper.mixin import AsyncLifecycleMixin
+from audex.helper.mixin import ContextMixin
+from audex.helper.mixin import LifecycleMixin
+from audex.helper.mixin import LoggingMixin
+
+
+class LifeSpan(LoggingMixin):
+    __logtag__ = "audex.lifespan"
+
+    def __init__(self, *contexts: object) -> None:
+        super().__init__()
+        self.contexts = contexts
+
+    def append(self, context: object) -> None:
+        self.contexts += (context,)
+
+    async def startup(self) -> t.Self:
+        atasks: list[t.Coroutine[None, None, None]] = []
+        for ctx in self.contexts:
+            if isinstance(ctx, ContextMixin):
+                self.logger.info(f"Initializing context: {ctx!r}")
+                ctx.init()
+            elif isinstance(ctx, AsyncContextMixin):
+                self.logger.info(f"Async initializing context: {ctx!r}")
+                atasks.append(ctx.init())
+
+            if isinstance(ctx, LifecycleMixin):
+                self.logger.info(f"Starting lifecycle: {ctx!r}")
+                ctx.start()
+            elif isinstance(ctx, AsyncLifecycleMixin):
+                self.logger.info(f"Async starting lifecycle: {ctx!r}")
+                atasks.append(ctx.start())
+
+        if atasks:
+            await asyncio.gather(*atasks)
+
+        return self
+
+    async def __aenter__(self) -> t.Self:
+        return await self.startup()
+
+    async def shutdown(self) -> None:
+        atasks: list[t.Coroutine[None, None, None]] = []
+        for ctx in self.contexts:
+            if isinstance(ctx, ContextMixin):
+                self.logger.info(f"Closing context: {ctx!r}")
+                ctx.close()
+            elif isinstance(ctx, AsyncContextMixin):
+                self.logger.info(f"Async closing context: {ctx!r}")
+                atasks.append(ctx.close())
+
+            if isinstance(ctx, LifecycleMixin):
+                self.logger.info(f"Stopping lifecycle: {ctx!r}")
+                ctx.stop()
+            elif isinstance(ctx, AsyncLifecycleMixin):
+                self.logger.info(f"Async stopping lifecycle: {ctx!r}")
+                atasks.append(ctx.stop())
+
+        if atasks:
+            await asyncio.gather(*atasks)
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None:
+        await self.shutdown()

audex/service/__init__.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import typing as t
+
+from audex.helper.mixin import LoggingMixin
+from audex.lib.cache import KVCache
+from audex.lib.repos.doctor import DoctorRepository
+from audex.lib.session import SessionManager
+
+
+class BaseService(LoggingMixin):
+    __logtag__ = "audex.service"
+
+    def __init_subclass__(cls, **kwargs: t.Any) -> None:
+        cls.__logtag__ = f"audex.service:{cls.__name__}"
+        super().__init_subclass__(**kwargs)
+
+    def __init__(
+        self,
+        session_manager: SessionManager,
+        cache: KVCache,
+        doctor_repo: DoctorRepository,
+    ):
+        super().__init__()
+        self.session_manager = session_manager
+        self.cache = cache
+        self.doctor_repo = doctor_repo

audex/service/decorators.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import functools as ft
+import typing as t
+
+from audex.exceptions import PermissionDeniedError
+
+if t.TYPE_CHECKING:
+    from audex.service import BaseService
+
+    ServiceMethodT = t.TypeVar("ServiceMethodT", bound=t.Callable[..., t.Awaitable[t.Any]])
+
+
+def require_auth(func: ServiceMethodT) -> ServiceMethodT:
+    """Decorator to require authentication for service methods.
+
+    This decorator checks if the user is authenticated before allowing
+    access to the decorated service method. If the user is not authenticated,
+    an exception is raised.
+
+    Args:
+        func: The service method to decorate.
+
+    Returns:
+        The decorated service method with authentication check.
+    """
+
+    @ft.wraps(func)
+    async def wrapper(self: BaseService, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        if doctor_id := await self.session_manager.get_doctor_id():
+            if await self.cache.contains(self.cache.key_builder.build("doctor", doctor_id)):
+                return await func(self, *args, **kwargs)
+            if (await self.doctor_repo.read(doctor_id)) is not None:
+                await self.cache.setx(self.cache.key_builder.build("doctor", doctor_id), True)
+                return await func(self, *args, **kwargs)
+            await self.session_manager.logout()
+            await self.cache.set_negative(self.cache.key_builder.build("doctor", doctor_id))
+            raise PermissionDeniedError("Authentication required to access this method.")
+        raise PermissionDeniedError("Authentication required to access this method.")
+
+    return wrapper  # type: ignore
+
+
+def log_call(func: ServiceMethodT) -> ServiceMethodT:
+    """Decorator to log calls to service methods.
+
+    This decorator logs the invocation of the decorated service method,
+    including its name and arguments.
+
+    Args:
+        func: The service method to decorate.
+
+    Returns:
+        The decorated service method with logging.
+    """
+
+    @ft.wraps(func)
+    async def wrapper(self: BaseService, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        op = func.__name__
+        msg = f"Calling {op} with args={args} kwargs={kwargs}"
+        if doc_id := self.session_manager.get_doctor_id():
+            msg += f" [Doctor ID: {doc_id}]"
+
+        self.logger.info(msg)
+        try:
+            result = await func(self, *args, **kwargs)
+            self.logger.info(f"{op} completed successfully.")
+            return result
+        except Exception as e:
+            self.logger.error(f"{op} failed with error: {e}")
+            raise
+
+    return wrapper  # type: ignore