Blocks Come in At Different Insert Scale?

[LoRue656Plus10]

Hello,
I am working on a script that will group nearby entities on selected layers and create blocks. It works mostly, except that in the generated DXF file, the insertion scale defaults to Feet, while the source drawing is set to Inches or Unitless (doesn't seem to matter). This of course means the blocks are not placed where they should be. I have tried the doc.header["$INSUNITS"] = 1 and doc.header["$INSUNITS"] = InsertUnits.Inches in various places but no dice. Any insight is appreciated.

import ezdxf
import tkinter as tk
from tkinter import filedialog
from ezdxf.math import BoundingBox
from ezdxf.bbox import multi_flat
from ezdxf.enums import InsertUnits
from typing import Iterable


def generate_unique_name(counter):
    """Generate a unique block name."""
    name = "Block_" + str(counter)
    return name[:10] if len(name) > 10 else name


def calculate_bbox(entity):
    """Calculate bounding box for a single entity."""
    try:
        bbox = list(multi_flat([entity]))
        return bbox[0] if bbox else None
    except Exception as e:
        print("Error calculating bounding box:", e)
        return None


def entities_intersect(ent1, ent2):
    """Check if two entities intersect based on bounding boxes."""
    try:
        if ent1.dxf.handle == ent2.dxf.handle:
            return False

        bbox1 = calculate_bbox(ent1)
        bbox2 = calculate_bbox(ent2)

        if bbox1 and bbox2:
            return bbox1.has_overlap(bbox2)  # Use overlap for bounding boxes
        return False
    except Exception as e:
        print("Error checking intersection:", e)
        return False


def group_entities(doc, selected_layers):
    """Group intersecting entities on selected layers."""
    entities = doc.modelspace().query('LINE CIRCLE ARC LWPOLYLINE POLYLINE HATCH')
    filtered_entities = [e for e in entities if e.dxf.layer in selected_layers]
    groups = []
    visited = set()

    for ent in filtered_entities:
        if ent.dxf.handle in visited:
            continue
        group = [ent]
        to_check = [ent]
        while to_check:
            current = to_check.pop()
            for other in filtered_entities:
                if other.dxf.handle not in visited and entities_intersect(current, other):
                    visited.add(other.dxf.handle)
                    to_check.append(other)
                    group.append(other)
        groups.append(group)
    return groups


def get_entity_base_point(entity):
    """Get a base point for the block from the first entity."""
    if entity.dxftype() == "LINE":
        return entity.dxf.start
    elif entity.dxftype() in {"CIRCLE", "ARC"}:
        return entity.dxf.center
    elif entity.dxftype() in {"LWPOLYLINE", "POLYLINE"}:
        points = list(entity.get_points())
        return points[0][:2]  # Take the first point
    return (0, 0)  # Fallback base point


def create_block(doc, group, name):
    """Create a block for a group of entities."""
    try:
        # Create a new block with a unique name
        block = doc.blocks.new(name=name)

        # Determine the base point for the block
        base_point = get_entity_base_point(group[0])

        for ent in group:
            # Add the entity to the block definition
            if ent.dxftype() == "LINE":
                block.add_line(ent.dxf.start, ent.dxf.end)
            elif ent.dxftype() == "CIRCLE":
                block.add_circle(ent.dxf.center, ent.dxf.radius)
            elif ent.dxftype() == "ARC":
                block.add_arc(
                    ent.dxf.center,
                    ent.dxf.radius,
                    ent.dxf.start_angle,
                    ent.dxf.end_angle,
                )
            elif ent.dxftype() == "LWPOLYLINE":
                points = list(ent.get_points("xy"))
                block.add_lwpolyline(points, close=ent.is_closed)
            elif ent.dxftype() == "HATCH":
                block.add_hatch()

        print("Block created:", name, "with", len(group), "entities")

        # Add a block reference to the modelspace
        msp = doc.modelspace()
        msp.add_blockref(name, base_point)

        # Optionally remove original entities from modelspace (if needed)
        for ent in group:
            doc.modelspace().delete_entity(ent)
    except Exception as e:
        print("Error creating block:", name, e)


def main():
    # Set up the Tkinter root
    root = tk.Tk()
    root.withdraw()  # Hide the main window

    # Open file dialog to select a DXF file
    file_path = filedialog.askopenfilename(
        title="Select a DXF file",
        filetypes=(("DXF files", "*.dxf"), ("All files", "*.*"))
    )
    if not file_path:
        print("No file selected.")
        return

    doc = ezdxf.readfile(file_path)

    # Ask user for layers to process
    print("Available layers:")
    layers = list(set(ent.dxf.layer for ent in doc.modelspace().query("*")))
    for i, layer in enumerate(layers, 1):
        print(f"{i}. {layer}")

    selected_indices = input("Enter the numbers of the layers to process, separated by commas: ")
    selected_layers = [layers[int(i) - 1] for i in selected_indices.split(",")]

    # Set insertion units to inches
    doc.header["$INSUNITS"] = InsertUnits.Inches

    # Group entities from the selected layers
    groups = group_entities(doc, selected_layers)
    print(f"Grouped entities into {len(groups)} blocks")

    # Create blocks from groups
    counter = 1
    for group in groups:
        if len(group) > 1:  # Skip single-entity groups
            name = generate_unique_name(counter)
            create_block(doc, group, name)
            counter += 1

    # Save the modified DXF file
    save_path = filedialog.asksaveasfilename(
        title="Save DXF file",
        defaultextension=".dxf",
        filetypes=(("DXF files", "*.dxf"), ("All files", "*.*"))
    )
    if save_path:
        doc.saveas(save_path)
    else:
        print("Save operation cancelled.")


if __name__ == "__main__":
    main()

[LoRue656Plus10]

Welp, looks like all I had to do was set the base point at 0,0. Yay!