qena-shared-lib 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

qena_shared_lib/application.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from fastapi import APIRouter, FastAPI
 from fastapi.exceptions import RequestValidationError
@@ -18,6 +18,7 @@ from .http import ControllerBase
 __all__ = [
     "Builder",
     "Environment",
+    "FastAPI",
 ]
 
 D = TypeVar("D")
@@ -29,19 +30,19 @@ class Environment(Enum):
 
 
 class Builder:
-    def __init__(self):
+    def __init__(self) -> None:
         self._environment = Environment.DEVELOPMENT
         self._debug = False
         self._title = "Qena shared lib"
         self._description = "Qena shared tools for microservice"
         self._version = "0.1.0"
         self._lifespan = None
-        self._openapi_url = "/openapi.json"
-        self._docs_url = "/docs"
-        self._redoc_url = "/redoc"
-        self._metrics_endpoint = None
-        self._instrumentator = None
-        self._routers = []
+        self._openapi_url: str | None = "/openapi.json"
+        self._docs_url: str | None = "/docs"
+        self._redoc_url: str | None = "/redoc"
+        self._metrics_endpoint: str | None = None
+        self._instrumentator: Instrumentator | None = None
+        self._routers: list[APIRouter] = []
         self._container = Container()
         self._built = False
 
@@ -107,7 +108,11 @@ class Builder:
         return self
 
     def with_singleton(
-        self, service: type[D], factory=empty, instance=empty, **kwargs
+        self,
+        service: type[D],
+        factory: Any = empty,
+        instance: Any = empty,
+        **kwargs: Any,
     ) -> "Builder":
         self._container.register(
             service=service,
@@ -120,7 +125,7 @@ class Builder:
         return self
 
     def with_transient(
-        self, service: type[D], factory=empty, **kwargs
+        self, service: type[D], factory: Any = empty, **kwargs: Any
     ) -> "Builder":
         self._container.register(
             service=service,
@@ -172,7 +177,7 @@ class Builder:
 
         return app
 
-    def _resolve_api_controllers(self, app: FastAPI):
+    def _resolve_api_controllers(self, app: FastAPI) -> None:
         api_controller_routers = [
             api_controller.register_route_handlers()
             for api_controller in self._container.resolve_all(ControllerBase)

qena_shared_lib/background.py

@@ -28,8 +28,8 @@ class Background(AsyncEventLoopMixin):
     def __init__(
         self,
         logstash: BaseLogstashSender,
-    ):
-        self._queue = Queue()
+    ) -> None:
+        self._queue: Queue[tuple[BackgroundTask | None, str | None]] = Queue()
         self._started = False
         self._stopped = False
         self._logstash = logstash
@@ -38,7 +38,7 @@ class Background(AsyncEventLoopMixin):
 
     async def _task_manager(
         self, task: BackgroundTask, task_id: str | None = None
-    ):
+    ) -> None:
         self._logger.info(
             "running %s: %s with %s", task_id, task.func.__name__, task.args
         )
@@ -60,29 +60,32 @@ class Background(AsyncEventLoopMixin):
             self._logger.info("finished running %s", task.func.__name__)
             self._tasks.pop(task_id, None)
 
-    def _run(self, task: BackgroundTask, task_id: str | None = None):
+    def _run(self, task: BackgroundTask, task_id: str | None = None) -> None:
         if not self._stopped and (
             task_id is None or task_id not in self._tasks
         ):
             self.loop.create_task(self._task_manager(task, task_id))
 
-    async def _run_tasks(self):
+    async def _run_tasks(self) -> None:
         while not self._stopped or not self._queue.empty():
             task, task_id = await self._queue.get()
 
             if task is None and task_id is None:
                 break
 
-            self._run(task=task, task_id=task_id)
+            if task is not None:
+                self._run(task=task, task_id=task_id)
 
         tasks = [t for _, t in self._tasks.items() if not t.done()]
 
         await gather(*tasks)
 
-    def add_task(self, task: BackgroundTask, task_id: str | None = None):
+    def add_task(
+        self, task: BackgroundTask, task_id: str | None = None
+    ) -> None:
         self._queue.put_nowait((task, task_id))
 
-    def start(self):
+    def start(self) -> None:
         if self._started:
             raise RuntimeError("background runner already running")
 
@@ -91,7 +94,7 @@ class Background(AsyncEventLoopMixin):
 
         self._started = True
 
-    def stop(self):
+    def stop(self) -> None:
         if self._stopped:
             raise RuntimeError("background runner already stopped")
 
@@ -99,11 +102,11 @@ class Background(AsyncEventLoopMixin):
         self._queue.put_nowait((None, None))
         self.BACKGROUND_RUNNER_STATE.state("stopped")
 
-    def is_alive(self, task_id: str):
+    def is_alive(self, task_id: str) -> bool:
         if task_id in self._tasks and not self._tasks[task_id].done():
             return True
 
         return False
 
-    def count(self):
+    def count(self) -> int:
         return len(self._tasks)

qena_shared_lib/dependencies/http.py

@@ -27,11 +27,11 @@ def get_container(app: FastAPI) -> Container:
 def add_service(
     app: FastAPI,
     service: type[D],
-    factory=empty,
+    factory: object = empty,
     instance: D = empty,
     scope: Scope = Scope.transient,
-    **kwargs,
-):
+    **kwargs: Any,
+) -> None:
     get_container(app).register(
         service=service,
         factory=factory,

qena_shared_lib/exception_handlers.py

@@ -30,6 +30,7 @@ def handle_http_service_error(
     logger_provider = get_service(app=request.app, service_key=LoggerProvider)
     logger = logger_provider.get_logger("http.exception_handler")
     exception_severity = exception.severity or Severity.LOW
+    user_agent = request.headers.get("user-agent", "__unknown__")
     message = exception.message
     tags = [
         "HTTP",
@@ -41,6 +42,7 @@ def handle_http_service_error(
         "serviceType": "HTTP",
         "method": request.method,
         "path": request.url.path,
+        "userAgent": user_agent,
         "exception": exception.__class__.__name__,
     }
     exc_info = (
@@ -165,6 +167,7 @@ def handle_general_http_exception(
     request: Request, exception: Exception
 ) -> Response:
     logstash = get_service(app=request.app, service_key=BaseLogstashSender)
+    user_agent = request.get("user-agent", "__unknown__")
 
     logstash.error(
         message=f"something went wrong on endpoint `{request.method} {request.url.path}`",
@@ -178,6 +181,7 @@ def handle_general_http_exception(
             "serviceType": "HTTP",
             "method": request.method,
             "path": request.url.path,
+            "userAgent": user_agent,
             "exception": exception.__class__.__name__,
         },
         exception=exception,

qena_shared_lib/exceptions.py

@@ -1,6 +1,8 @@
 from enum import Enum
 from typing import Any
 
+from fastapi import status
+
 __all__ = [
     "BadGateway",
     "BadRequest",
@@ -62,8 +64,8 @@ class Severity(Enum):
 
 
 class ServiceException(Exception):
-    _GENERAL_SEVERITY = None
-    _GENERAL_EXTRACT_EXC_INFO = None
+    _GENERAL_SEVERITY: Severity | None = None
+    _GENERAL_EXTRACT_EXC_INFO: bool | None = None
 
     def __init__(
         self,
@@ -78,8 +80,10 @@ class ServiceException(Exception):
 
         if severity is not None:
             self._severity = severity
-        else:
+        elif self._GENERAL_SEVERITY is not None:
             self._severity = self._GENERAL_SEVERITY
+        else:
+            self._severity = Severity.LOW
 
         self._tags = tags
         self._extra = extra
@@ -91,8 +95,10 @@ class ServiceException(Exception):
 
         if extract_exc_info is not None:
             self._extract_exc_info = extract_exc_info
-        else:
+        elif self._GENERAL_EXTRACT_EXC_INFO is not None:
             self._extract_exc_info = self._GENERAL_EXTRACT_EXC_INFO
+        else:
+            self._extract_exc_info = False
 
     @property
     def message(self) -> str:
@@ -126,7 +132,7 @@ class ServiceException(Exception):
 
 
 class HTTPServiceError(ServiceException):
-    _GENERAL_STATUS_CODE = None
+    _GENERAL_STATUS_CODE: int | None = None
 
     def __init__(
         self,
@@ -152,6 +158,7 @@ class HTTPServiceError(ServiceException):
         )
 
         self._body = body
+        self._status_code: int | None = None
 
         if status_code is not None:
             self._status_code = status_code
@@ -190,178 +197,179 @@ class HTTPServiceError(ServiceException):
 
 
 class ClientError(HTTPServiceError):
-    _GENERAL_EXTRACT_EXC_INFO = False
     _GENERAL_SEVERITY = Severity.MEDIUM
+    _GENERAL_EXTRACT_EXC_INFO = False
 
 
 class BadRequest(ClientError):
-    _GENERAL_STATUS_CODE = 400
+    _GENERAL_STATUS_CODE = status.HTTP_400_BAD_REQUEST
 
 
 class Unauthorized(ClientError):
-    _GENERAL_STATUS_CODE = 401
+    _GENERAL_STATUS_CODE = status.HTTP_401_UNAUTHORIZED
 
 
 class PaymentRequired(ClientError):
-    _GENERAL_STATUS_CODE = 402
+    _GENERAL_STATUS_CODE = status.HTTP_402_PAYMENT_REQUIRED
 
 
 class Forbidden(ClientError):
-    _GENERAL_STATUS_CODE = 403
+    _GENERAL_STATUS_CODE = status.HTTP_403_FORBIDDEN
 
 
 class NotFound(ClientError):
-    _GENERAL_STATUS_CODE = 404
+    _GENERAL_STATUS_CODE = status.HTTP_404_NOT_FOUND
 
 
 class MethodNotAllowed(ClientError):
-    _GENERAL_STATUS_CODE = 405
+    _GENERAL_STATUS_CODE = status.HTTP_405_METHOD_NOT_ALLOWED
 
 
 class NotAcceptable(ClientError):
-    _GENERAL_STATUS_CODE = 406
+    _GENERAL_STATUS_CODE = status.HTTP_406_NOT_ACCEPTABLE
 
 
 class ProxyAuthenticationRequired(ClientError):
-    _GENERAL_STATUS_CODE = 407
+    _GENERAL_STATUS_CODE = status.HTTP_407_PROXY_AUTHENTICATION_REQUIRED
 
 
 class RequestTimeout(ClientError):
-    _GENERAL_STATUS_CODE = 408
+    _GENERAL_STATUS_CODE = status.HTTP_408_REQUEST_TIMEOUT
 
 
 class Conflict(ClientError):
-    _GENERAL_STATUS_CODE = 409
+    _GENERAL_STATUS_CODE = status.HTTP_409_CONFLICT
 
 
 class Gone(ClientError):
-    _GENERAL_STATUS_CODE = 410
+    _GENERAL_STATUS_CODE = status.HTTP_410_GONE
 
 
 class LengthRequired(ClientError):
-    _GENERAL_STATUS_CODE = 411
+    _GENERAL_STATUS_CODE = status.HTTP_411_LENGTH_REQUIRED
 
 
 class PreconditionFailed(ClientError):
-    _GENERAL_STATUS_CODE = 412
+    _GENERAL_STATUS_CODE = status.HTTP_412_PRECONDITION_FAILED
 
 
 class PayloadTooLarge(ClientError):
-    _GENERAL_STATUS_CODE = 413
+    _GENERAL_STATUS_CODE = status.HTTP_413_REQUEST_ENTITY_TOO_LARGE
 
 
 class URITooLong(ClientError):
-    _GENERAL_STATUS_CODE = 414
+    _GENERAL_STATUS_CODE = status.HTTP_414_REQUEST_URI_TOO_LONG
 
 
 class UnsupportedMediaType(ClientError):
-    _GENERAL_STATUS_CODE = 415
+    _GENERAL_STATUS_CODE = status.HTTP_415_UNSUPPORTED_MEDIA_TYPE
 
 
 class RangeNotSatisfiable(ClientError):
-    _GENERAL_STATUS_CODE = 416
+    _GENERAL_STATUS_CODE = status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE
 
 
 class ExpectationFailed(ClientError):
-    _GENERAL_STATUS_CODE = 417
+    _GENERAL_STATUS_CODE = status.HTTP_417_EXPECTATION_FAILED
 
 
 class IAmATeapot(ClientError):
-    _GENERAL_STATUS_CODE = 418
+    _GENERAL_STATUS_CODE = status.HTTP_418_IM_A_TEAPOT
 
 
 class MisdirectedRequest(ClientError):
-    _GENERAL_STATUS_CODE = 421
+    _GENERAL_STATUS_CODE = status.HTTP_421_MISDIRECTED_REQUEST
 
 
 class UnprocessableEntity(ClientError):
-    _GENERAL_STATUS_CODE = 422
+    _GENERAL_STATUS_CODE = status.HTTP_422_UNPROCESSABLE_ENTITY
 
 
 class Locked(ClientError):
-    _GENERAL_STATUS_CODE = 423
+    _GENERAL_STATUS_CODE = status.HTTP_423_LOCKED
 
 
 class FailedDependency(ClientError):
-    _GENERAL_STATUS_CODE = 424
+    _GENERAL_STATUS_CODE = status.HTTP_424_FAILED_DEPENDENCY
 
 
 class TooEarly(ClientError):
-    _GENERAL_STATUS_CODE = 425
+    _GENERAL_STATUS_CODE = status.HTTP_425_TOO_EARLY
 
 
 class UpgradeRequired(ClientError):
-    _GENERAL_STATUS_CODE = 426
+    _GENERAL_STATUS_CODE = status.HTTP_426_UPGRADE_REQUIRED
 
 
 class PreconditionRequired(ClientError):
-    _GENERAL_STATUS_CODE = 428
+    _GENERAL_STATUS_CODE = status.HTTP_428_PRECONDITION_REQUIRED
 
 
 class TooManyRequests(ClientError):
-    _GENERAL_STATUS_CODE = 429
+    _GENERAL_STATUS_CODE = status.HTTP_429_TOO_MANY_REQUESTS
 
 
 class RequestHeaderFieldsTooLarge(ClientError):
-    _GENERAL_STATUS_CODE = 431
+    _GENERAL_STATUS_CODE = status.HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE
 
 
 class UnavailableForLegalReasons(ClientError):
-    _GENERAL_STATUS_CODE = 451
+    _GENERAL_STATUS_CODE = status.HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS
 
 
 class ServerError(HTTPServiceError):
-    _GENERAL_EXTRACT_EXC_INFO = True
     _GENERAL_SEVERITY = Severity.HIGH
+    _GENERAL_EXTRACT_EXC_INFO = True
 
 
 class InternalServerError(ServerError):
-    _GENERAL_STATUS_CODE = 500
+    _GENERAL_STATUS_CODE = status.HTTP_500_INTERNAL_SERVER_ERROR
 
 
 class NotImplemented(ServerError):
-    _GENERAL_STATUS_CODE = 501
+    _GENERAL_STATUS_CODE = status.HTTP_501_NOT_IMPLEMENTED
 
 
 class BadGateway(ServerError):
-    _GENERAL_STATUS_CODE = 502
+    _GENERAL_STATUS_CODE = status.HTTP_502_BAD_GATEWAY
 
 
 class ServiceUnavailable(ServerError):
-    _GENERAL_STATUS_CODE = 503
+    _GENERAL_STATUS_CODE = status.HTTP_503_SERVICE_UNAVAILABLE
 
 
 class GatewayTimeout(ServerError):
-    _GENERAL_STATUS_CODE = 504
+    _GENERAL_STATUS_CODE = status.HTTP_504_GATEWAY_TIMEOUT
 
 
 class HTTPVersionNotSupported(ServerError):
-    _GENERAL_STATUS_CODE = 505
+    _GENERAL_STATUS_CODE = status.HTTP_505_HTTP_VERSION_NOT_SUPPORTED
 
 
 class VariantAlsoNegotiates(ServerError):
-    _GENERAL_STATUS_CODE = 506
+    _GENERAL_STATUS_CODE = status.HTTP_506_VARIANT_ALSO_NEGOTIATES
 
 
 class InsufficientStorage(ServerError):
-    _GENERAL_STATUS_CODE = 507
+    _GENERAL_STATUS_CODE = status.HTTP_507_INSUFFICIENT_STORAGE
 
 
 class LoopDetected(ServerError):
-    _GENERAL_STATUS_CODE = 508
+    _GENERAL_STATUS_CODE = status.HTTP_508_LOOP_DETECTED
 
 
 class NotExtended(ServerError):
-    _GENERAL_STATUS_CODE = 510
+    _GENERAL_STATUS_CODE = status.HTTP_510_NOT_EXTENDED
 
 
 class NetworkAuthenticationRequired(ServerError):
-    _GENERAL_STATUS_CODE = 511
+    _GENERAL_STATUS_CODE = status.HTTP_511_NETWORK_AUTHENTICATION_REQUIRED
 
 
 class RabbitMQServiceException(ServiceException):
     _GENERAL_SEVERITY = Severity.HIGH
-    _GENERAL_CODE = None
+    _GENERAL_EXTRACT_EXC_INFO = True
+    _GENERAL_CODE: int | None = None
 
     def __init__(
         self,
@@ -385,8 +393,10 @@ class RabbitMQServiceException(ServiceException):
 
         if code is not None:
             self._code = code
+        elif self._GENERAL_CODE is not None:
+            self._code = self._GENERAL_CODE
         else:
-            self._code = self._GENERAL_CODE or 0
+            self._code = 0
 
         self._data = data
 

qena_shared_lib/http.py

@@ -2,23 +2,75 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Callable, Sequence, TypeVar
 
-from fastapi import APIRouter, Response
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    Body,
+    Cookie,
+    File,
+    Form,
+    Header,
+    HTTPException,
+    Path,
+    Query,
+    Request,
+    Response,
+    Security,
+    UploadFile,
+    WebSocket,
+    WebSocketDisconnect,
+    WebSocketException,
+    status,
+)
 from fastapi.datastructures import Default
 from fastapi.params import Depends
-from fastapi.responses import JSONResponse
+from fastapi.responses import (
+    FileResponse,
+    HTMLResponse,
+    JSONResponse,
+    PlainTextResponse,
+    RedirectResponse,
+    StreamingResponse,
+)
 from fastapi.types import IncEx
 
 __all__ = [
     "api_controller",
+    "APIRouter",
+    "BackgroundTasks",
+    "Body",
     "ControllerBase",
+    "Cookie",
     "delete",
+    "Depends",
+    "File",
+    "FileResponse",
+    "Form",
     "get",
     "head",
+    "Header",
+    "HTMLResponse",
+    "HTTPException",
+    "JSONResponse",
     "options",
     "patch",
+    "Path",
+    "PlainTextResponse",
     "post",
     "put",
+    "Query",
+    "RedirectResponse",
+    "Request",
+    "Response",
+    "Response",
+    "Security",
+    "status",
+    "StreamingResponse",
     "trace",
+    "UploadFile",
+    "WebSocket",
+    "WebSocketDisconnect",
+    "WebSocketException",
 ]
 
 AC = TypeVar("AC")
@@ -73,7 +125,9 @@ def api_controller(
     deprecated: bool | None = None,
     include_in_schema: bool = True,
 ) -> Callable[[type["ControllerBase"]], type["ControllerBase"]]:
-    def annotate_class(api_controller_class: type[ControllerBase]):
+    def annotate_class(
+        api_controller_class: type[ControllerBase],
+    ) -> type[ControllerBase]:
         router = APIRouter(
             prefix=prefix or "",
             tags=tags,

qena_shared_lib/logging.py

@@ -18,7 +18,7 @@ ROOT_LOGGER_NAME = environ.get("LOGGER_NAME") or "qena_shared_lib"
 
 
 class LoggerProvider:
-    def __init__(self):
+    def __init__(self) -> None:
         logger = self.get_logger()
 
         logger.setLevel(INFO)
@@ -55,9 +55,9 @@ class LoggerProvider:
 
     def _check_handler(
         self, handlers: list[type[Handler]], logger: Optional[Logger] = None
-    ):
+    ) -> None:
         if logger is None:
-            return handlers
+            return
 
         handlers.extend([handler.__class__ for handler in logger.handlers])
         self._check_handler(handlers=handlers, logger=logger.parent)