nimare 0.5.3__tar.gz → 0.5.4rc1__tar.gz

{nimare-0.5.3/nimare.egg-info → nimare-0.5.4rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nimare
-Version: 0.5.3
+Version: 0.5.4rc1
 Summary: NiMARE: Neuroimaging Meta-Analysis Research Environment
 Home-page: https://github.com/neurostuff/NiMARE
 Author: NiMARE developers

{nimare-0.5.3 → nimare-0.5.4rc1}/nimare/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-07-26T17:24:25-0500",
+ "date": "2025-07-30T11:49:13-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "096951f4879c2b5f508463c2efc4a3da9ebaf9bc",
- "version": "0.5.3"
+ "full-revisionid": "aa29fabbe739d247d1502bd7825a670018651aa5",
+ "version": "0.5.4rc1"
 }
 '''  # END VERSION_JSON
 

{nimare-0.5.3 → nimare-0.5.4rc1}/nimare/io.py

@@ -63,31 +63,53 @@ def convert_nimads_to_dataset(studyset, annotation=None):
             },
         }
 
-        sample_sizes = analysis.metadata.get("sample_sizes")
-        sample_size = None
+        sample_sizes = analysis.metadata.get("sample_sizes", None)
+        sample_size = analysis.metadata.get("sample_size", None)
 
         # Validate sample sizes if present
         if sample_sizes is not None and not isinstance(sample_sizes, (list, tuple)):
-            raise TypeError(
-                f"Expected sample_sizes to be list or tuple, but got {type(sample_sizes)}"
+            LGR.warning(
+                f"Expected sample_sizes to be list or tuple, but got {type(sample_sizes)}."
             )
-
-        if not sample_sizes:
-            # Try to get single sample size from analysis or study metadata
-            sample_size = analysis.metadata.get("sample_size")
-            if sample_size is None:
-                sample_size = study.metadata.get("sample_size")
-
+            sample_sizes = None
+        elif sample_sizes is not None:
+            # Validate each sample size in the list
+            for i, ss in enumerate(sample_sizes):
+                if not isinstance(ss, (int, float)):
+                    LGR.warning(
+                        f"Expected sample_sizes[{i}] to be numeric, but got {type(ss)}."
+                        " Attempting to convert to numeric."
+                    )
+                try:
+                    sample_sizes[i] = int(ss)
+                except (ValueError, TypeError):
+                    try:
+                        sample_sizes[i] = float(ss)
+                    except (ValueError, TypeError):
+                        LGR.warning(f"Could not convert {ss} to numeric from type {type(ss)}.")
+                        sample_sizes = None
+                        break
+
+        if not sample_sizes and sample_size:
             # Validate single sample size if present
-            if sample_size is not None and not isinstance(sample_size, (int, float)):
-                raise TypeError(f"Expected sample_size to be numeric, but got {type(sample_size)}")
-
-        # Add sample size info to result if available
-        if sample_sizes or sample_size is not None:
+            if not isinstance(sample_size, (int, float)):
+                LGR.warning(
+                    f"Expected sample_size to be numeric, but got {type(sample_size)}."
+                    " Attempting to convert to numeric."
+                )
             try:
-                result["metadata"]["sample_sizes"] = sample_sizes or [sample_size]
-            except TypeError as e:
-                raise TypeError(f"Error converting sample size data to list: {str(e)}") from e
+                sample_sizes = [int(sample_size)]
+            except (ValueError, TypeError):
+                try:
+                    sample_sizes = [float(sample_size)]
+                except (ValueError, TypeError):
+                    LGR.warning(
+                        f"Could not convert {sample_size} to"
+                        f" numeric from type {type(sample_size)}."
+                    )
+                    sample_sizes = None
+        if sample_sizes:
+            result["metadata"]["sample_sizes"] = sample_sizes
 
         # Handle annotations if present
         if analysis.annotations:

{nimare-0.5.3 → nimare-0.5.4rc1}/nimare/tests/test_io.py

@@ -1,5 +1,6 @@
 """Test nimare.io (Dataset IO/transformations)."""
 
+import copy
 import os
 
 import pytest
@@ -52,16 +53,107 @@ def test_convert_nimads_to_dataset_single_sample_size(
     assert "sample_sizes" in dset.metadata.columns
 
 
-def test_analysis_to_dict_invalid_sample_sizes_type(example_nimads_studyset):
-    """Test _analysis_to_dict raises ValueError when sample_sizes is not a list/tuple."""
+@pytest.mark.parametrize(
+    "sample_sizes_val,sample_size_val,expect_col,expect_warning",
+    [
+        (5, None, False, True),
+        ([5, "6", "7.3", "not_a_number"], None, False, True),
+        (None, 10, True, False),
+        (None, 10.5, True, False),
+        (None, "12", True, True),
+        (None, "13.5", True, True),
+        (None, "not_a_number", False, True),
+        (None, None, False, False),
+        ([], 7, True, False),
+        ([], None, False, False),
+    ],
+)
+def test_analysis_to_dict_sample_size(
+    example_nimads_studyset, sample_sizes_val, sample_size_val, expect_col, expect_warning, caplog
+):
+    """Test conversion of nimads JSON to nimare dataset with different sample_size(s) values."""
     studyset = Studyset(example_nimads_studyset)
-    # Set sample_sizes to an int rather than list/tuple
     for study in studyset.studies:
         for analysis in study.analyses:
-            analysis.metadata["sample_sizes"] = 5
-    with pytest.raises(TypeError):
-        # Trigger conversion which internally calls _analysis_to_dict
-        io.convert_nimads_to_dataset(studyset)
+            analysis.metadata.clear()
+            if sample_sizes_val is not None:
+                analysis.metadata["sample_sizes"] = sample_sizes_val
+            if sample_size_val is not None:
+                analysis.metadata["sample_size"] = sample_size_val
+
+    with caplog.at_level("WARNING"):
+        dset = io.convert_nimads_to_dataset(studyset)
+    assert isinstance(dset, nimare.dataset.Dataset)
+    if expect_col:
+        assert "sample_sizes" in dset.metadata.columns
+    else:
+        assert "sample_sizes" not in dset.metadata.columns
+    if expect_warning:
+        assert any(
+            "sample_size" in record.message or "sample_sizes" in record.message
+            for record in caplog.records
+        )
+    else:
+        assert not any(
+            "sample_size" in record.message or "sample_sizes" in record.message
+            for record in caplog.records
+        )
+
+
+@pytest.mark.parametrize(
+    "annotation_mod,expect_success,expect_typeerror",
+    [
+        # No annotation at all
+        (None, True, False),
+        # Annotation with empty notes
+        (lambda ann: ann.update({"notes": []}), True, False),
+        # Annotation with extra irrelevant key
+        (lambda ann: ann.update({"extra_key": 123}), True, False),
+        # Annotation with missing 'notes' key (should fail)
+        (lambda ann: ann.pop("notes", None), False, True),
+        # Annotation with mismatched analysis id in notes (should warn/fail)
+        (
+            lambda ann: ann["notes"].append(
+                {
+                    "analysis_name": "Fake",
+                    "publication": "Fake",
+                    "study": ann["notes"][0]["study"],
+                    "study_year": 2025,
+                    "analysis": "not_in_studyset",
+                    "authors": "Nobody",
+                    "note": {"include": False},
+                    "study_name": "Fake",
+                }
+            ),
+            True,
+            True,
+        ),
+    ],
+)
+def test_analysis_to_dict_annotation(
+    example_nimads_studyset,
+    example_nimads_annotation,
+    annotation_mod,
+    expect_success,
+    expect_typeerror,
+):
+    """Test conversion of nimads JSON to nimare dataset with various annotation modifications."""
+    studyset = Studyset(example_nimads_studyset)
+    if annotation_mod is not None:
+        annotation = copy.deepcopy(example_nimads_annotation)
+        annotation_mod(annotation)
+        if expect_typeerror:
+            with pytest.raises((TypeError, ValueError, KeyError)):
+                studyset.annotations = annotation
+                io.convert_nimads_to_dataset(studyset)
+        else:
+            studyset.annotations = annotation
+            dset = io.convert_nimads_to_dataset(studyset)
+            assert expect_success
+    else:
+        # No annotation
+        dset = io.convert_nimads_to_dataset(studyset)
+        assert isinstance(dset, nimare.dataset.Dataset)
 
 
 def test_convert_sleuth_to_dataset_smoke():

{nimare-0.5.3 → nimare-0.5.4rc1/nimare.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nimare
-Version: 0.5.3
+Version: 0.5.4rc1
 Summary: NiMARE: Neuroimaging Meta-Analysis Research Environment
 Home-page: https://github.com/neurostuff/NiMARE
 Author: NiMARE developers