fix: resolve linting errors in Z-Image ControlNet support

- Add missing ControlNet_Checkpoint_ZImage_Config import
- Remove unused imports (Any, Dict, ADALN_EMBED_DIM, is_torch_version)
- Add strict=True to zip() calls
- Replace mutable list defaults with immutable tuples
- Replace dict() calls with literal syntax
- Sort imports in z_image_denoise.py

Author: Pfannkuchensack

invokeai/app/invocations/z_image_denoise.py

@@ -19,10 +19,10 @@
     LatentsField,
     ZImageConditioningField,
 )
-from invokeai.app.invocations.z_image_control import ZImageControlField
-from invokeai.app.invocations.z_image_image_to_latents import ZImageImageToLatentsInvocation
 from invokeai.app.invocations.model import TransformerField, VAEField
 from invokeai.app.invocations.primitives import LatentsOutput
+from invokeai.app.invocations.z_image_control import ZImageControlField
+from invokeai.app.invocations.z_image_image_to_latents import ZImageImageToLatentsInvocation
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelFormat
 from invokeai.backend.patches.layer_patcher import LayerPatcher

invokeai/backend/model_manager/load/model_loaders/z_image.py

@@ -9,6 +9,7 @@
 from transformers import AutoTokenizer, Qwen3ForCausalLM
 
 from invokeai.backend.model_manager.configs.base import Checkpoint_Config_Base, Diffusers_Config_Base
+from invokeai.backend.model_manager.configs.controlnet import ControlNet_Checkpoint_ZImage_Config
 from invokeai.backend.model_manager.configs.factory import AnyModelConfig
 from invokeai.backend.model_manager.configs.main import Main_Checkpoint_ZImage_Config, Main_GGUF_ZImage_Config
 from invokeai.backend.model_manager.configs.qwen3_encoder import (

invokeai/backend/z_image/z_image_control_adapter.py

@@ -10,18 +10,16 @@
 control-specific layers (control_layers, control_all_x_embedder, control_noise_refiner).
 """
 
-from typing import Any, Dict, List, Optional
+from typing import List, Optional
 
 import torch
 import torch.nn as nn
 from diffusers.configuration_utils import ConfigMixin, register_to_config
 from diffusers.models.modeling_utils import ModelMixin
 from diffusers.models.transformers.transformer_z_image import (
-    ADALN_EMBED_DIM,
     SEQ_MULTI_OF,
     ZImageTransformerBlock,
 )
-from diffusers.utils import is_torch_version
 from torch.nn.utils.rnn import pad_sequence
 
 
@@ -105,7 +103,7 @@ def __init__(
 
         # Control patch embeddings
         all_x_embedder = {}
-        for patch_size, f_patch_size in zip(all_patch_size, all_f_patch_size):
+        for patch_size, f_patch_size in zip(all_patch_size, all_f_patch_size, strict=True):
             x_embedder = nn.Linear(
                 f_patch_size * patch_size * patch_size * control_in_dim,
                 dim,

invokeai/backend/z_image/z_image_control_transformer.py

@@ -15,7 +15,6 @@
 import torch.nn as nn
 from diffusers.configuration_utils import register_to_config
 from diffusers.models.transformers.transformer_z_image import (
-    ADALN_EMBED_DIM,
     SEQ_MULTI_OF,
     ZImageTransformer2DModel,
     ZImageTransformerBlock,
@@ -151,8 +150,8 @@ def __init__(
         cap_feat_dim: int = 2560,
         rope_theta: float = 256.0,
         t_scale: float = 1000.0,
-        axes_dims: List[int] = [32, 48, 48],
-        axes_lens: List[int] = [1024, 512, 512],
+        axes_dims: tuple[int, ...] = (32, 48, 48),
+        axes_lens: tuple[int, ...] = (1024, 512, 512),
     ):
         super().__init__(
             all_patch_size=all_patch_size,
@@ -174,7 +173,7 @@ def __init__(
 
         # Control layer configuration
         self.control_layers_places = (
-            [i for i in range(0, n_layers, 2)] if control_layers_places is None else control_layers_places
+            list(range(0, n_layers, 2)) if control_layers_places is None else control_layers_places
         )
         self.control_in_dim = in_channels if control_in_dim is None else control_in_dim
 
@@ -216,7 +215,7 @@ def __init__(
 
         # Control patch embeddings
         all_x_embedder = {}
-        for patch_size, f_patch_size in zip(all_patch_size, all_f_patch_size):
+        for patch_size, f_patch_size in zip(all_patch_size, all_f_patch_size, strict=True):
             x_embedder = nn.Linear(
                 f_patch_size * patch_size * patch_size * self.control_in_dim,
                 dim,
@@ -585,7 +584,7 @@ def custom_forward(*inputs):
             cap_len = cap_item_seqlens[i]
             unified.append(torch.cat([x[i][:x_len], cap_feats[i][:cap_len]]))
             unified_freqs_cis.append(torch.cat([x_freqs_cis[i][:x_len], cap_freqs_cis[i][:cap_len]]))
-        unified_item_seqlens = [a + b for a, b in zip(cap_item_seqlens, x_item_seqlens)]
+        unified_item_seqlens = [a + b for a, b in zip(cap_item_seqlens, x_item_seqlens, strict=True)]
         unified_max_item_seqlen = max(unified_item_seqlens)
 
         unified = pad_sequence(unified, batch_first=True, padding_value=0.0)
@@ -595,11 +594,11 @@ def custom_forward(*inputs):
             unified_attn_mask[i, :seq_len] = 1
 
         # Generate control hints
-        kwargs = dict(
-            attn_mask=unified_attn_mask,
-            freqs_cis=unified_freqs_cis,
-            adaln_input=adaln_input,
-        )
+        kwargs = {
+            "attn_mask": unified_attn_mask,
+            "freqs_cis": unified_freqs_cis,
+            "adaln_input": adaln_input,
+        }
         hints = self.forward_control(
             unified,
             cap_feats,
@@ -612,13 +611,13 @@ def custom_forward(*inputs):
 
         # Main transformer with control hints
         for layer in self.layers:
-            layer_kwargs = dict(
-                attn_mask=unified_attn_mask,
-                freqs_cis=unified_freqs_cis,
-                adaln_input=adaln_input,
-                hints=hints,
-                context_scale=control_context_scale,
-            )
+            layer_kwargs = {
+                "attn_mask": unified_attn_mask,
+                "freqs_cis": unified_freqs_cis,
+                "adaln_input": adaln_input,
+                "hints": hints,
+                "context_scale": control_context_scale,
+            }
             if torch.is_grad_enabled() and self.gradient_checkpointing:
 
                 def create_custom_forward(module, **static_kwargs):