Linting

Author: BrianMichell

src/mdio/core/v1/_overloads.py

@@ -25,8 +25,9 @@ def to_mdio(
         """Alias for `.to_zarr()`."""
         # Ensure zarr_version=2 by default unless explicitly overridden
         zarr_version = kwargs.get("zarr_version", 2)
-        if zarr_version != 2:
-            raise ValueError("MDIO only supports zarr_version=2")
+        if zarr_version != 2:  # noqa: PLR2004
+            msg = "MDIO only supports zarr_version=2"
+            raise ValueError(msg)
         kwargs["zarr_version"] = zarr_version
         return super().to_zarr(*args, store=store, **kwargs)
 
@@ -45,8 +46,9 @@ def to_mdio(
         """Alias for `.to_zarr()`, and writes to Zarr store."""
         # Ensure zarr_version=2 by default unless explicitly overridden
         zarr_version = kwargs.get("zarr_version", 2)
-        if zarr_version != 2:
-            raise ValueError("MDIO only supports zarr_version=2")
+        if zarr_version != 2:  # noqa: PLR2004
+            msg = "MDIO only supports zarr_version=2"
+            raise ValueError(msg)
         kwargs["zarr_version"] = zarr_version
         return super().to_zarr(*args, store=store, **kwargs)
 
@@ -80,9 +82,9 @@ def open(
         ds.__class__ = MDIODataset
         # Cast each DataArray in data_vars and coords
 
-        for _name, var in ds.data_vars.items():
+        for _name, var in ds.data_vars.items():  # noqa: PERF102 .values() failed tests
             var.__class__ = MDIODataArray
-        for _name, coord in ds.coords.items():
+        for _name, coord in ds.coords.items():  # noqa: PERF102 .values() failed tests
             coord.__class__ = MDIODataArray
         return ds
 

src/mdio/core/v1/_serializer.py

@@ -11,6 +11,7 @@
 from numcodecs import Blosc as NumcodecsBlosc
 
 from mdio.core.v1._overloads import mdio
+from mdio.schemas.chunk_grid import *  # noqa: F403
 from mdio.schemas.compressors import ZFP
 from mdio.schemas.compressors import Blosc
 from mdio.schemas.dimension import NamedDimension
@@ -19,20 +20,16 @@
 from mdio.schemas.metadata import UserAttributes
 from mdio.schemas.v1.dataset import Dataset as MDIODataset
 from mdio.schemas.v1.dataset import DatasetMetadata
+from mdio.schemas.v1.stats import *  # noqa: F403
 from mdio.schemas.v1.units import AllUnits
 from mdio.schemas.v1.variable import Coordinate
 from mdio.schemas.v1.variable import Variable
 from mdio.schemas.v1.variable import VariableMetadata
-from mdio.schemas.chunk_grid import *
-from mdio.schemas.v1.stats import *
-
-import logging
 
 try:
     import zfpy as zfpy_base  # Base library
     from numcodecs import ZFPY  # Codec
 except ImportError:
-    logging.warning(f"Tried to import zfpy and numcodecs zfpy but failed because {ImportError}")
     zfpy_base = None
     ZFPY = None
 
@@ -87,9 +84,7 @@ def make_variable(  # noqa: PLR0913 PLR0912
         TypeError: If the metadata type is not supported.
     """
 
-    # TODO(BrianMichell) #0: I suspect that this is only partially correct...
-
-    def _to_serializable(val: Any) -> Any:
+    def _to_serializable(val: object) -> dict[str, Any] | object:
         return val.model_dump(mode="json", by_alias=True) if hasattr(val, "model_dump") else val
 
     var_metadata = None
@@ -104,7 +99,9 @@ def _to_serializable(val: Any) -> Any:
                     metadata_dict["unitsV1"] = val
                 elif isinstance(md, UserAttributes):
                     attrs = _to_serializable(md)
-                    metadata_dict["attributes"] = attrs[0] if isinstance(attrs, list) and len(attrs) == 1 else attrs
+                    metadata_dict["attributes"] = (
+                        attrs[0] if isinstance(attrs, list) and len(attrs) == 1 else attrs
+                    )
             var_metadata = VariableMetadata(**metadata_dict)
 
         elif isinstance(metadata, dict):
@@ -121,7 +118,8 @@ def _to_serializable(val: Any) -> Any:
             var_metadata = metadata
 
         else:
-            raise TypeError(f"Unsupported metadata type: {type(metadata)}")
+            msg = f"Unsupported metadata type: {type(metadata)}"
+            raise TypeError(msg)
 
     return Variable(
         name=name,

src/mdio/schemas/core.py

@@ -3,12 +3,12 @@
 from __future__ import annotations
 
 from typing import Any
-from typing import get_type_hints
 
 from pydantic import BaseModel
 from pydantic import ConfigDict
-from pydantic.alias_generators import to_camel
 from pydantic import Field
+from pydantic.alias_generators import to_camel
+
 
 def model_fields(model: type[BaseModel]) -> dict[str, tuple[Any, Any]]:
     """Extract Pydantic BaseModel fields.
@@ -57,7 +57,7 @@ class CamelCaseStrictModel(StrictModel):
         ser_json_by_alias=True,
     )
 
-    def model_dump_json(self, *args, **kwargs):  # type: ignore[override]
+    def model_dump_json(self, *args, **kwargs) -> dict:  # noqa: ANN201 ANN001 ANN002 ANN003
         """Dump JSON using camelCase aliases and excluding None values by default."""
         # Ensure camelCase aliases
         if "by_alias" not in kwargs:

tests/test_main.py

@@ -30,6 +30,7 @@ def test_main_succeeds(runner: CliRunner, segy_input: Path, zarr_tmp: Path) -> N
 def test_main_cloud(runner: CliRunner, segy_input_uri: str, zarr_tmp: Path) -> None:
     """It exits with a status code of zero."""
     os.environ["MDIO__IMPORT__CLOUD_NATIVE"] = "true"
+    os.environ["MDIO__IMPORT__CPU_COUNT"] = "1"
     cli_args = ["segy", "import", segy_input_uri, str(zarr_tmp)]
     cli_args.extend(["--header-locations", "181,185"])
     cli_args.extend(["--header-names", "inline,crossline"])

tests/unit/test_schema.py

@@ -311,24 +311,25 @@ class TestPydanticMDIORoundTrip:
     def test_json_to_mdio_dataset(self, tmp_path: Path) -> None:
         """Test converting TEST_SCHEMA JSON to an MDIO dataset using to_mdio."""
         from mdio.core.v1._serializer import _construct_mdio_dataset
-        
+
         output_path = tmp_path / "from_json.mdio"
         # output_path = "test_mdio_from_json.mdio"
-        
+
         # Step 1: Validate the TEST_SCHEMA JSON with Pydantic
         dataset = V1Dataset.model_validate(TEST_SCHEMA)
-        
+
         # Step 2: Convert to MDIO dataset using the internal constructor
         mdio_dataset = _construct_mdio_dataset(dataset)
-        
+
         # Step 3: Use to_mdio to save the dataset
         mdio_dataset.to_mdio(store=str(output_path))
-        
+
         # Verify the dataset was created
         assert output_path.exists()
-        
+
         # Verify we can read it back
         from mdio.core.v1 import mdio
+
         with mdio.open(str(output_path)) as reader:
             assert "actual_variable" in reader
             assert "coord" in reader
@@ -338,21 +339,21 @@ def test_json_to_mdio_dataset(self, tmp_path: Path) -> None:
 
     def test_mdio_dataset_to_json(self, tmp_path: Path) -> None:
         """Test converting an MDIO dataset back to JSON (camelCase)."""
-        from mdio.core.v1._serializer import _construct_mdio_dataset
         from mdio.core.v1 import mdio
-        
+        from mdio.core.v1._serializer import _construct_mdio_dataset
+
         # Step 1: Create MDIO dataset from TEST_SCHEMA
         dataset = V1Dataset.model_validate(TEST_SCHEMA)
         mdio_dataset = _construct_mdio_dataset(dataset)
-        
+
         mdio_path = tmp_path / "test_dataset.mdio"
         mdio_dataset.to_mdio(store=str(mdio_path))
-        
+
         # Step 2: Read back the MDIO dataset
         with mdio.open(str(mdio_path)) as reader:
             # Step 3: Extract information to reconstruct Pydantic model
             variables = []
-            
+
             # Add dimension variables
             for dim_name in ["dim0", "dim1"]:
                 if dim_name in reader.coords:
@@ -363,7 +364,7 @@ def test_mdio_dataset_to_json(self, tmp_path: Path) -> None:
                         "dimensions": [{"name": dim_name, "size": reader.dims[dim_name]}],
                     }
                     variables.append(var_dict)
-            
+
             # Add data variables with their metadata
             for var_name in reader.data_vars:
                 var = reader[var_name]
@@ -372,7 +373,7 @@ def test_mdio_dataset_to_json(self, tmp_path: Path) -> None:
                     "dataType": str(var.dtype),
                     "dimensions": list(var.dims),
                 }
-                
+
                 # Reconstruct metadata based on original TEST_SCHEMA
                 if var_name == "coord":
                     var_dict["metadata"] = {
@@ -392,21 +393,21 @@ def test_mdio_dataset_to_json(self, tmp_path: Path) -> None:
                         },
                     }
                 variables.append(var_dict)
-            
+
             # Step 4: Create Pydantic model data (camelCase)
             dataset_data = {
                 "metadata": {
                     "name": reader.attrs.get("name"),
                     "apiVersion": reader.attrs.get("apiVersion", "1.0.0"),
                     "createdOn": reader.attrs.get("createdOn", "2023-01-01T00:00:00Z"),
                 },
-                "variables": variables
+                "variables": variables,
             }
-            
+
             # Step 5: Validate with Pydantic and serialize to JSON using by_alias=True
             pydantic_dataset = V1Dataset.model_validate(dataset_data)
             json_str = pydantic_dataset.model_dump_json(by_alias=True)
-            
+
             # Verify it's valid JSON and camelCase
             parsed = json.loads(json_str)
 
@@ -415,34 +416,34 @@ def test_mdio_dataset_to_json(self, tmp_path: Path) -> None:
             assert "apiVersion" in parsed["metadata"]
             assert "createdOn" in parsed["metadata"]
             assert "dataType" in parsed["variables"][0]
-            
+
             # Verify the conversion preserved data
             assert pydantic_dataset.metadata.name == "test_dataset"
 
     def test_full_round_trip_json_mdio_json(self, tmp_path: Path) -> None:
         """Test full round-trip: TEST_SCHEMA JSON -> MDIO -> JSON using to_mdio."""
-        from mdio.core.v1._serializer import _construct_mdio_dataset
         from mdio.core.v1 import mdio
-        
+        from mdio.core.v1._serializer import _construct_mdio_dataset
+
         # Step 1: Start with TEST_SCHEMA (input JSON)
         original_dataset = V1Dataset.model_validate(TEST_SCHEMA)
         original_json = original_dataset.model_dump_json(by_alias=True)
         original_parsed = json.loads(original_json)
-        
+
         # Verify original is camelCase
         assert "apiVersion" in original_parsed["metadata"]
         assert "createdOn" in original_parsed["metadata"]
-        
+
         # Step 2: Convert to MDIO dataset and save
         mdio_dataset = _construct_mdio_dataset(original_dataset)
         mdio_path = tmp_path / "round_trip.mdio"
         mdio_dataset.to_mdio(store=str(mdio_path))
-        
+
         # Step 3: Read back from MDIO and convert to JSON
         with mdio.open(str(mdio_path)) as reader:
             # Reconstruct the schema structure
             variables = []
-            
+
             # Add dimension variables
             for dim_name in ["dim0", "dim1"]:
                 if dim_name in reader.coords:
@@ -453,7 +454,7 @@ def test_full_round_trip_json_mdio_json(self, tmp_path: Path) -> None:
                         "dimensions": [{"name": dim_name, "size": reader.dims[dim_name]}],
                     }
                     variables.append(var_dict)
-            
+
             # Add coordinate variables that are not dimensions
             for coord_name, coord in reader.coords.items():
                 if coord_name not in ["dim0", "dim1"]:  # Skip dimension coordinates
@@ -462,7 +463,7 @@ def test_full_round_trip_json_mdio_json(self, tmp_path: Path) -> None:
                         "dataType": str(coord.dtype),
                         "dimensions": list(coord.dims),
                     }
-                    
+
                     # Add metadata for coord variable from original TEST_SCHEMA
                     if coord_name == "coord":
                         var_dict["metadata"] = {
@@ -473,7 +474,7 @@ def test_full_round_trip_json_mdio_json(self, tmp_path: Path) -> None:
                             "unitsV1": {"length": "m"},
                         }
                     variables.append(var_dict)
-            
+
             # Add data variables with original metadata
             for var_name in reader.data_vars:
                 var = reader[var_name]
@@ -482,7 +483,7 @@ def test_full_round_trip_json_mdio_json(self, tmp_path: Path) -> None:
                     "dataType": str(var.dtype),
                     "dimensions": list(var.dims),
                 }
-                
+
                 # Add original metadata back from TEST_SCHEMA
                 if var_name == "actual_variable":
                     var_dict["compressor"] = {"name": "blosc", "level": 3}
@@ -494,30 +495,32 @@ def test_full_round_trip_json_mdio_json(self, tmp_path: Path) -> None:
                         },
                     }
                 variables.append(var_dict)
-            
+
             # Create final dataset
             final_data = {
                 "metadata": {
                     "name": reader.attrs.get("name", "test_dataset"),
                     "apiVersion": reader.attrs.get("apiVersion", "1.0.0"),
                     "createdOn": reader.attrs.get("createdOn", "2023-01-01T00:00:00Z"),
                 },
-                "variables": variables
+                "variables": variables,
             }
-            
+
             final_dataset = V1Dataset.model_validate(final_data)
             final_json = final_dataset.model_dump_json(by_alias=True)
             final_parsed = json.loads(final_json)
-            
+
             # Step 4: Verify round-trip integrity
             assert final_parsed["metadata"]["name"] == original_parsed["metadata"]["name"]
-            assert final_parsed["metadata"]["apiVersion"] == original_parsed["metadata"]["apiVersion"]
-            
+            assert (
+                final_parsed["metadata"]["apiVersion"] == original_parsed["metadata"]["apiVersion"]
+            )
+
             # Verify camelCase is preserved
             assert "apiVersion" in final_parsed["metadata"]
             assert "createdOn" in final_parsed["metadata"]
             assert "dataType" in final_parsed["variables"][0]
-            
+
             # Verify variable structure is preserved
             original_var_names = {v["name"] for v in original_parsed["variables"]}
             final_var_names = {v["name"] for v in final_parsed["variables"]}
@@ -543,9 +546,9 @@ def test_invalid_snake_case_json_fails(self) -> None:
                     "data_type": "float32",  # snake_case should fail
                     "dimensions": ["dim0"],
                 }
-            ]
+            ],
         }
-        
+
         # This should fail validation
         with pytest.raises(ValidationError):
             V1Dataset.model_validate(invalid_snake_case_schema)
@@ -555,20 +558,20 @@ def test_camel_case_serialization_only(self) -> None:
         dataset = V1Dataset.model_validate(TEST_SCHEMA)
         json_str = dataset.model_dump_json()
         parsed = json.loads(json_str)
-        
+
         # Verify camelCase fields are present
         assert "apiVersion" in parsed["metadata"]
         assert "createdOn" in parsed["metadata"]
-        
+
         # Verify snake_case fields are NOT present
         assert "api_version" not in parsed["metadata"]
         assert "created_on" not in parsed["metadata"]
-        
+
         # Check variables use camelCase
         for var in parsed["variables"]:
             assert "dataType" in var
             assert "data_type" not in var
-            
+
             # Check nested metadata if present
             if "metadata" in var and "chunkGrid" in var["metadata"]:
                 assert "chunkGrid" in var["metadata"]