voxcity 0.6.26__py3-none-any.whl → 1.0.2__py3-none-any.whl

voxcity/exporter/cityles.py

@@ -14,25 +14,26 @@ Notes:
 import os
 import numpy as np
 from pathlib import Path
+from ..models import VoxCity
 
 
 # VoxCity standard land cover classes after conversion
-# Based on convert_land_cover function output
+# Based on convert_land_cover function output (1-based indices)
 VOXCITY_STANDARD_CLASSES = {
-    0: 'Bareland',
-    1: 'Rangeland',
-    2: 'Shrub',
-    3: 'Agriculture land',
-    4: 'Tree',
-    5: 'Moss and lichen',
-    6: 'Wet land',
-    7: 'Mangrove',
-    8: 'Water',
-    9: 'Snow and ice',
-    10: 'Developed space',
-    11: 'Road',
-    12: 'Building',
-    13: 'No Data'
+    1: 'Bareland',
+    2: 'Rangeland',
+    3: 'Shrub',
+    4: 'Agriculture land',
+    5: 'Tree',
+    6: 'Moss and lichen',
+    7: 'Wet land',
+    8: 'Mangrove',
+    9: 'Water',
+    10: 'Snow and ice',
+    11: 'Developed space',
+    12: 'Road',
+    13: 'Building',
+    14: 'No Data'
 }
 
 ## Source-specific class name to CityLES land use mappings
@@ -189,6 +190,27 @@ def _build_index_to_cityles_map(land_cover_source):
     return index_to_code, class_names
 
 
+def _resolve_under_tree_code(under_tree_class_name, under_tree_cityles_code, land_cover_source):
+    """Resolve the CityLES land-use code used under tree canopy.
+
+    Priority:
+    1) Explicit numeric code if provided
+    2) Class name using the source-specific mapping
+    3) Class name using the standard (OSM) mapping
+    4) Default to 9 (Bare Land)
+    """
+    if under_tree_cityles_code is not None:
+        try:
+            return int(under_tree_cityles_code)
+        except Exception:
+            pass
+    name_to_code = _get_source_name_mapping(land_cover_source)
+    code = name_to_code.get(under_tree_class_name)
+    if code is None:
+        code = OSM_CLASS_TO_CITYLES.get(under_tree_class_name, 9)
+    return code
+
+
 def export_topog(building_height_grid, building_id_grid, output_path, 
                  building_material='default', cityles_landuse_grid=None):
     """
@@ -239,7 +261,9 @@ def export_topog(building_height_grid, building_id_grid, output_path,
                 f.write(f"{i_1based} {j_1based} {height:.1f} {material_code_cell} 0.0 0.0 102\n")
 
 
-def export_landuse(land_cover_grid, output_path, land_cover_source=None):
+def export_landuse(land_cover_grid, output_path, land_cover_source=None,
+                   canopy_height_grid=None, building_height_grid=None,
+                   under_tree_class_name='Bareland', under_tree_cityles_code=None):
     """
     Export landuse.txt file for CityLES
     
@@ -251,6 +275,17 @@ def export_landuse(land_cover_grid, output_path, land_cover_source=None):
         Output directory path
     land_cover_source : str, optional
         Source of land cover data
+    canopy_height_grid : numpy.ndarray, optional
+        2D array of canopy heights; if provided, cells with canopy (>0) will be
+        assigned the ground class under the canopy instead of a tree class.
+    building_height_grid : numpy.ndarray, optional
+        2D array of building heights; if provided, canopy overrides will not be
+        applied where buildings exist (height > 0).
+    under_tree_class_name : str, optional
+        Name of ground land-cover class to use under tree canopy. Defaults to 'Bareland'.
+    under_tree_cityles_code : int, optional
+        Explicit CityLES land-use code to use under canopy; if provided it takes
+        precedence over under_tree_class_name.
     """
     filename = output_path / 'landuse.txt'
     
@@ -261,7 +296,12 @@ def export_landuse(land_cover_grid, output_path, land_cover_source=None):
 
     print(f"Land cover source: {land_cover_source} (raw indices)")
 
-    # Create mapping statistics
+    # Resolve the CityLES code to use under tree canopy
+    under_tree_code = _resolve_under_tree_code(
+        under_tree_class_name, under_tree_cityles_code, land_cover_source
+    )
+
+    # Create mapping statistics: per raw index, count per resulting CityLES code
     mapping_stats = {}
     # Prepare grid to return
     cityles_landuse_grid = np.zeros((ny, nx), dtype=int)
@@ -272,24 +312,33 @@ def export_landuse(land_cover_grid, output_path, land_cover_source=None):
             for i in range(nx):
                 idx = int(land_cover_grid[j, i])
                 cityles_code = index_to_code.get(idx, 4)
+
+                # If a canopy grid is provided, override tree canopy cells to the
+                # specified ground class, optionally skipping where buildings exist.
+                if canopy_height_grid is not None:
+                    has_canopy = float(canopy_height_grid[j, i]) > 0.0
+                    has_building = False
+                    if building_height_grid is not None:
+                        has_building = float(building_height_grid[j, i]) > 0.0
+                    if has_canopy and not has_building:
+                        cityles_code = under_tree_code
                 f.write(f"{cityles_code}\n")
 
                 cityles_landuse_grid[j, i] = cityles_code
 
                 # Track mapping statistics
                 if idx not in mapping_stats:
-                    mapping_stats[idx] = {'cityles_code': cityles_code, 'count': 0}
-                mapping_stats[idx]['count'] += 1
+                    mapping_stats[idx] = {}
+                mapping_stats[idx][cityles_code] = mapping_stats[idx].get(cityles_code, 0) + 1
 
     # Print mapping summary
     print("\nLand cover mapping summary (by source class):")
     total = ny * nx
     for idx in sorted(mapping_stats.keys()):
-        stats = mapping_stats[idx]
-        percentage = (stats['count'] / total) * 100
         class_name = class_names[idx] if 0 <= idx < len(class_names) else 'Unknown'
-        print(f"  {idx}: {class_name} -> CityLES {stats['cityles_code']}: "
-              f"{stats['count']} cells ({percentage:.1f}%)")
+        for code, count in sorted(mapping_stats[idx].items()):
+            percentage = (count / total) * 100
+            print(f"  {idx}: {class_name} -> CityLES {code}: {count} cells ({percentage:.1f}%)")
     
     return cityles_landuse_grid
 
@@ -322,7 +371,7 @@ def export_dem(dem_grid, output_path):
                 f.write(f"{i_1based} {j_1based} {elevation:.1f}\n")
 
 
-def export_vmap(canopy_height_grid, output_path, tree_base_ratio=0.3, tree_type='default', building_height_grid=None, canopy_bottom_height_grid=None):
+def export_vmap(canopy_height_grid, output_path, trunk_height_ratio=0.3, tree_type='default', building_height_grid=None, canopy_bottom_height_grid=None):
     """
     Export vmap.txt file for CityLES
     
@@ -332,7 +381,7 @@ def export_vmap(canopy_height_grid, output_path, tree_base_ratio=0.3, tree_type=
         2D array of canopy heights
     output_path : Path
         Output directory path
-    tree_base_ratio : float
+    trunk_height_ratio : float
         Ratio of tree base height to total canopy height
     tree_type : str
         Tree type for mapping
@@ -366,7 +415,7 @@ def export_vmap(canopy_height_grid, output_path, tree_base_ratio=0.3, tree_type=
                 if canopy_bottom_height_grid is not None:
                     lower_height = float(np.clip(canopy_bottom_height_grid[j, i], 0.0, total_height))
                 else:
-                    lower_height = total_height * tree_base_ratio
+                    lower_height = total_height * trunk_height_ratio
                 upper_height = total_height
                 # Format: i j lower_height upper_height tree_type
                 f.write(f"{i_1based} {j_1based} {lower_height:.1f} {upper_height:.1f} {tree_code}\n")
@@ -412,11 +461,16 @@ def export_lonlat(rectangle_vertices, grid_shape, output_path):
                 f.write(f"{i_1based} {j_1based} {lon:.7f} {lat:.8f}\n")
 
 
-def export_cityles(building_height_grid, building_id_grid, canopy_height_grid,
-                   land_cover_grid, dem_grid, meshsize, land_cover_source,
-                   rectangle_vertices, output_directory="output/cityles",
-                   building_material='default', tree_type='default',
-                   tree_base_ratio=0.3, canopy_bottom_height_grid=None, **kwargs):
+def export_cityles(city: VoxCity,
+                   output_directory: str = "output/cityles",
+                   building_material: str = 'default',
+                   tree_type: str = 'default',
+                   trunk_height_ratio: float = 0.3,
+                   canopy_bottom_height_grid=None,
+                   under_tree_class_name: str = 'Bareland',
+                   under_tree_cityles_code=None,
+                   land_cover_source: str | None = None,
+                   **kwargs):
     """
     Export VoxCity data to CityLES format
     
@@ -444,7 +498,7 @@ def export_cityles(building_height_grid, building_id_grid, canopy_height_grid,
         Building material type for mapping
     tree_type : str
         Tree type for mapping
-    tree_base_ratio : float
+    trunk_height_ratio : float
         Ratio of tree base height to total canopy height
     **kwargs : dict
         Additional parameters (for compatibility)
@@ -457,11 +511,29 @@ def export_cityles(building_height_grid, building_id_grid, canopy_height_grid,
     output_path = create_cityles_directories(output_directory)
     
     print(f"Exporting CityLES files to: {output_path}")
+    # Resolve data from VoxCity
+    building_height_grid = city.buildings.heights
+    building_id_grid = city.buildings.ids if city.buildings.ids is not None else np.zeros_like(building_height_grid, dtype=int)
+    canopy_height_grid = city.tree_canopy.top if city.tree_canopy is not None else np.zeros_like(city.land_cover.classes, dtype=float)
+    land_cover_grid = city.land_cover.classes
+    dem_grid = city.dem.elevation
+    meshsize = float(city.voxels.meta.meshsize)
+    rectangle_vertices = city.extras.get("rectangle_vertices") or [(0.0, 0.0)] * 4
+    land_cover_source = land_cover_source or city.extras.get("land_cover_source", "Standard")
+
     print(f"Land cover source: {land_cover_source}")
     
     # Export individual files
     print("\nExporting landuse.txt...")
-    cityles_landuse_grid = export_landuse(land_cover_grid, output_path, land_cover_source)
+    cityles_landuse_grid = export_landuse(
+        land_cover_grid,
+        output_path,
+        land_cover_source,
+        canopy_height_grid=canopy_height_grid,
+        building_height_grid=building_height_grid,
+        under_tree_class_name=under_tree_class_name,
+        under_tree_cityles_code=under_tree_cityles_code,
+    )
 
     print("\nExporting topog.txt...")
     export_topog(
@@ -476,7 +548,7 @@ def export_cityles(building_height_grid, building_id_grid, canopy_height_grid,
     export_dem(dem_grid, output_path)
     
     print("\nExporting vmap.txt...")
-    export_vmap(canopy_height_grid, output_path, tree_base_ratio, tree_type, building_height_grid=building_height_grid, canopy_bottom_height_grid=canopy_bottom_height_grid)
+    export_vmap(canopy_height_grid, output_path, trunk_height_ratio, tree_type, building_height_grid=building_height_grid, canopy_bottom_height_grid=canopy_bottom_height_grid)
     
     print("\nExporting lonlat.txt...")
     export_lonlat(rectangle_vertices, building_height_grid.shape, output_path)
@@ -497,6 +569,11 @@ def export_cityles(building_height_grid, building_id_grid, canopy_height_grid,
         # Trees count after removing overlaps with buildings
         trees_count = int(np.sum(np.where(building_height_grid > 0, 0.0, canopy_height_grid) > 0))
         f.write(f"Trees: {trees_count}\n")
+        # Under-tree land-use selection
+        under_tree_code = _resolve_under_tree_code(
+            under_tree_class_name, under_tree_cityles_code, land_cover_source
+        )
+        f.write(f"Under-tree land use: {under_tree_class_name} (CityLES {under_tree_code})\n")
         
         # Add land use value ranges
         f.write(f"\nLand cover value range: {land_cover_grid.min()} - {land_cover_grid.max()}\n")
@@ -507,6 +584,24 @@ def export_cityles(building_height_grid, building_id_grid, canopy_height_grid,
     return str(output_path)
 
 
+class CityLesExporter:
+    """Exporter adapter to write a VoxCity model to CityLES text files."""
+
+    def export(self, obj, output_directory: str, base_filename: str, **kwargs):
+        if not isinstance(obj, VoxCity):
+            raise TypeError("CityLesExporter expects a VoxCity instance")
+        city: VoxCity = obj
+        # CityLES writes multiple files; use output_directory/base_filename as folder/name
+        out_dir = os.path.join(output_directory, base_filename)
+        os.makedirs(out_dir, exist_ok=True)
+        export_cityles(
+            city,
+            output_directory=out_dir,
+            **kwargs,
+        )
+        return out_dir
+
+
 # Helper function to apply VoxCity's convert_land_cover if needed
 def ensure_converted_land_cover(land_cover_grid, land_cover_source):
     """

voxcity/exporter/envimet.py

@@ -27,9 +27,10 @@ import os
 import numpy as np
 import datetime
 
-from ..geoprocessor.grid import apply_operation, translate_array, group_and_label_cells, process_grid
+from ..geoprocessor.raster import apply_operation, translate_array, group_and_label_cells, process_grid
 from ..geoprocessor.utils import get_city_country_name_from_rectangle, get_timezone_info
 from ..utils.lc import convert_land_cover
+from ..models import VoxCity
 
 def array_to_string(arr):
     """Convert a 2D numpy array to a string representation with comma-separated values.
@@ -136,21 +137,26 @@ def prepare_grids(building_height_grid_ori, building_id_grid_ori, canopy_height_
     building_height_grid = apply_operation(building_height_grid, meshsize)
 
     # Convert land cover if needed based on source
-    if (land_cover_source == 'OpenEarthMapJapan') or (land_cover_source == 'OpenStreetMap'):
-        land_cover_grid_converted = land_cover_grid_ori   
+    if land_cover_source == 'OpenStreetMap':
+        # OpenStreetMap uses Standard classification, just shift to 1-based
+        land_cover_grid_converted = land_cover_grid_ori + 1
     else:
+        # All other sources need remapping to standard indices
         land_cover_grid_converted = convert_land_cover(land_cover_grid_ori, land_cover_source=land_cover_source)        
 
-    land_cover_grid = np.flipud(land_cover_grid_converted).copy() + 1
+    land_cover_grid = np.flipud(land_cover_grid_converted).copy()
 
     # Dictionary mapping land cover types to vegetation codes
+    # Standard 1-based indices: 1=Bareland, 2=Rangeland, 3=Shrub, 4=Agriculture, 5=Tree, 
+    #                          6=Moss/lichen, 7=Wetland, 8=Mangrove, 9=Water, 10=Snow,
+    #                          11=Developed, 12=Road, 13=Building, 14=NoData
     veg_translation_dict = {
         1: '',  # Bareland
         2: '0200XX',  # Rangeland
         3: '0200H1',  # Shrub
-        4: '0200XX',  # Moss and lichen
-        5: '0200XX',  # Agriculture land
-        6: '',  # Tree
+        4: '0200XX',  # Agriculture land
+        5: '',  # Tree (handled separately as 3D vegetation)
+        6: '0200XX',  # Moss and lichen
         7: '0200XX',  # Wet land
         8: ''  # Mangroves
     }
@@ -161,9 +167,9 @@ def prepare_grids(building_height_grid_ori, building_id_grid_ori, canopy_height_
         1: '000000',  # Bareland
         2: '000000',  # Rangeland
         3: '000000',  # Shrub
-        4: '000000',  # Moss and lichen
-        5: '000000',  # Agriculture land
-        6: '000000',  # Tree
+        4: '000000',  # Agriculture land
+        5: '000000',  # Tree
+        6: '000000',  # Moss and lichen
         7: '0200WW',  # Wet land
         8: '0200WW',  # Mangroves
         9: '0200WW',  # Water
@@ -478,25 +484,18 @@ def save_file(content, output_file_path):
     with open(output_file_path, 'w', encoding='utf-8') as file:
         file.write(content)
 
-def export_inx(building_height_grid_ori, building_id_grid_ori, canopy_height_grid_ori, land_cover_grid_ori, dem_grid_ori, meshsize, land_cover_source, rectangle_vertices, **kwargs):
+def export_inx(city: VoxCity, output_directory: str, file_basename: str = 'voxcity', land_cover_source: str | None = None, **kwargs):
     """Export model data to ENVI-met INX file format.
     
     This is the main function for exporting voxel city data to ENVI-met format.
     It coordinates the entire export process from grid preparation to file saving.
     
     Args:
-        building_height_grid_ori (numpy.ndarray): Original building height grid
-        building_id_grid_ori (numpy.ndarray): Original building ID grid
-        canopy_height_grid_ori (numpy.ndarray): Original canopy height grid
-        land_cover_grid_ori (numpy.ndarray): Original land cover grid
-        dem_grid_ori (numpy.ndarray): Original DEM grid
-        meshsize (float): Size of mesh cells in meters
-        land_cover_source (str): Source of land cover data
-        rectangle_vertices (list): Vertices defining model area
-        **kwargs: Additional keyword arguments:
-            - output_directory (str): Directory to save output
-            - file_basename (str): Base filename for output
-            - Other args passed to create_xml_content()
+        city (VoxCity): VoxCity instance to export
+        output_directory (str): Directory to save output
+        file_basename (str): Base filename (without extension)
+        land_cover_source (str | None): Optional override for land cover source; defaults to city.extras
+        **kwargs: Additional keyword arguments passed to create_xml_content()
             
     Notes:
         - Creates output directory if it doesn't exist
@@ -504,20 +503,46 @@ def export_inx(building_height_grid_ori, building_id_grid_ori, canopy_height_gri
         - Generates complete INX file with all required data
         - Uses standardized file naming convention
     """
+    # Resolve inputs from VoxCity
+    meshsize = float(city.voxels.meta.meshsize)
+    rectangle_vertices = city.extras.get("rectangle_vertices") or [(0.0, 0.0)] * 4
+    lc_source = land_cover_source or city.extras.get("land_cover_source", "Standard")
+
     # Prepare grids
     building_height_grid_inx, building_id_grid, land_cover_veg_grid_inx, land_cover_mat_grid_inx, canopy_height_grid_inx, dem_grid_inx = prepare_grids(
-        building_height_grid_ori.copy(), building_id_grid_ori.copy(), canopy_height_grid_ori.copy(), land_cover_grid_ori.copy(), dem_grid_ori.copy(), meshsize, land_cover_source)    
+        city.buildings.heights.copy(),
+        (city.buildings.ids if city.buildings.ids is not None else np.zeros_like(city.buildings.heights, dtype=int)).copy(),
+        (city.tree_canopy.top if city.tree_canopy is not None else np.zeros_like(city.land_cover.classes, dtype=float)).copy(),
+        city.land_cover.classes.copy(),
+        city.dem.elevation.copy(),
+        meshsize,
+        lc_source)    
 
     # Create XML content
     xml_content = create_xml_content(building_height_grid_inx, building_id_grid, land_cover_veg_grid_inx, land_cover_mat_grid_inx, canopy_height_grid_inx, dem_grid_inx, meshsize, rectangle_vertices, **kwargs)
 
     # Save the output
-    output_dir = kwargs.get("output_directory", 'output')
+    output_dir = output_directory or 'output'
     os.makedirs(output_dir, exist_ok=True)
-    file_basename = kwargs.get("file_basename", 'voxcity')
     output_file_path = os.path.join(output_dir, f"{file_basename}.INX")
     save_file(xml_content, output_file_path)
 
+
+class EnvimetExporter:
+    """Exporter adapter to write a VoxCity model to ENVI-met INX format."""
+
+    def export(self, obj, output_directory: str, base_filename: str, **kwargs):
+        if not isinstance(obj, VoxCity):
+            raise TypeError("EnvimetExporter expects a VoxCity instance")
+        city: VoxCity = obj
+        export_inx(
+            city,
+            output_directory=output_directory,
+            file_basename=base_filename,
+            **kwargs,
+        )
+        return os.path.join(output_directory, f"{base_filename}.INX")
+
 def generate_edb_file(**kwargs):
     """Generate ENVI-met database file for 3D plants.
     

voxcity/exporter/magicavoxel.py

@@ -23,7 +23,7 @@ import numpy as np
 from pyvox.models import Vox
 from pyvox.writer import VoxWriter
 import os
-from ..utils.visualization import get_voxel_color_map
+from ..visualizer import get_voxel_color_map
 
 def convert_colormap_and_array(original_map, original_array):
     """
@@ -270,14 +270,14 @@ def export_magicavoxel_vox(array, output_dir, base_filename='chunk', voxel_color
     4. Progress reporting
     
     Args:
-        array (numpy.ndarray): 3D array containing voxel data.
-            Values should correspond to keys in voxel_color_map.
+        array (numpy.ndarray | VoxCity): 3D array containing voxel data or a VoxCity instance.
+            When a VoxCity is provided, its voxel classes are exported.
         output_dir (str): Directory to save the .vox files.
             Will be created if it doesn't exist.
         base_filename (str, optional): Base name for the output files.
             Defaults to 'chunk'. Used when model is split into multiple files.
         voxel_color_map (dict, optional): Dictionary mapping indices to RGB color values.
-            If None, uses default color map from utils.visualization.
+            If None, uses default color map from visualizer.
             Each value should be a list of [R,G,B] values (0-255).
     
     Note:
@@ -285,6 +285,14 @@ def export_magicavoxel_vox(array, output_dir, base_filename='chunk', voxel_color
         - Color mapping is optimized and made sequential
         - Progress information is printed to stdout
     """
+    # Accept VoxCity instance as first argument
+    try:
+        from ..models import VoxCity as _VoxCity
+        if isinstance(array, _VoxCity):
+            array = array.voxels.classes
+    except Exception:
+        pass
+
     # Use default color map if none provided
     if voxel_color_map is None:
         voxel_color_map = get_voxel_color_map()
@@ -294,4 +302,33 @@ def export_magicavoxel_vox(array, output_dir, base_filename='chunk', voxel_color
 
     # Export the model and print confirmation
     value_mapping, palette = export_large_voxel_model(converted_array, converted_voxel_color_map, output_dir, base_filename=base_filename)
-    print(f"\tvox files was successfully exported in {output_dir}")
+    print(f"\tvox files was successfully exported in {output_dir}")
+
+
+class MagicaVoxelExporter:
+    """Exporter adapter to write VoxCity voxels as MagicaVoxel .vox chunks.
+
+    Accepts either a VoxCity instance (uses `voxels.classes`) or a raw 3D numpy array.
+    """
+
+    def export(self, obj, output_directory: str, base_filename: str, **kwargs):
+        import numpy as _np
+        os.makedirs(output_directory, exist_ok=True)
+        try:
+            from ..models import VoxCity as _VoxCity
+            if isinstance(obj, _VoxCity):
+                export_magicavoxel_vox(
+                    obj.voxels.classes,
+                    output_directory,
+                    base_filename,
+                    voxel_color_map=kwargs.get("voxel_color_map"),
+                )
+                return output_directory
+        except Exception:
+            pass
+
+        if isinstance(obj, _np.ndarray) and obj.ndim == 3:
+            export_magicavoxel_vox(obj, output_directory, base_filename, voxel_color_map=kwargs.get("voxel_color_map"))
+            return output_directory
+
+        raise TypeError("MagicaVoxelExporter.export expects VoxCity or a 3D numpy array")

voxcity/exporter/netcdf.py

@@ -38,6 +38,7 @@ except Exception:  # pragma: no cover - optional dependency
 __all__ = [
     "voxel_to_xarray_dataset",
     "save_voxel_netcdf",
+    "NetCDFExporter",
 ]
 
 
@@ -209,3 +210,29 @@ def save_voxel_netcdf(
     return str(path)
 
 
+class NetCDFExporter:
+    """Exporter adapter to write a VoxCity voxel grid to NetCDF."""
+
+    def export(self, obj, output_directory: str, base_filename: str, **kwargs):
+        from ..models import VoxCity
+        path = Path(output_directory) / f"{base_filename}.nc"
+        if not isinstance(obj, VoxCity):
+            raise TypeError("NetCDFExporter expects a VoxCity instance")
+        rect = obj.extras.get("rectangle_vertices")
+        # Merge default attrs with user-provided extras
+        user_extra = kwargs.get("extra_attrs") or {}
+        attrs = {
+            "land_cover_source": obj.extras.get("land_cover_source", ""),
+            "building_source": obj.extras.get("building_source", ""),
+            "dem_source": obj.extras.get("dem_source", ""),
+        }
+        attrs.update(user_extra)
+        return save_voxel_netcdf(
+            voxcity_grid=obj.voxels.classes,
+            output_path=path,
+            voxel_size_m=obj.voxels.meta.meshsize,
+            rectangle_vertices=rect,
+            extra_attrs=attrs,
+            engine=kwargs.get("engine"),
+        )
+