Sonar analysis

kylstevenson · kylstevenson · commit 94221e307afc · 2026-04-06T11:47:16.000+01:00
diff --git a/py_src/fusion/attributes.py b/py_src/fusion/attributes.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field, fields
+from dataclasses import MISSING, dataclass, field, fields
 from typing import TYPE_CHECKING, Any, cast
 
 import numpy as np
@@ -260,7 +260,40 @@ def _from_dict(cls: type[Attribute], data: dict[str, Any]) -> Attribute:
         data = {k: (None if pd.isna(v) else v) for k, v in data.items() if k in keys}
         if "data_type" in data:
             data["data_type"] = Types[data["data_type"].strip().rsplit(".", maxsplit=1)[-1].title()]
-        return cls(**data)
+        field_map = {field_.name: field_ for field_ in fields(cls)}
+
+        def _value(name: str) -> Any:
+            if name in data:
+                return data[name]
+            field_ = field_map[name]
+            if field_.default_factory is not MISSING:
+                return field_.default_factory()
+            return field_.default
+
+        return cls(
+            identifier=data["identifier"],
+            index=data["index"],
+            data_type=_value("data_type"),
+            title=_value("title"),
+            description=_value("description"),
+            is_dataset_key=_value("is_dataset_key"),
+            source=_value("source"),
+            source_field_id=_value("source_field_id"),
+            is_internal_dataset_key=_value("is_internal_dataset_key"),
+            is_externally_visible=_value("is_externally_visible"),
+            unit=_value("unit"),
+            multiplier=_value("multiplier"),
+            is_propagation_eligible=_value("is_propagation_eligible"),
+            is_metric=_value("is_metric"),
+            available_from=_value("available_from"),
+            deprecated_from=_value("deprecated_from"),
+            term=_value("term"),
+            dataset=_value("dataset"),
+            attribute_type=_value("attribute_type"),
+            application_id=_value("application_id"),
+            publisher=_value("publisher"),
+            is_key_data_element=_value("is_key_data_element"),
+        )
 
     def from_object(
         self,
diff --git a/py_src/fusion/dataset.py b/py_src/fusion/dataset.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json as js
-from dataclasses import dataclass, field, fields
+from dataclasses import MISSING, dataclass, field, fields
 from typing import TYPE_CHECKING, Any
 
 import pandas as pd
@@ -314,7 +314,55 @@ def _from_dict(cls: type[Dataset], data: dict[str, Any]) -> Dataset:
         data = {k: v for k, v in data.items() if k in keys}
         if "type" in data:
             data["type_"] = data.pop("type")
-        return cls(**data)
+        field_map = {field_.name: field_ for field_ in fields(cls)}
+
+        def _value(name: str) -> Any:
+            if name in data:
+                return data[name]
+            field_ = field_map[name]
+            if field_.default_factory is not MISSING:
+                return field_.default_factory()
+            return field_.default
+
+        return cls(
+            identifier=data["identifier"],
+            title=_value("title"),
+            category=_value("category"),
+            description=_value("description"),
+            frequency=_value("frequency"),
+            is_internal_only_dataset=_value("is_internal_only_dataset"),
+            is_third_party_data=_value("is_third_party_data"),
+            is_restricted=_value("is_restricted"),
+            is_raw_data=_value("is_raw_data"),
+            maintainer=_value("maintainer"),
+            source=_value("source"),
+            region=_value("region"),
+            publisher=_value("publisher"),
+            product=_value("product"),
+            sub_category=_value("sub_category"),
+            tags=_value("tags"),
+            created_date=_value("created_date"),
+            modified_date=_value("modified_date"),
+            delivery_channel=_value("delivery_channel"),
+            language=_value("language"),
+            status=_value("status"),
+            type_=_value("type_"),
+            container_type=_value("container_type"),
+            snowflake=_value("snowflake"),
+            complexity=_value("complexity"),
+            is_immutable=_value("is_immutable"),
+            is_mnpi=_value("is_mnpi"),
+            is_pci=_value("is_pci"),
+            is_pii=_value("is_pii"),
+            is_client=_value("is_client"),
+            is_public=_value("is_public"),
+            is_internal=_value("is_internal"),
+            is_confidential=_value("is_confidential"),
+            is_highly_confidential=_value("is_highly_confidential"),
+            is_active=_value("is_active"),
+            owners=_value("owners"),
+            application_id=_value("application_id"),
+        )
 
     @classmethod
     def _from_csv(cls: type[Dataset], file_path: str, identifier: str | None = None) -> Dataset:
diff --git a/py_src/fusion/fusion_filesystem.py b/py_src/fusion/fusion_filesystem.py
@@ -1002,19 +1002,23 @@ def _compute_checksum_from_data(self, data: bytes, algorithm: str, is_multipart:
 
         elif algorithm == "SHA-1":
             if is_multipart:
-                inner_hash = hashlib.sha1(data).digest()
-                outer_hash = hashlib.sha1(inner_hash).digest()
+                inner_hash = hashlib.sha1(data).digest()  # NOSONAR(S4790) legacy API checksum
+                outer_hash = hashlib.sha1(inner_hash).digest()  # NOSONAR(S4790) legacy API checksum
                 return base64.b64encode(outer_hash).decode("ascii")
             else:
-                return base64.b64encode(hashlib.sha1(data).digest()).decode("ascii")
+                return base64.b64encode(hashlib.sha1(data).digest()).decode(
+                    "ascii"
+                )  # NOSONAR(S4790) legacy API checksum
 
         elif algorithm == "MD5":
             if is_multipart:
-                inner_hash = hashlib.md5(data).digest()
-                outer_hash = hashlib.md5(inner_hash).digest()
+                inner_hash = hashlib.md5(data).digest()  # NOSONAR(S4790) legacy API checksum
+                outer_hash = hashlib.md5(inner_hash).digest()  # NOSONAR(S4790) legacy API checksum
                 return base64.b64encode(outer_hash).decode("ascii")
             else:
-                return base64.b64encode(hashlib.md5(data).digest()).decode("ascii")
+                return base64.b64encode(hashlib.md5(data).digest()).decode(  # NOSONAR(S4790) legacy API checksum
+                    "ascii"
+                )
 
         elif algorithm == "CRC64NVME":
             crc_value = aws_checksums.crc64nvme(data)
@@ -1243,7 +1247,8 @@ async def put_data() -> AsyncGenerator[dict[Any, Any], None]:
                 operation_id = await resp.json()
 
             operation_id = operation_id["operationId"]
-            resps = [resp async for resp in put_data()]
+            put_data_iterable: AsyncGenerator[dict[Any, Any], None] = put_data()
+            resps = [resp async for resp in put_data_iterable]
             kw = self.kwargs.copy()
             kw.update({"headers": headers})
             kw = FusionHTTPFileSystem._update_kwargs(kw, headers, additional_headers)
diff --git a/py_src/fusion/product.py b/py_src/fusion/product.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json as js
-from dataclasses import dataclass, field, fields
+from dataclasses import MISSING, dataclass, field, fields
 from typing import TYPE_CHECKING, Any
 
 import pandas as pd
@@ -221,7 +221,38 @@ def _from_dict(cls: type[Product], data: dict[str, Any]) -> Product:
         keys = [f.name for f in fields(cls)]
         data = {camel_to_snake(k): v for k, v in data.items()}
         data = {k: v for k, v in data.items() if k in keys}
-        return cls(**data)
+        field_map = {field_.name: field_ for field_ in fields(cls)}
+
+        def _value(name: str) -> Any:
+            if name in data:
+                return data[name]
+            field_ = field_map[name]
+            if field_.default_factory is not MISSING:
+                return field_.default_factory()
+            return field_.default
+
+        return cls(
+            identifier=data["identifier"],
+            title=_value("title"),
+            category=_value("category"),
+            short_abstract=_value("short_abstract"),
+            description=_value("description"),
+            is_active=_value("is_active"),
+            is_restricted=_value("is_restricted"),
+            maintainer=_value("maintainer"),
+            region=_value("region"),
+            publisher=_value("publisher"),
+            sub_category=_value("sub_category"),
+            tag=_value("tag"),
+            delivery_channel=_value("delivery_channel"),
+            theme=_value("theme"),
+            release_date=_value("release_date"),
+            language=_value("language"),
+            status=_value("status"),
+            image=_value("image"),
+            logo=_value("logo"),
+            dataset=_value("dataset"),
+        )
 
     @classmethod
     def _from_csv(cls: type[Product], file_path: str, identifier: str | None = None) -> Product:
diff --git a/py_tests/test_attributes.py b/py_tests/test_attributes.py
@@ -135,6 +135,33 @@ def test_attribute_class_from_dict() -> None:
     assert test_attribute.attributeType is None
 
 
+def test_attribute_class_from_dict_with_extended_fields() -> None:
+    """Test attribute class from dict with optional fields."""
+    test_attribute = Attribute._from_dict(
+        {
+            "title": "Test Attribute",
+            "identifier": "Test Attribute",
+            "index": 0,
+            "dataType": "string",
+            "sourceFieldId": "Original Field",
+            "isInternalDatasetKey": True,
+            "isExternallyVisible": False,
+            "deprecatedFrom": "May 5, 2021",
+            "applicationId": {"id": "123", "type": "Application"},
+            "publisher": "JPM",
+            "isKeyDataElement": True,
+        }
+    )
+
+    assert test_attribute.sourceFieldId == "Original_Field"
+    assert test_attribute.isInternalDatasetKey is True
+    assert test_attribute.isExternallyVisible is False
+    assert test_attribute.deprecatedFrom == "2021-05-05"
+    assert test_attribute.applicationId == {"id": "123", "type": "Application"}
+    assert test_attribute.publisher == "JPM"
+    assert test_attribute.isKeyDataElement is True
+
+
 def test_attribute_class_from_object_dict() -> None:
     """Test attribute class from object"""
     test_dict = {
diff --git a/py_tests/test_dataset.py b/py_tests/test_dataset.py
@@ -268,6 +268,42 @@ def test_dataset_class_from_dict() -> None:
     assert test_dataset.is_active is None
 
 
+def test_dataset_class_from_dict_with_aliases() -> None:
+    """Test Dataset._from_dict handles aliased camelCase keys."""
+    test_dataset = Dataset._from_dict(
+        {
+            "title": "Test Dataset",
+            "identifier": "Test Dataset",
+            "tag": ["tag1", "tag2"],
+            "type": "Source",
+            "applicationId": {"id": "123", "type": "Application"},
+            "owners": ["owner1", "owner2"],
+        }
+    )
+
+    assert test_dataset.tags == ["tag1", "tag2"]
+    assert test_dataset.type_ == "Source"
+    assert test_dataset.application_id == {"id": "123", "type": "Application"}
+    assert test_dataset.owners == ["owner1", "owner2"]
+
+
+def test_dataset_class_from_dict_uses_fresh_default_factory_list() -> None:
+    """Test Dataset._from_dict uses a fresh delivery_channel default list."""
+    first_dataset = Dataset._from_dict({"identifier": "first_dataset"})
+    second_dataset = Dataset._from_dict({"identifier": "second_dataset"})
+
+    assert isinstance(first_dataset.delivery_channel, list)
+    assert isinstance(second_dataset.delivery_channel, list)
+    assert first_dataset.delivery_channel == ["API"]
+    assert second_dataset.delivery_channel == ["API"]
+    assert first_dataset.delivery_channel is not second_dataset.delivery_channel
+
+    first_dataset.delivery_channel.append("SFTP")
+
+    assert first_dataset.delivery_channel == ["API", "SFTP"]
+    assert second_dataset.delivery_channel == ["API"]
+
+
 def test_dataset_class_from_csv(mock_dataset_pd_read_csv: Generator[pd.DataFrame, Any, None]) -> None:  # noqa: ARG001
     """Test Dataset class."""
     test_dataset = Dataset._from_csv("datasets.csv")
diff --git a/py_tests/test_product.py b/py_tests/test_product.py
@@ -110,6 +110,54 @@ def test_product_class_from_dict() -> None:
     assert test_product.dataset is None
 
 
+def test_product_class_from_dict_with_optional_fields() -> None:
+    """Test Product._from_dict maps optional fields directly."""
+    test_product = Product._from_dict(
+        {
+            "title": "Test Product",
+            "identifier": "TEST_PRODUCT",
+            "shortAbstract": "Short Abstract",
+            "isRestricted": False,
+            "maintainer": ["Maintainer"],
+            "subCategory": ["Sub Category"],
+            "tag": ["Tag"],
+            "dataset": ["DATASET_1"],
+        }
+    )
+
+    assert test_product.shortAbstract == "Short Abstract"
+    assert test_product.isRestricted is False
+    assert test_product.maintainer == ["Maintainer"]
+    assert test_product.subCategory == ["Sub Category"]
+    assert test_product.tag == ["Tag"]
+    assert test_product.dataset == ["DATASET_1"]
+
+
+def test_product_class_from_dict_uses_fresh_default_factory_lists() -> None:
+    """Test Product._from_dict uses fresh list defaults for default_factory fields."""
+    first_product = Product._from_dict({"identifier": "FIRST_PRODUCT"})
+    second_product = Product._from_dict({"identifier": "SECOND_PRODUCT"})
+
+    assert isinstance(first_product.region, list)
+    assert isinstance(second_product.region, list)
+    assert isinstance(first_product.delivery_channel, list)
+    assert isinstance(second_product.delivery_channel, list)
+    assert first_product.region == ["Global"]
+    assert second_product.region == ["Global"]
+    assert first_product.region is not second_product.region
+    assert first_product.delivery_channel == ["API"]
+    assert second_product.delivery_channel == ["API"]
+    assert first_product.delivery_channel is not second_product.delivery_channel
+
+    first_product.region.append("EMEA")
+    first_product.delivery_channel.append("SFTP")
+
+    assert first_product.region == ["Global", "EMEA"]
+    assert second_product.region == ["Global"]
+    assert first_product.delivery_channel == ["API", "SFTP"]
+    assert second_product.delivery_channel == ["API"]
+
+
 def test_product_class_from_csv(mock_product_pd_read_csv: Generator[pd.DataFrame, Any, None]) -> None:  # noqa: ARG001
     """Test the Product class."""
     test_product = Product._from_csv("products.csv")
diff --git a/uv.lock b/uv.lock
