(pylint) making the linting stricter and cleaner, currently no issues

Author: stefankumarasinghe

CHANGELOG.md

@@ -11,6 +11,8 @@ All notable changes to this project will be documented in this file.
 - Lazily load baseline and granger engine classes via module `__getattr__` hooks to avoid import-time engine dependencies in store modules.
 - Hardened shared Redis patching in resolver tests by importing store modules dynamically and only patching available attributes.
 - Improved exception wrapper tests to preserve original HTTP exception identity and validate sync/async handler shape preservation.
+- Tightened resolver pylint design thresholds and refactored analyzer/connector/rca interfaces to keep strict linting without compatibility regressions.
+- Added structured RCA signal-input wiring and expanded edge-case tests so resolver `mypy`, `pylint`, and `pytest` all pass cleanly at 100% coverage.
 
 ## [v0.0.4] - 2026-04-14
 

api/__init__.py

@@ -1,4 +1,9 @@
-# package marker for api submodules
 """
-Package exports for the `api` module namespace.
+Api module for the resolver package.
+
+Copyright (c) 2026 Stefan Kumarasinghe
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
+License. You may obtain a copy of the License at
+http://www.apache.org/licenses/LICENSE-2.0
 """

api/responses/base.py

@@ -19,17 +19,18 @@
 
 
 def _coerce(obj: SerializableValue) -> SerializableValue:
+    result: SerializableValue = obj
     if isinstance(obj, dict):
-        return {k: _coerce(v) for k, v in obj.items()}
-    if isinstance(obj, list):
-        return [_coerce(v) for v in obj]
-    if isinstance(obj, np.integer):
-        return int(obj)
-    if isinstance(obj, np.floating):
-        return float(obj)
-    if isinstance(obj, np.ndarray):
-        return obj.tolist()
-    return obj
+        result = {k: _coerce(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        result = [_coerce(v) for v in obj]
+    elif isinstance(obj, np.integer):
+        result = int(obj)
+    elif isinstance(obj, np.floating):
+        result = float(obj)
+    elif isinstance(obj, np.ndarray):
+        result = obj.tolist()
+    return result
 
 
 class NpModel(BaseModel):

api/routes/__init__.py

@@ -12,47 +12,33 @@
 
 from fastapi import APIRouter
 
-_router: APIRouter | None = None
-
-
-def _build_router() -> APIRouter:
-	from api.routes.analyze import router as analyze_router
-	from api.routes.causal import router as causal_router
-	from api.routes.correlation import router as correlation_router
-	from api.routes.events import router as events_router
-	from api.routes.forecast import router as forecast_router
-	from api.routes.health import router as health_router
-	from api.routes.jobs import router as jobs_router
-	from api.routes.logs import router as logs_router
-	from api.routes.metrics import router as metrics_router
-	from api.routes.ml import router as ml_router
-	from api.routes.slo import router as slo_router
-	from api.routes.topology import router as topology_router
-	from api.routes.traces import router as traces_router
-
-	router = APIRouter()
-	router.include_router(health_router)
-	router.include_router(analyze_router)
-	router.include_router(metrics_router)
-	router.include_router(logs_router)
-	router.include_router(traces_router)
-	router.include_router(correlation_router)
-	router.include_router(slo_router)
-	router.include_router(topology_router)
-	router.include_router(events_router)
-	router.include_router(forecast_router)
-	router.include_router(causal_router)
-	router.include_router(ml_router)
-	router.include_router(jobs_router)
-	return router
-
-
-def __getattr__(name: str):
-	if name == "router":
-		global _router
-		if _router is None:
-			_router = _build_router()
-		return _router
-	raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+from api.routes.analyze import router as analyze_router
+from api.routes.causal import router as causal_router
+from api.routes.correlation import router as correlation_router
+from api.routes.events import router as events_router
+from api.routes.forecast import router as forecast_router
+from api.routes.health import router as health_router
+from api.routes.jobs import router as jobs_router
+from api.routes.logs import router as logs_router
+from api.routes.metrics import router as metrics_router
+from api.routes.ml import router as ml_router
+from api.routes.slo import router as slo_router
+from api.routes.topology import router as topology_router
+from api.routes.traces import router as traces_router
+
+router = APIRouter()
+router.include_router(health_router)
+router.include_router(analyze_router)
+router.include_router(metrics_router)
+router.include_router(logs_router)
+router.include_router(traces_router)
+router.include_router(correlation_router)
+router.include_router(slo_router)
+router.include_router(topology_router)
+router.include_router(events_router)
+router.include_router(forecast_router)
+router.include_router(causal_router)
+router.include_router(ml_router)
+router.include_router(jobs_router)
 
 __all__ = ["router"]

api/routes/causal.py

@@ -55,7 +55,7 @@ def _common_causes_for_roots(causal_graph: CausalGraph, roots: list[str]) -> dic
 
 async def _fetch_requested_metrics(provider: DataSourceProvider, req: CorrelateRequest) -> list[tuple[str, JSONDict]]:
     queries = list(dict.fromkeys((getattr(req, "metric_queries", None) or []) + DEFAULT_METRIC_QUERIES))
-    return await safe_call(fetch_metrics(provider, queries, req.start, req.end, req.step))
+    return await safe_call(fetch_metrics(provider, queries, req.start, req.end, step=req.step))
 
 
 @router.post(
@@ -66,6 +66,7 @@ async def _fetch_requested_metrics(provider: DataSourceProvider, req: CorrelateR
 @handle_exceptions
 async def granger_causality(
     req: CorrelateRequest,
+    *,
     limit: int = Query(default=100, ge=1, le=2000),
     min_strength: float = Query(default=0.05, ge=0.0, le=1.0),
     max_series: int = Query(default=25, ge=2, le=200),

api/routes/common.py

@@ -84,4 +84,4 @@ async def fetch_requested_metrics(
     req: _MetricRequestLike,
 ) -> list[tuple[str, JSONDict]]:
     queries = list(dict.fromkeys((getattr(req, "metric_queries", None) or []) + DEFAULT_METRIC_QUERIES))
-    return await safe_call(fetch_metrics(provider, queries, req.start, req.end, req.step))
+    return await safe_call(fetch_metrics(provider, queries, req.start, req.end, step=req.step))

api/routes/correlation.py

@@ -45,7 +45,7 @@ async def correlate_signals(req: CorrelateRequest) -> JSONDict:
             start=req.start * 1_000_000_000,
             end=req.end * 1_000_000_000,
         ),
-        fetch_metrics(provider, all_queries, req.start, req.end, req.step),
+        fetch_metrics(provider, all_queries, req.start, req.end, step=req.step),
         return_exceptions=True,
     )
 

api/routes/slo.py

@@ -72,7 +72,15 @@ async def slo_burn(req: SloRequest) -> JSONDict:
             err_vals = err_vals[:n]
             tot_vals = tot_vals[:n]
             err_ts = err_ts[:n]
-        alerts.extend(slo_evaluate(req.service, err_vals, tot_vals, err_ts, req.target_availability))
+        alerts.extend(
+            slo_evaluate(
+                req.service,
+                err_vals,
+                tot_vals,
+                err_ts,
+                target_availability=req.target_availability,
+            )
+        )
         budget = remaining_minutes(req.service, err_vals, tot_vals, req.target_availability)
 
     return {

connectors/common.py

@@ -4,11 +4,12 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Protocol
 
 import httpx
 
-from datasources.helpers import fetch_json
+from datasources.helpers import FetchErrorMessages, FetchRequestOptions, fetch_json
 from datasources.types import JSONDict, QueryParams
 
 
@@ -20,29 +21,43 @@ class _BackendConnector(Protocol):
     def request_headers(self) -> dict[str, str]: ...
 
 
+@dataclass(frozen=True)
+class BackendErrorMessages:
+    invalid: str
+    timeout: str
+    unavailable: str
+
+
 async def query_backend_json(
     connector: _BackendConnector,
-    *,
     path: str,
     params: QueryParams,
-    invalid_msg: str,
-    timeout_msg: str,
-    unavailable_msg: str,
+    messages: BackendErrorMessages | None = None,
 ) -> JSONDict:
+    resolved_messages = messages or BackendErrorMessages(invalid="", timeout="", unavailable="")
+
     headers_getter = getattr(connector, "request_headers", None)
     if callable(headers_getter):
         headers = headers_getter()
     else:
-        legacy_headers_getter = getattr(connector, "_headers", None)
-        headers = legacy_headers_getter() if callable(legacy_headers_getter) else {}
+        fallback_headers_getter = getattr(connector, "_headers", None)
+        headers = fallback_headers_getter() if callable(fallback_headers_getter) else {}
 
     return await fetch_json(
         f"{connector.base_url}{path}",
-        params=params,
-        headers=headers,
-        timeout=connector.timeout,
-        client=connector.client,
-        invalid_msg=invalid_msg,
-        timeout_msg=timeout_msg,
-        unavailable_msg=unavailable_msg,
+        options=FetchRequestOptions(
+            params=params,
+            headers=headers,
+            timeout=connector.timeout,
+            client=connector.client,
+        ),
+        messages=_to_fetch_messages(resolved_messages),
+    )
+
+
+def _to_fetch_messages(messages: BackendErrorMessages) -> FetchErrorMessages:
+    return FetchErrorMessages(
+        invalid_msg=messages.invalid,
+        timeout_msg=messages.timeout,
+        unavailable_msg=messages.unavailable,
     )

connectors/loki.py

@@ -3,7 +3,7 @@
 import httpx
 
 from config import DATASOURCE_TIMEOUT, HEALTH_PATH
-from connectors.common import query_backend_json
+from connectors.common import BackendErrorMessages, query_backend_json
 from datasources.base import LogsConnector
 from datasources.retry import retry
 from datasources.types import JSONDict
@@ -16,10 +16,11 @@ def __init__(
         self,
         base_url: str,
         tenant_id: str,
+        *,
         timeout: int = DATASOURCE_TIMEOUT,
         headers: dict[str, str] | None = None,
     ) -> None:
-        super().__init__(tenant_id, base_url, timeout, headers)
+        super().__init__(tenant_id, base_url, timeout=timeout, headers=headers)
 
     @staticmethod
     def _normalize_query(query: str) -> str:
@@ -36,6 +37,7 @@ async def query_range(
         query: str,
         start: int,
         end: int,
+        *,
         limit: int | None = None,
     ) -> JSONDict:
         params: dict[str, str | int | float | bool] = {
@@ -45,11 +47,14 @@ async def query_range(
         }
         if limit is not None:
             params["limit"] = limit
+        messages = BackendErrorMessages(
+            invalid="Loki query failed",
+            timeout="Loki query timed out",
+            unavailable="Cannot reach Loki at",
+        )
         return await query_backend_json(
             self,
-            path="/loki/api/v1/query_range",
-            params=params,
-            invalid_msg="Loki query failed",
-            timeout_msg="Loki query timed out",
-            unavailable_msg="Cannot reach Loki at",
+            "/loki/api/v1/query_range",
+            params,
+            messages=messages,
         )