So, out of frustration (and to see how far I can push copilot), I got copilot to write a pyton script for fix the position of the diagram. If copilot (chatGPT) can do this in a few minutes, I don't know why Microsoft can't have a button to do the same in Power BI!
Simply:
1. save and close the power BI
2. rename the <Report>.pbix to <Report>.pbix.zip and extract DiagramLayout file
3. run the python similar to the following:
python RepositionPowerBIModelView.py "DiagramLayout" -o "DiagramLayout" --MinX 100 --MinY 100
4. Put the file back in <Report>.pbix.zip, overwriting the original
5. Rename the file back to <Report>.pbix
Python code (Provided with no promises or guarantees... USE AT YOUR OWN RISK!!!):
import json
import argparse
from pathlib import Path
from typing import Any, Tuple, Optional
# -----------------------------
# Encoding-aware JSON load/save
# -----------------------------
def detect_encoding(raw: bytes) -> str:
"""
Detect likely encoding for Power BI DiagramLayout files.
- BOM UTF-16 LE/BE -> 'utf-16' (Python handles BOM)
- NUL bytes early -> UTF-16LE without BOM (common for these files; your sample shows this) [1](https://openwayfood-my.sharepoint.com/personal/amay_openwayfood_com_au/Documents/Microsoft%20Copilot%20Chat%20Files/DiagramLayout.json?web=1)
- Otherwise assume UTF-8 (with optional BOM via utf-8-sig)
"""
if raw.startswith(b"\xff\xfe") or raw.startswith(b"\xfe\xff"):
return "utf-16"
if b"\x00" in raw[:200]:
return "utf-16-le"
return "utf-8-sig"
def load_json_file(path: Path) -> Tuple[dict[str, Any], str]:
"""
Returns (data_dict, detected_output_encoding).
detected_output_encoding is normalized to:
- 'utf-16-le' if input is UTF-16-ish
- 'utf-8' otherwise
"""
raw = path.read_bytes()
enc = detect_encoding(raw)
text = raw.decode(enc)
text = text.lstrip("\ufeff").lstrip() # remove BOM char + whitespace if present
data = json.loads(text)
if not isinstance(data, dict):
raise ValueError(f"Top-level JSON is not an object/dict. Got: {type(data)}")
# Normalize "match" output encoding to utf-16-le or utf-8
out_enc = "utf-16-le" if enc in ("utf-16", "utf-16-le") else "utf-8"
return data, out_enc
def save_json_file_minified(path: Path, data: dict[str, Any], encoding: str) -> None:
"""
Writes MINIFIED (compressed) JSON, no indentation.
separators=(',', ':') removes unnecessary whitespace.
ensure_ascii=False preserves any non-ASCII characters as-is.
"""
text = json.dumps(data, ensure_ascii=False, separators=(",", ":"))
path.write_text(text, encoding=encoding)
# -----------------------------
# Diagram operations
# -----------------------------
def list_diagram_names(data: dict[str, Any]) -> list[str]:
diagrams = data.get("diagrams")
if not isinstance(diagrams, list):
return []
return [str(d.get("name", "")) for d in diagrams]
def find_diagram(data: dict[str, Any], diagram_name: str) -> dict[str, Any]:
diagrams = data.get("diagrams")
if not isinstance(diagrams, list):
raise ValueError("JSON does not contain a 'diagrams' array.")
target = diagram_name.strip().lower()
for d in diagrams:
name = str(d.get("name", "")).strip().lower()
if name == target:
return d
available = list_diagram_names(data)
raise ValueError(f'No diagram named "{diagram_name}" found. Available: {available}')
def compute_min_xy(nodes: list[dict[str, Any]]) -> Tuple[float, float]:
xs: list[float] = []
ys: list[float] = []
for n in nodes:
loc = n.get("location", {})
x = loc.get("x", None)
y = loc.get("y", None)
if isinstance(x, (int, float)):
xs.append(float(x))
if isinstance(y, (int, float)):
ys.append(float(y))
if not xs:
raise ValueError("No numeric node.location.x values found in nodes.")
if not ys:
raise ValueError("No numeric node.location.y values found in nodes.")
return min(xs), min(ys)
def shift_nodes(nodes: list[dict[str, Any]], delta_x: float, delta_y: float) -> int:
changed = 0
for n in nodes:
loc = n.get("location")
if isinstance(loc, dict):
updated = False
if isinstance(loc.get("x", None), (int, float)):
loc["x"] = float(loc["x"]) + delta_x
updated = True
if isinstance(loc.get("y", None), (int, float)):
loc["y"] = float(loc["y"]) + delta_y
updated = True
if updated:
changed += 1
return changed
def process_file(
input_path: str,
output_path: Optional[str],
min_x: float,
min_y: float,
diagram_name: str,
shift_scroll: bool,
output_encoding_mode: str
) -> None:
input_file = Path(input_path)
if not input_file.exists():
raise FileNotFoundError(f"Input file not found: {input_file}")
output_file = Path(output_path) if output_path else input_file
data, detected_out_enc = load_json_file(input_file)
# Resolve output encoding
if output_encoding_mode == "match":
out_enc = detected_out_enc
elif output_encoding_mode == "utf-16-le":
out_enc = "utf-16-le"
else:
out_enc = "utf-8"
diagram = find_diagram(data, diagram_name)
nodes = diagram.get("nodes")
if not isinstance(nodes, list) or len(nodes) == 0:
raise ValueError(f'Diagram "{diagram_name}" has no nodes array (or it is empty).')
current_min_x, current_min_y = compute_min_xy(nodes)
# Shift so that new minimums become MinX and MinY:
delta_x = float(min_x) - current_min_x
delta_y = float(min_y) - current_min_y
changed_nodes = shift_nodes(nodes, delta_x, delta_y)
# Optional: shift scrollPosition too (keeps viewport aligned with moved nodes)
if shift_scroll:
sp = diagram.get("scrollPosition")
if isinstance(sp, dict):
if isinstance(sp.get("x", None), (int, float)):
sp["x"] = float(sp["x"]) + delta_x
if isinstance(sp.get("y", None), (int, float)):
sp["y"] = float(sp["y"]) + delta_y
# Write MINIFIED JSON
save_json_file_minified(output_file, data, encoding=out_enc)
print(f"Updated '{input_file}' -> '{output_file}'")
print(f'Diagram processed: "{diagram_name}"')
print(f" currentMinX={current_min_x:.6f}, currentMinY={current_min_y:.6f}")
print(f" targetMinX={min_x:.6f}, targetMinY={min_y:.6f}")
print(f" deltaX={delta_x:.6f}, deltaY={delta_y:.6f}")
print(f" nodes shifted={changed_nodes}")
print(f" output encoding: {out_enc}")
print(" output format: minified JSON")
if shift_scroll:
print(" scrollPosition shifted: yes")
def main():
parser = argparse.ArgumentParser(
description="Shift a Power BI diagram's node locations so minimum X/Y become specified values."
)
parser.add_argument("input", help="Input layout file path (e.g., DiagramLayout.json)")
parser.add_argument("-o", "--output", default=None,
help="Output file path (defaults to overwrite input)")
parser.add_argument("--MinX", type=float, required=False, help="New minimum X for nodes")
parser.add_argument("--MinY", type=float, required=False, help="New minimum Y for nodes")
parser.add_argument("--DiagramName", default="All tables",
help='Diagram name to process (default: "All tables")')
parser.add_argument("--shift-scroll", action="store_true",
help="Also shift diagram.scrollPosition by the same deltaX/deltaY")
parser.add_argument("--list-diagrams", action="store_true",
help="List diagram names in the file and exit")
parser.add_argument(
"--output-encoding",
default="match",
choices=["match", "utf-16-le", "utf-8"],
help="Output encoding: match (default), utf-16-le, or utf-8"
)
args = parser.parse_args()
if args.list_diagrams:
data, _ = load_json_file(Path(args.input))
names = list_diagram_names(data)
print("Diagrams found:")
for n in names:
print(f" - {n}")
return
if args.MinX is None or args.MinY is None:
parser.error("--MinX and --MinY are required unless --list-diagrams is used.")
process_file(
input_path=args.input,
output_path=args.output,
min_x=args.MinX,
min_y=args.MinY,
diagram_name=args.DiagramName,
shift_scroll=args.shift_scroll,
output_encoding_mode=args.output_encoding
)
if __name__ == "__main__":
main()
