fix pylint, pyright and ruff errors in resource/propagator config

- _resource.py: refactor _coerce_attribute_value to dispatch table to
  avoid too-many-return-statements; fix short variable names k/v ->
  attr_key/attr_val; fix return type of _sdk_default_attributes to
  dict[str, str] to satisfy pyright
- _propagator.py: rename short variable names e -> exc, p -> propagator
- test_resource.py: move imports to top level; split TestCreateResource
  (25 methods) into three focused classes to satisfy too-many-public-methods
- test_propagator.py: add pylint disable for protected-access

Assisted-by: Claude Sonnet 4.6

Author: MikeGoldsmith

opentelemetry-sdk/src/opentelemetry/sdk/_configuration/_propagator.py

@@ -24,6 +24,8 @@
 from opentelemetry.sdk._configuration._exceptions import ConfigurationError
 from opentelemetry.sdk._configuration.models import (
     Propagator as PropagatorConfig,
+)
+from opentelemetry.sdk._configuration.models import (
     TextMapPropagator as TextMapPropagatorConfig,
 )
 from opentelemetry.trace.propagation.tracecontext import (
@@ -37,9 +39,7 @@
 def _load_entry_point_propagator(name: str) -> TextMapPropagator:
     """Load a propagator by name from the opentelemetry_propagator entry point group."""
     try:
-        eps = list(
-            entry_points(group="opentelemetry_propagator", name=name)
-        )
+        eps = list(entry_points(group="opentelemetry_propagator", name=name))
         if not eps:
             raise ConfigurationError(
                 f"Propagator '{name}' not found. "
@@ -48,10 +48,10 @@ def _load_entry_point_propagator(name: str) -> TextMapPropagator:
         return eps[0].load()()
     except ConfigurationError:
         raise
-    except Exception as e:
+    except Exception as exc:
         raise ConfigurationError(
-            f"Failed to load propagator '{name}': {e}"
-        ) from e
+            f"Failed to load propagator '{name}': {exc}"
+        ) from exc
 
 
 def _propagators_from_textmap_config(
@@ -91,25 +91,24 @@ def create_propagator(
     propagators: list[TextMapPropagator] = []
     seen_types: set[type] = set()
 
-    def _add_deduped(p: TextMapPropagator) -> None:
-        if type(p) not in seen_types:
-            seen_types.add(type(p))
-            propagators.append(p)
+    def _add_deduped(propagator: TextMapPropagator) -> None:
+        if type(propagator) not in seen_types:
+            seen_types.add(type(propagator))
+            propagators.append(propagator)
 
     # Process structured composite list
     if config.composite:
         for entry in config.composite:
-            for p in _propagators_from_textmap_config(entry):
-                _add_deduped(p)
+            for propagator in _propagators_from_textmap_config(entry):
+                _add_deduped(propagator)
 
     # Process composite_list (comma-separated propagator names via entry_points)
     if config.composite_list:
         for name in config.composite_list.split(","):
             name = name.strip()
             if not name or name.lower() == "none":
                 continue
-            p = _load_entry_point_propagator(name)
-            _add_deduped(p)
+            _add_deduped(_load_entry_point_propagator(name))
 
     return CompositePropagator(propagators)
 

opentelemetry-sdk/src/opentelemetry/sdk/_configuration/_resource.py

@@ -21,19 +21,40 @@
 from opentelemetry.sdk._configuration.models import (
     AttributeNameValue,
     AttributeType,
-    Resource as ResourceConfig,
 )
+from opentelemetry.sdk._configuration.models import Resource as ResourceConfig
 from opentelemetry.sdk.resources import (
+    _OPENTELEMETRY_SDK_VERSION,
     SERVICE_NAME,
     TELEMETRY_SDK_LANGUAGE,
     TELEMETRY_SDK_NAME,
     TELEMETRY_SDK_VERSION,
     Resource,
-    _OPENTELEMETRY_SDK_VERSION,
 )
 
 _logger = logging.getLogger(__name__)
 
+# Dispatch table for scalar type coercions
+_SCALAR_COERCIONS = {
+    AttributeType.string: str,
+    AttributeType.int: int,
+    AttributeType.double: float,
+}
+
+# Dispatch table for array type coercions
+_ARRAY_COERCIONS = {
+    AttributeType.string_array: str,
+    AttributeType.bool_array: bool,
+    AttributeType.int_array: int,
+    AttributeType.double_array: float,
+}
+
+
+def _coerce_bool(value: object) -> bool:
+    if isinstance(value, str):
+        return value.lower() not in ("false", "0", "")
+    return bool(value)
+
 
 def _coerce_attribute_value(attr: AttributeNameValue) -> object:
     """Coerce an attribute value to the correct Python type based on AttributeType."""
@@ -42,26 +63,14 @@ def _coerce_attribute_value(attr: AttributeNameValue) -> object:
 
     if attr_type is None:
         return value
-
-    if attr_type == AttributeType.string:
-        return str(value)
     if attr_type == AttributeType.bool:
-        if isinstance(value, str):
-            return value.lower() not in ("false", "0", "")
-        return bool(value)
-    if attr_type == AttributeType.int:
-        return int(value)  # type: ignore[arg-type]
-    if attr_type == AttributeType.double:
-        return float(value)  # type: ignore[arg-type]
-    if attr_type == AttributeType.string_array:
-        return [str(v) for v in value]  # type: ignore[union-attr]
-    if attr_type == AttributeType.bool_array:
-        return [bool(v) for v in value]  # type: ignore[union-attr]
-    if attr_type == AttributeType.int_array:
-        return [int(v) for v in value]  # type: ignore[union-attr,arg-type]
-    if attr_type == AttributeType.double_array:
-        return [float(v) for v in value]  # type: ignore[union-attr,arg-type]
-
+        return _coerce_bool(value)
+    scalar_coercer = _SCALAR_COERCIONS.get(attr_type)
+    if scalar_coercer is not None:
+        return scalar_coercer(value)  # type: ignore[arg-type]
+    array_coercer = _ARRAY_COERCIONS.get(attr_type)
+    if array_coercer is not None:
+        return [array_coercer(item) for item in value]  # type: ignore[union-attr,arg-type]
     return value
 
 
@@ -87,7 +96,7 @@ def _parse_attributes_list(attributes_list: str) -> dict[str, str]:
     return result
 
 
-def _sdk_default_attributes() -> dict[str, object]:
+def _sdk_default_attributes() -> dict[str, str]:
     """Return the SDK telemetry attributes (equivalent to Java's Resource.getDefault())."""
     return {
         TELEMETRY_SDK_LANGUAGE: "python",
@@ -125,9 +134,9 @@ def create_resource(config: Optional[ResourceConfig]) -> Resource:
     if config.attributes_list:
         list_attrs = _parse_attributes_list(config.attributes_list)
         # attributes_list entries do not override explicit attributes
-        for k, v in list_attrs.items():
-            if k not in config_attrs:
-                config_attrs[k] = v
+        for attr_key, attr_val in list_attrs.items():
+            if attr_key not in config_attrs:
+                config_attrs[attr_key] = attr_val
 
     schema_url = config.schema_url
 

opentelemetry-sdk/tests/_configuration/test_propagator.py

@@ -15,6 +15,9 @@
 import unittest
 from unittest.mock import MagicMock, patch
 
+# CompositePropagator stores its propagators in _propagators (private).
+# We access it here to assert composition correctness.
+# pylint: disable=protected-access
 from opentelemetry.baggage.propagation import W3CBaggagePropagator
 from opentelemetry.propagators.composite import CompositePropagator
 from opentelemetry.sdk._configuration._propagator import (
@@ -24,6 +27,8 @@
 from opentelemetry.sdk._configuration.file._loader import ConfigurationError
 from opentelemetry.sdk._configuration.models import (
     Propagator as PropagatorConfig,
+)
+from opentelemetry.sdk._configuration.models import (
     TextMapPropagator as TextMapPropagatorConfig,
 )
 from opentelemetry.trace.propagation.tracecontext import (
@@ -49,7 +54,8 @@ def test_tracecontext_only(self):
         result = create_propagator(config)
         self.assertEqual(len(result._propagators), 1)  # type: ignore[attr-defined]
         self.assertIsInstance(
-            result._propagators[0], TraceContextTextMapPropagator  # type: ignore[attr-defined]
+            result._propagators[0],
+            TraceContextTextMapPropagator,  # type: ignore[attr-defined]
         )
 
     def test_baggage_only(self):
@@ -70,7 +76,8 @@ def test_tracecontext_and_baggage(self):
         result = create_propagator(config)
         self.assertEqual(len(result._propagators), 2)  # type: ignore[attr-defined]
         self.assertIsInstance(
-            result._propagators[0], TraceContextTextMapPropagator  # type: ignore[attr-defined]
+            result._propagators[0],
+            TraceContextTextMapPropagator,  # type: ignore[attr-defined]
         )
         self.assertIsInstance(result._propagators[1], W3CBaggagePropagator)  # type: ignore[attr-defined]
 
@@ -152,9 +159,7 @@ def fake_entry_points(group, name):
             "opentelemetry.sdk._configuration._propagator.entry_points",
             side_effect=fake_entry_points,
         ):
-            config = PropagatorConfig(
-                composite_list="tracecontext,baggage"
-            )
+            config = PropagatorConfig(composite_list="tracecontext,baggage")
             result = create_propagator(config)
 
         self.assertEqual(len(result._propagators), 2)  # type: ignore[attr-defined]

opentelemetry-sdk/tests/_configuration/test_resource.py

@@ -12,14 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 import unittest
+from unittest.mock import patch
 
 from opentelemetry.sdk._configuration._resource import create_resource
 from opentelemetry.sdk._configuration.models import (
     AttributeNameValue,
     AttributeType,
-    Resource as ResourceConfig,
 )
+from opentelemetry.sdk._configuration.models import Resource as ResourceConfig
 from opentelemetry.sdk.resources import (
     SERVICE_NAME,
     TELEMETRY_SDK_LANGUAGE,
@@ -29,7 +31,7 @@
 )
 
 
-class TestCreateResource(unittest.TestCase):
+class TestCreateResourceDefaults(unittest.TestCase):
     def test_none_config_returns_sdk_defaults(self):
         resource = create_resource(None)
         self.assertIsInstance(resource, Resource)
@@ -38,17 +40,15 @@ def test_none_config_returns_sdk_defaults(self):
             resource.attributes[TELEMETRY_SDK_NAME], "opentelemetry"
         )
         self.assertIn(TELEMETRY_SDK_VERSION, resource.attributes)
-        self.assertEqual(
-            resource.attributes[SERVICE_NAME], "unknown_service"
-        )
+        self.assertEqual(resource.attributes[SERVICE_NAME], "unknown_service")
 
     def test_none_config_does_not_read_env_vars(self):
-        import os
-        from unittest.mock import patch
-
         with patch.dict(
             os.environ,
-            {"OTEL_RESOURCE_ATTRIBUTES": "foo=bar", "OTEL_SERVICE_NAME": "my-service"},
+            {
+                "OTEL_RESOURCE_ATTRIBUTES": "foo=bar",
+                "OTEL_SERVICE_NAME": "my-service",
+            },
         ):
             resource = create_resource(None)
         self.assertNotIn("foo", resource.attributes)
@@ -59,6 +59,49 @@ def test_empty_resource_config(self):
         self.assertEqual(resource.attributes[TELEMETRY_SDK_LANGUAGE], "python")
         self.assertEqual(resource.attributes[SERVICE_NAME], "unknown_service")
 
+    def test_service_name_default_added_when_missing(self):
+        config = ResourceConfig(
+            attributes=[AttributeNameValue(name="env", value="staging")]
+        )
+        resource = create_resource(config)
+        self.assertEqual(resource.attributes[SERVICE_NAME], "unknown_service")
+
+    def test_service_name_not_overridden_when_set(self):
+        config = ResourceConfig(
+            attributes=[
+                AttributeNameValue(name="service.name", value="my-app")
+            ]
+        )
+        resource = create_resource(config)
+        self.assertEqual(resource.attributes[SERVICE_NAME], "my-app")
+
+    def test_env_vars_not_read(self):
+        """OTEL_RESOURCE_ATTRIBUTES must not affect declarative config resource."""
+        with patch.dict(
+            os.environ,
+            {"OTEL_RESOURCE_ATTRIBUTES": "injected=true"},
+        ):
+            config = ResourceConfig(
+                attributes=[AttributeNameValue(name="k", value="v")]
+            )
+            resource = create_resource(config)
+        self.assertNotIn("injected", resource.attributes)
+
+    def test_schema_url(self):
+        config = ResourceConfig(
+            schema_url="https://opentelemetry.io/schemas/1.24.0"
+        )
+        resource = create_resource(config)
+        self.assertEqual(
+            resource.schema_url, "https://opentelemetry.io/schemas/1.24.0"
+        )
+
+    def test_schema_url_none(self):
+        resource = create_resource(ResourceConfig())
+        self.assertEqual(resource.schema_url, "")
+
+
+class TestCreateResourceAttributes(unittest.TestCase):
     def test_attributes_plain(self):
         config = ResourceConfig(
             attributes=[
@@ -87,9 +130,7 @@ def test_attribute_type_string(self):
     def test_attribute_type_int(self):
         config = ResourceConfig(
             attributes=[
-                AttributeNameValue(
-                    name="k", value=3.0, type=AttributeType.int
-                )
+                AttributeNameValue(name="k", value=3.0, type=AttributeType.int)
             ]
         )
         resource = create_resource(config)
@@ -182,19 +223,8 @@ def test_attribute_type_bool_array(self):
         resource = create_resource(config)
         self.assertEqual(list(resource.attributes["k"]), [True, False])  # type: ignore[arg-type]
 
-    def test_schema_url(self):
-        config = ResourceConfig(
-            schema_url="https://opentelemetry.io/schemas/1.24.0"
-        )
-        resource = create_resource(config)
-        self.assertEqual(
-            resource.schema_url, "https://opentelemetry.io/schemas/1.24.0"
-        )
-
-    def test_schema_url_none(self):
-        resource = create_resource(ResourceConfig())
-        self.assertEqual(resource.schema_url, "")
 
+class TestCreateResourceAttributesList(unittest.TestCase):
     def test_attributes_list_parsed(self):
         config = ResourceConfig(
             attributes_list="service.name=my-svc,region=us-east-1"
@@ -238,7 +268,9 @@ def test_attributes_list_url_decoded(self):
             attributes_list="service.namespace=my%20namespace,region=us-east-1"
         )
         resource = create_resource(config)
-        self.assertEqual(resource.attributes["service.namespace"], "my namespace")
+        self.assertEqual(
+            resource.attributes["service.namespace"], "my namespace"
+        )
 
     def test_attributes_list_invalid_pair_skipped(self):
         with self.assertLogs(
@@ -249,34 +281,3 @@ def test_attributes_list_invalid_pair_skipped(self):
         self.assertEqual(resource.attributes["foo"], "bar")
         self.assertNotIn("no-equals", resource.attributes)
         self.assertTrue(any("no-equals" in msg for msg in cm.output))
-
-    def test_service_name_default_added_when_missing(self):
-        config = ResourceConfig(
-            attributes=[AttributeNameValue(name="env", value="staging")]
-        )
-        resource = create_resource(config)
-        self.assertEqual(resource.attributes[SERVICE_NAME], "unknown_service")
-
-    def test_service_name_not_overridden_when_set(self):
-        config = ResourceConfig(
-            attributes=[
-                AttributeNameValue(name="service.name", value="my-app")
-            ]
-        )
-        resource = create_resource(config)
-        self.assertEqual(resource.attributes[SERVICE_NAME], "my-app")
-
-    def test_env_vars_not_read(self):
-        """OTEL_RESOURCE_ATTRIBUTES must not affect declarative config resource."""
-        import os
-        from unittest.mock import patch
-
-        with patch.dict(
-            os.environ,
-            {"OTEL_RESOURCE_ATTRIBUTES": "injected=true"},
-        ):
-            config = ResourceConfig(
-                attributes=[AttributeNameValue(name="k", value="v")]
-            )
-            resource = create_resource(config)
-        self.assertNotIn("injected", resource.attributes)