3jSSKrSSKrSSKJr SSKJr SSKJrJr SSK J r SSK J r SS K JrJrJrJr SS KJrJrJr S S K Jr \ R."\5r"S S\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r "SS\5r!"SS\!5r""SS \!5r#"S!S"\!5r$"S#S$\!5r%"S%S&\!5r&"S'S(\!5r'"S)S*\!5r(g)+N) FrozenDict)ClassifierFreeGuidance)QwenImageControlNetModelQwenImageTransformer2DModel)FlowMatchEulerDiscreteScheduler)logging) BlockStateLoopSequentialPipelineBlocksModularPipelineBlocks PipelineState) ComponentSpec InputParam OutputParam)QwenImageModularPipelinec \rSrSrSr\S\4Sj5r\S\\ 4Sj5r \ R"5S\ S\S\S \ R 4S j5rS rg ) QwenImageLoopBeforeDenoiser% qwenimagereturncgNzstep within the denoising loop that prepares the latent input for the denoiser. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)selfs g/home/wildlama/miniconda3/lib/python3.13/site-packages/diffusers/modular_pipelines/qwenimage/denoise.py description'QwenImageLoopBeforeDenoiser.description(  : c8[SS[RSS9/$)NlatentsT^The initial latents to use for the denoising process. Can be generated in prepare_latent step.namerequired type_hintr)rtorchTensorrs rinputs"QwenImageLoopBeforeDenoiser.inputs0s& ,,|    r" components block_stateitcURURRS5RURR5UlURUlX4$)Nr)expandr$shapetodtypetimesteplatent_model_inputrr.r/r0r1s r__call__$QwenImageLoopBeforeDenoiser.__call__;sT !xx (;(;(A(A!(DEHHI\I\IbIbc )4)<)< &&&r"rN__name__ __module__ __qualname____firstlineno__ model_namepropertystrrlistrr,r*no_gradrr intr+r:__static_attributes__rr"rrr%sJ  S   Z(   ]]_'#;'*'Y\'afamam''r"rc \rSrSrSr\S\4Sj5r\S\\ 4Sj5r \ R"5S\ S\S\S \ R 4S j5rS rg ) QwenImageEditLoopBeforeDenoiserCqwenimage-editrcgrrrs rr+QwenImageEditLoopBeforeDenoiser.descriptionFr!r"cb[SS[RSS9[R"S5/$)Nr$Tr%r& image_latentsrr*r+templaters rr,&QwenImageEditLoopBeforeDenoiser.inputsNs6 ,,|      0  r"r.r/r0r1c[R"URUR/SS9UlUR URR S5RURR5Ul X4$)Nr)dimr) r*catr$rOr8r3r4r5r6r7r9s rr:(QwenImageEditLoopBeforeDenoiser.__call__Zsk*/K4G4GIbIb3cij)k & xx (;(;(A(A!(DEHHI\I\IbIbc &&r"rNr<rr"rrIrICs!J  S    Z(     ]]_'#;'*'Y\'afamam''r"rIc \rSrSrSr\S\\4Sj5r\S\ 4Sj5r \S\\ 4Sj5r \ R"5S\S\S \S \4S j5rS rg )%QwenImageLoopBeforeDenoiserControlNetcrrcX[S[[SS05SS9[S[5/$)Nguiderguidance_scale@ from_configconfigdefault_creation_method controlnet)rrrrrs rexpected_components9QwenImageLoopBeforeDenoiserControlNet.expected_componentsfs: &!#3S"9:(5   ,(@ A  r"cg)Nzstep within the denoising loop that runs the controlnet before the denoiser. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)rrs rr1QwenImageLoopBeforeDenoiserControlNet.descriptionrr!r"c [SS[RSS9[R"SSS9[SS[[ S S 9/$) Ncontrol_image_latentsTzgThe control image to use for the denoising process. Can be generated in prepare_controlnet_inputs step.r(r)rcontrolnet_conditioning_scalez*updated in prepare_controlnet_inputs step.)notecontrolnet_keepzOThe controlnet keep values. Can be generated in prepare_controlnet_inputs step.r&)rr*r+rQrDfloatrs rr,,QwenImageLoopBeforeDenoiserControlNet.inputszsU ',,F      ?Fr s &u+m    r"r.r/r0r1c *[URU[5(a@[URURU5VVs/sH upVXV-PM snnUlOr?r@rArBrDrrcrCrrr,r*rErr rFr:rGrr"rrXrXcsJ   T-%8     S   Z(  " ]]_'#;'*'Y\'ad''r"rXc \rSrSrSr\S\4Sj5r\S\\ 4Sj5r \S\\ 4Sj5r \ R"5S\S\S \S \ R$4S j5rS rg )QwenImageLoopDenoiserrrcgNzstep within the denoising loop that denoise the latent input for the denoiser. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)rrs rr!QwenImageLoopDenoiser.descriptionr!r"cX[S[[SS05SS9[S[5/$Nr[r\r]r^r_ transformerrrrrrs rrc)QwenImageLoopDenoiser.expected_components: &!#3S"9:(5   -)D E  r"c [R"S5[R"S5[SS[[[[4SS9/$)Nattention_kwargsdenoiser_input_fieldsrtTzhThe shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step.rirrQrDtuplerFrs rr,QwenImageLoopDenoiser.inputsP    2 3    7 8 uS#X/G    r"r.r/r0r1c [USS5[USS54[USS5[USS54S.n[[R"URR 5R R55n0nURR5HupX;dM X;dMXU'M URRU5 URRX2RUS9 URRU5n U Hn URR!UR5 UR5V s0sHo[X5_M n n UR"SUR"UR$S- UR&SS .U DURD6S U lURR+UR5 M URU 5n[,R."UR0S S S 9n[,R."UR2S S S 9nUR2UU- -UlX4$s sn f)Nr|negative_prompt_embedsr}negative_prompt_embeds_maskrurvstepnum_inference_stepsr7rpFrqr7rrwrTrTkeepdimr)getattrsetinspect signaturerforward parameterskeysritemsr~updater[ set_staterprepare_inputsprepare_modelsr8r7r noise_predcleanup_modelsr*norm pred_condpred)rr.r/r0r1 guider_inputstransformer_argsr~ field_name field_value guider_stateguider_state_batch input_name cond_kwargs guider_outputpred_cond_norm pred_norms rr:QwenImageLoopDenoiser.__call__s7 _d; %=tD&  %94@ %BDI+  w001G1G1O1OP[[``bc!#'2'H'H'N'N'P #J-*2Q5@z2(Q **112HI##@_@_jk#l!((77 F ".     , ,Z-C-C DanasasauvauS]w/A'NNauKv-7,B,B-)<<$--4!,!=!=! -  - 44 --  )    , ,Z-C-C D#/ #)),7 M$;$;TRJJ}11r4H !.!3!3~ 7Q!R &&+wsIrNr=r>r?r@rArBrCrrDrrcrr,r*rErr rFr+r:rGrr"rrrsJ  S    T-%8      Z(     ]]_-'#;-'*-'Y\-'afamam-'-'r"rc \rSrSrSr\S\4Sj5r\S\\ 4Sj5r \S\\ 4Sj5r \ R"5S\S\S \S \ R$4S j5rS rg )QwenImageEditLoopDenoiserrKrcgrrrs rr%QwenImageEditLoopDenoiser.descriptionr!r"cX[S[[SS05SS9[S[5/$rrrs rrc-QwenImageEditLoopDenoiser.expected_components rr"c [R"S5[R"S5[SS[[[[4SS9/$)NrrrtTzhThe shape of the image latents for RoPE calculation. Can be generated in prepare_additional_inputs step.rirrs rr, QwenImageEditLoopDenoiser.inputsrr"r.r/r0r1c [USS5[USS54[USS5[USS54S.n[[R"URR 5R R55n0nURR5HupX;dM X;dMXU'M URRU5 URRX2RUS9 URRU5n U Hn URR!UR5 UR5V s0sHo[X5_M n n UR"SUR"UR$S- UR&SS .U DURD6S U lURR+UR5 M URU 5nUR,SS2SUR.R1S 524nUR2SS2SUR.R1S 524n[4R6"US S S9n[4R6"US S S9nUUU- -UlX4$s sn f)Nr|rr}rrrrpFrrrrTrr)rrrrrrrrrrr~rr[rrrrr8r7rrrrr$sizerr*r)rr.r/r0r1rrr~rrrrrrrrrrrs rr:"QwenImageEditLoopDenoiser.__call__$s} _d; %=tD&  %94@ %BDI+  w001G1G1O1OP[[``bc!#'2'H'H'N'N'P #J-*2Q5@z2(Q **112HI##@_@_jk#l!((77 F ".     , ,Z-C-C DanasasauvauS]w/A'NNauKv-7,B,B-)<<$--4!,!=!=! -  - 44 --  )    , ,Z-C-C D#/ #)),7 !!!%B{':':'?'?'B%B"BC!++A/L1D1D1I1I!1L/L,LM I2tDJJtT: !%))C!D &&1wsJrNrrr"rrrs!J  S    T-%8      Z(     ]]_0'#;0'*0'Y\0'afamam0'0'r"rc \rSrSrSr\S\4Sj5r\S\\ 4Sj5r \S\\ 4Sj5r \ R"5S\S\S \S \ R$4S j5rS rg )QwenImageLoopAfterDenoiseriYrrcg)Nzstep within the denoising loop that updates the latents. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)rrs rr&QwenImageLoopAfterDenoiser.description\r!r"c$[S[5/$N schedulerrrrs rrc.QwenImageLoopAfterDenoiser.expected_componentsd +'F G  r"c0[R"S5/$Nr$rrQrs rintermediate_outputs/QwenImageLoopAfterDenoiser.intermediate_outputsj   +  r"r.r/r0r1crURRnURRURUURSS9SUlURRU:waM[ R RR5(a URRU5UlX4$)NF)rwr) r$r6rrrr*backendsmps is_availabler5)rr.r/r0r1 latents_dtypes rr:#QwenImageLoopAfterDenoiser.__call__ps#++11 (2277  " "    8      $ $ 5~~!!..00&1&9&9&<&<]&K #&&r"rN)r=r>r?r@rArBrCrrDrrcrrr*rErr rFr+r:rGrr"rrrYsJ  S   T-%8   d;&7   ]]_'#;'*'Y\'afamam''r"rc \rSrSrSr\S\4Sj5r\S\\ 4Sj5r \S\\ 4Sj5r \ R"5S\S\S \S \ R$4S j5rS rg )!QwenImageLoopAfterDenoiserInpaintirrcg)Nzstep within the denoising loop that updates the latents using mask and image_latents for inpainting. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)rrs rr-QwenImageLoopAfterDenoiserInpaint.descriptionr!r"c [SS[RSS9[R"S5[SS[RSS9/$)NmaskTz]The mask to use for the inpainting process. Can be generated in inpaint prepare latents step.rirO initial_noisezfThe initial noise to use for the inpainting process. Can be generated in inpaint prepare latents step.rPrs rr,(QwenImageLoopAfterDenoiserInpaint.inputssQ ,,{      0 ,,E    r"c0[R"S5/$rrrs rr6QwenImageLoopAfterDenoiserInpaint.intermediate_outputsrr"r.r/r0r1cURUlU[UR5S- :alURUS-UlUR R UR[R"UR/5UR5UlSUR- UR-URUR--Ul X4$)Nr) rOinit_latents_properlen timestepsnoise_timestepr scale_noiser*tensorrrr$r9s rr:*QwenImageLoopAfterDenoiserInpaint.__call__s*5*C*C ' s;(()A- -)4)>)>q1u)EK &.8.B.B.N.N//{?Y?Y>Z1[]h]v]v/K +     + +,.9.>.>ATAT.TU &&r"rN)r=r>r?r@rArBrCrrDrr,rrr*rErr rFr+r:rGrr"rrrsJ  S   Z(  " d;&7   ]]_ '#; '* 'Y\ 'afamam ' 'r"rc\rSrSrSr\S\4Sj5r\S\\ 4Sj5r \S\\ 4Sj5r \ R"5S\S\S\4S j5rS rg ) QwenImageDenoiseLoopWrapperirrcg)NzPipeline block that iteratively denoise the latents over `timesteps`. The specific steps with each iteration can be customized with `sub_blocks` attributesrrs rr'QwenImageDenoiseLoopWrapper.descriptions  d r"c$[S[5/$rrrs rloop_expected_components4QwenImageDenoiseLoopWrapper.loop_expected_componentsrr"c`[SS[RSS9[R"SSS9/$)NrTzWThe timesteps to use for the denoising process. Can be generated in set_timesteps step.r&r)r(rPrs r loop_inputs'QwenImageDenoiseLoopWrapper.loop_inputss9  ,,u      5 E  r"r.statec vURU5n[[UR5URUR R -- S5Ul0UlURURS9n[UR5HzupVURXXVS9upU[UR5S- :Xd7US-UR:dMHUS-UR R -S:XdMjUR5 M| SSS5 URX#5 X4$!,(df  N"=f)Nr)total)r0r1r)get_block_statemaxrrrrordernum_warmup_stepsr~ progress_bar enumerate loop_steprset_block_state)rr.rr/rr0r1s rr:$QwenImageDenoiseLoopWrapper.__call__s**51 '*  %% &)H)H:K_K_KeKe)e egh( $.0 *   [%D%D  E!+"7"78*...TU.*[' K112Q66Uk:::AI]I]IcIc?cgh?h '') 9F U0  F Es:AD*D*:D** D8rN)r=r>r?r@rArBrCrrDrrrrr*rErrr:rGrr"rrrsJ  S   $}*=    T*-     ]]_!#;!M!Vc!!r"rcF\rSrSrSrSr\\\/r /SQr \ S\ 4Sj5r Srg) QwenImageDenoiseStepia/ Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports text2image and image2image tasks for QwenImage. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step. Outputs: latents (`Tensor`): Denoised latents. rbefore_denoiserdenoiserafter_denoiserrcg)NaeDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports text2image and image2image tasks for QwenImage.rrs rr QwenImageDenoiseStep.descriptions  R r"rN)r=r>r?r@__doc__rArrr block_classes block_namesrBrCrrGrr"rr r sB@J $"M DK   S    r"r cH\rSrSrSrSr\\\\ /r /SQr \ S\ 4Sj5rSrg) QwenImageInpaintDenoiseStepi-a Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks for QwenImage. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step. mask (`Tensor`): The mask to use for the inpainting process. Can be generated in inpaint prepare latents step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. initial_noise (`Tensor`): The initial noise to use for the inpainting process. Can be generated in inpaint prepare latents step. Outputs: latents (`Tensor`): Denoised latents. rr r rafter_denoiser_inpaintrcg)Na~Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks for QwenImage.rrs rr'QwenImageInpaintDenoiseStep.description^s  B r"rN)r=r>r?r@rrArrrrrrrBrCrrGrr"rrr-sC%NJ#") M ^K   S    r"rcH\rSrSrSrSr\\\\ /r /SQr \ S\ 4Sj5rSrg) QwenImageControlNetDenoiseStepinaD Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopBeforeDenoiserControlNet` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports text2img/img2img tasks with controlnet for QwenImage. Components: guider (`ClassifierFreeGuidance`) controlnet (`QwenImageControlNetModel`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. control_image_latents (`Tensor`): The control image to use for the denoising process. Can be generated in prepare_controlnet_inputs step. controlnet_conditioning_scale (`float`, *optional*, defaults to 1.0): Scale for ControlNet conditioning. (updated in prepare_controlnet_inputs step.) controlnet_keep (`list`): The controlnet keep values. Can be generated in prepare_controlnet_inputs step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step. Outputs: latents (`Tensor`): Denoised latents. r)r before_denoiser_controlnetr rrcg)NaDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopBeforeDenoiserControlNet` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports text2img/img2img tasks with controlnet for QwenImage.rrs rr*QwenImageControlNetDenoiseStep.descriptions  X r"rN)r=r>r?r@rrArrXrrrrrBrCrrGrr"rrrnsC%NJ#-" M bK   S    r"rcJ\rSrSrSrSr\\\\ \ /r /SQr \ S\4Sj5rSrg) %QwenImageInpaintControlNetDenoiseStepia Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopBeforeDenoiserControlNet` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks with controlnet for QwenImage. Components: guider (`ClassifierFreeGuidance`) controlnet (`QwenImageControlNetModel`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. control_image_latents (`Tensor`): The control image to use for the denoising process. Can be generated in prepare_controlnet_inputs step. controlnet_conditioning_scale (`float`, *optional*, defaults to 1.0): Scale for ControlNet conditioning. (updated in prepare_controlnet_inputs step.) controlnet_keep (`list`): The controlnet keep values. Can be generated in prepare_controlnet_inputs step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step. mask (`Tensor`): The mask to use for the inpainting process. Can be generated in inpaint prepare latents step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. initial_noise (`Tensor`): The initial noise to use for the inpainting process. Can be generated in inpaint prepare latents step. Outputs: latents (`Tensor`): Denoised latents. r)r rr rrrcg)NaDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopBeforeDenoiserControlNet` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks with controlnet for QwenImage.rrs rr1QwenImageInpaintControlNetDenoiseStep.descriptions  R r"rN)r=r>r?r@rrArrXrrrrrrBrCrrGrr"rr r sG,\J#-") MK  S    r"r cF\rSrSrSrSr\\\/r /SQr \ S\ 4Sj5r Srg) QwenImageEditDenoiseStepia Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports QwenImage Edit. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. Can be generated in prepare_additional_inputs step. Outputs: latents (`Tensor`): Denoised latents. rKr rcg)NaODenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports QwenImage Edit.rrs rr$QwenImageEditDenoiseStep.description*s  2 r"rNr=r>r?r@rrArIrrrrrBrCrrGrr"rr$r$s@ D"J'!"M DK   S    r"r$cH\rSrSrSrSr\\\\ /r /SQr \ S\ 4Sj5rSrg) QwenImageEditInpaintDenoiseStepi9a Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks for QwenImage Edit. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. Can be generated in prepare_additional_inputs step. mask (`Tensor`): The mask to use for the inpainting process. Can be generated in inpaint prepare latents step. initial_noise (`Tensor`): The initial noise to use for the inpainting process. Can be generated in inpaint prepare latents step. Outputs: latents (`Tensor`): Denoised latents. rKrrcg)NaDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks for QwenImage Edit.rrs rr+QwenImageEditInpaintDenoiseStep.descriptionjs  G r"rN)r=r>r?r@rrArIrrrrrrBrCrrGrr"rr)r)9sC%N"J'!") M ^K   S    r"r)cF\rSrSrSrSr\\\/r /SQr \ S\ 4Sj5r Srg) QwenImageLayeredDenoiseStepiza Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports QwenImage Layered. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. Can be generated in prepare_additional_inputs step. Outputs: latents (`Tensor`): Denoised latents. zqwenimage-layeredr rcg)NaRDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports QwenImage Layered.rrs rr'QwenImageLayeredDenoiseStep.descriptions  5 r"rNr'rr"rr-r-zs@ D%J'!"M DK   S    r"r-))rr*configuration_utilsrguidersrmodelsrr schedulersrutilsr modular_pipeliner r r rmodular_pipeline_utilsrrrr get_loggerr=loggerrrIrXrrrrrr rrr r$r)r-rr"rr9s --K9mmKK6   H %'"7'<'&;'@D',AD'PR'1R'jU' 5U'r&'!6&'R0'(=0'l0!">0!x4 64 r< "=< B< %@< BK ,GK `5 :5 t< &A< B5 "=5 r"