biDddlZddlZddlZddlZddlZddlmZddlmZddl m Z m Z ddl m Z mZmZmZmZmZddlZddlmZddlmZddlmZdd lmZd d lmZmZd d lm Z m!Z!d d l"m#Z#m$Z$m%Z%d dl&m'Z'm(Z(d dl)m*Z*m+Z+ddl,m-Z-ddl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6e$rddl7Z7e%jpe9Z:egdZ;egdZGddee#Z?Gdde?Z@Gdde?ZAGdd e?ZBGd!d"ee#ZCy)#N) OrderedDict)deepcopy) dataclassfield)AnyDictListOptionalTupleUnion) create_repo)validate_hf_hub_args)tqdm)Self) ConfigMixin FrozenDict)_fetch_class_library_tuplesimple_get_class_obj)PushToHubMixinis_accelerate_availablelogging)get_class_from_dynamic_moduleresolve_trust_remote_code)load_or_create_model_cardpopulate_model_card)ComponentsManager) ComponentSpec ConfigSpec InputParamInsertableDict OutputParamformat_componentsformat_configsmake_doc_string))zstable-diffusion-xl StableDiffusionXLModularPipeline)wanWanModularPipeline)fluxFluxModularPipeline))r'StableDiffusionXLAutoBlocks)r) WanAutoBlocks)r+FluxAutoBlocksc eZdZUdZeeZeee fe d<eeZ eee efe d<ddede defd Z dd eee efd e d ee eee fffd Zded eee ffdZd eee ffdZdZy) PipelineStatezl [`PipelineState`] stores the state of a pipeline. It is used to pass data between pipeline blocks. )default_factoryvalueskwargs_mappingNkeyvalue kwargs_typec||j|<|>||jvr|g|j|<y|j|j|yy)z Add a value to the pipeline state. Args: key (str): The key for the value value (Any): The value to store kwargs_type (str): The kwargs_type with which the value is associated N)r2r3append)selfr4r5r6s g/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/diffusers/modular_pipelines/modular_pipeline.pysetzPipelineState.setPsV! C  "$"5"55475##K0##K077< #keysdefaultreturnct|tr|jj||S|Dcic]}||jj||!c}Scc}w)aa Get one or multiple values from the pipeline state. Args: keys (Union[str, List[str]]): Key or list of keys for the values default (Any): The default value to return if not found Returns: Union[Any, Dict[str, Any]]: Single value if keys is str, dictionary of values if keys is list ) isinstancestrr2get)r9r=r>r4s r:rCzPipelineState.getasK dC ;;??41 1>BCsT[[__S'22CCCs$Ac\|jj|g}|j|S)z Get all values with matching kwargs_type. Args: kwargs_type (str): The kwargs_type to filter by Returns: Dict[str, Any]: Dictionary of values with matching kwargs_type )r3rC)r9r6 value_namess r: get_by_kwargszPipelineState.get_by_kwargsps+))--k2> xx $$r<ci|jS)z8 Convert PipelineState to a dictionary. )__dict__r9s r:to_dictzPipelineState.to_dict}s!$--  r<cddjfd|jjD}djd|jjD}d|d|dS)Nc@t|dr)t|drd|jd|jdSt|trOt |dkDrAt|ddr2t|ddr#d|djd|djdSt |S) Nshapedtype Tensor(dtype=, shape=)rz[Tensor(dtype=z), ...])hasattrrNrMrAlistlenrepr)vs r: format_valuez,PipelineState.__repr__..format_valuesq'"wq'':&qwwixyBBAt$Q!!g8NSZ[\]^[_ahSi'! |8AaDJJz)PipelineState.__repr__..s']AaS<?*;<]c32K|]\}}d|d|ywrZr[)r]r^rVs r:r_z)PipelineState.__repr__..s &_41aaS1#&_zPipelineState( values={ z }, kwargs_mapping={ z } ))joinr2itemsr3)r9 values_strkwargs_mapping_strrWs @r:__repr__zPipelineState.__repr__sh YY]IZIZI\]] !YY&_4CVCVC\C\C^&__.zl:XYkXlluvvr<N)__name__ __module__ __qualname____doc__rdictr2rrBr__annotations__r3r r;r rCrFrJrgr[r<r:r0r0Gs#48FDcN8+0+FNDd3i(F=s=3=S=" Dc49n- D DuSRVWZ\_W_R`M`Ga D % %c3h %!c3h! wr<r0c>eZdZdZdZdefdZdedefdZdZ dZ y ) BlockStatez\ Container for block state data with attribute access and formatted representation. c N|jD]\}}t|||yrh)rdsetattr)r9kwargsr4r5s r:__init__zBlockState.__init__s' ,,. &JC D#u % &r<r4ct||dSrh)getattr)r9r4s r: __getitem__zBlockState.__getitem__stS$''r<r5ct|||yrh)rr)r9r4r5s r: __setitem__zBlockState.__setitem__sc5!r<cHt|jjS)z Convert BlockState to a dictionary. Returns: Dict[str, Any]: Dictionary containing all attributes of the BlockState )rmrHrdrIs r:as_dictzBlockState.as_dictsDMM'')**r<czddjfd|jjD}d|dS)Nct|dr)t|drd|jd|jdSt|trat |dkDrHt|ddr9t|ddr*|Dcgc]}|j}}dt |d|St |St|trat |dkDrHt|ddr9t|ddr*|Dcgc]}|j}}d t |d|St |St|tri}|jD]\}}t|dr-t|dr!d |jd |jd||<?t|trZt |dkDrLt|ddr=t|ddr.|Dcgc]}|j}}dt |d|||<t |||<|St |Scc}wcc}wcc}w) NrMrNrOrPrQrzList[z] of Tensors with shapes zTuple[z Tensor(shape=z, dtype=) rRrNrMrArSrTrUtuplermrd)rVtshapesformatted_dictr^vals r:rWz)BlockState.__repr__..format_valuesq'"wq'':&qwwixyBBAt$q6A:'!A$"8WQqT7=S/01!agg1F1"3q6(*CF8LLAwAu%q6A:'!A$"8WQqT7=S/01!agg1F1#CF8+DVHMMAwAt$!#ggi 6FAssG,g1F.;CII;hsyykYZ,[q)"3-HqL#CFG4#CFG436!7a!''!7!7.3CH:=VW]V^,_q),0Iq) 6&%7N=22 "8s6H'H9H rXc3@K|]\}}d|d|ywrZr[r\s r:r_z&BlockState.__repr__..s'_AaS<?*;<_r`z BlockState( z ))rcrHrd)r9 attributesrWs @r:rgzBlockState.__repr__s;& PYY_I\I\I^__ zl#..r<N) rirjrkrlrtrBrwrryr{rgr[r<r:rprps5&(s("s"3"+*/r<rpc deZdZdZdZdZedZdZe de fdZ e de e fdZe de efd Ze de efd Zd Ze de efd Ze de efd ZdZe de efdZe d$de deefdZd%dZ d&deee ej>fdee dee ddfdZ!de"de#fdZ$de"de%fdZ&e'de e(e e efde efdZ)e'de e(e e efde efdZ*e de e fd Z+e de e fd!Z,e de e fd"Z-e d#Z.y)'ModularPipelineBlocksad Base class for all Pipeline Blocks: PipelineBlock, AutoPipelineBlocks, SequentialPipelineBlocks, LoopSequentialPipelineBlocks [`ModularPipelineBlocks`] provides method to load and save the defination of pipeline blocks. This is an experimental feature and is likely to change in the future. zmodular_config.jsonNctj|jj}|j Dcic]&\}}|j tj k(s$||(}}}t|j Dchc]%\}}|j tj k7s$|'c}}}t|jdhz }||fScc}}wcc}}w)Nr9) inspect signaturert parametersrdr>_emptyr;r=)clsobjrr^rVrequired_parametersoptional_parametersexpected_moduless r:_get_signature_keysz)ModularPipelineBlocks._get_signature_keyss&&s||4?? 0:0@0@0Bb1aiiSZSaSaFaq!tbb!1A1A1C"cAqyyT[TbTbGb1"cd2779:fXE!444 c"cs%C#C%C )C c"t|_yrh)r" sub_blocksrIs r:rtzModularPipelineBlocks.__init__s (*r<r?cy)?$.U3<<6*CU3U5 >**:((a(,44]BG,,55BBHHaPQRS $o6(!H:(>? 2ZKZSYZdkk"(0r<components_manager collectionModularPipelinectj|jtj}t j d}t||}|t||||}|S)z\ create a ModularPipeline, optionally accept modular_repo to load from hub. diffusersblocksrrr) MODULAR_PIPELINE_MAPPINGrC model_namerri importlib import_modulervr)r9rrrpipeline_class_namediffusers_modulepipeline_classmodular_pipelines r: init_pipelinez#ModularPipelineBlocks.init_pipeline]sc7::4??OLdLde$22;? !13FG)D>*G1!    r<stateci}|j}|D]}|jrf|j|j}|jr|t d|jd||V|j|vse|||j<u|j s|j |vri||j <|j |j }|s|jD]\}}| |||<|||j |<!tdi|S)z2Get all inputs and intermediates in one dictionaryzRequired input 'z ' is missingr[) rrrCrrr6rFrdrp) r9rdata state_inputsrr5 inputs_kwargsr^rVs r:get_block_statez%ModularPipelineBlocks.get_block_staters"{{ ( AK +"2"23''EM$'7 8H8H7I%VWW&5=[=M=MUY=Y-2D))*((**$646D001 % 3 3K4K4K L  - 3 3 5A1=&'DG?@D!8!89!<A A&!D!!r< block_statec |jD]n}t||jstd|jdt ||j}|j |j||j p|jD]}|jrtt||jr^t ||j}|j|j}||us\|j |j||j |j s|j|j }|jD]C\}}| t||st ||}||us'|j |||j Ey)NzIntermediate output 'z' is missing in block state) rrRrrrvr;r6rrCrFrd) r9rr output_paramparamr current_valueintermediate_kwargs param_names r:set_block_statez%ModularPipelineBlocks.set_block_statesn 55 JL; (9(9: #89J9J8KKf!ghhK):):;E IIl'' 0H0H I  J  ;; NKGK9I9I$J [-=-=> % +*:*: ;  -IIk..{7N7NO((',&9&9+:Q:Q&R#1D1J1J1L N-J !) "; ; #KwarningswarnrSr2)r combined_dict value_sources block_namerr input_name current_params r:combine_inputsz$ModularPipelineBlocks.combine_inputssU  "3 ; J% ; ##+ 0G0G0S!% (?(?!?J!,!1!1J.$1*$=M%--9'//;)11[5H5HH QR\Q]]`,445^MR\D]C^^e*223>*ZXeXmXmWnnoq %,,49L9L9X4? j14> j10;M*-0:M*-- ; ;2M((*++r<named_output_listsci}|D]P\}}|D]F}|j|vs'||jj+|j8|||j<HRt|jS)ar Combines multiple lists of OutputParam objects from different blocks. For duplicate outputs, keeps the first occurrence of each output name. Args: named_output_lists: List of tuples containing (block_name, output_param_list) pairs Returns: List[OutputParam]: Combined list of unique OutputParam objects )rr6rSr2)r rrrrs r:combine_outputsz%ModularPipelineBlocks.combine_outputss #5 D J ' D  %%]:!,"3"34@@H\MeMeMq7CM,"3"34  D DM((*++r<cT|jDcgc]}|jc}Scc}wrh)rr)r9rs r:rz!ModularPipelineBlocks.input_namess 48KK@[   @@@%cT|jDcgc]}|jc}Scc}wrh)rrr9rs r:intermediate_output_namesz/ModularPipelineBlocks.intermediate_output_namess"6:6O6OPl !!PPPrcT|jDcgc]}|jc}Scc}wrh)rrrs r: output_namesz"ModularPipelineBlocks.output_namess 6:llCl !!CCCrct|j|j|j|jj |j |jSN)rrrr&rrrrrirrrIs r:doczModularPipelineBlocks.docE KK LL   ~~.. $ 8 8!22   r<rhFNNN)/rirjrkrl config_namer classmethodrrtpropertyrBrr rrr rr!rrrr#rrrr boolrrr osPathLikerrr0rmrrpr staticmethodr r r rrrrr[r<r:rrs (KJ55+ST-%8$z"2Z(+j!1++d;&7)#k*##-1+)'*+)$D>+)+)Z 1 LP:>$(  '/c2;;6F0G'H %%67 SM    *"]"t"6N]NN<(,4c4 ;K6K0L+M(,RVWaRb(,(,T,T%T+=N8N2O-P,UYZeUf,,,AT#YAAQ49QQDd3iDD  r<rc@eZdZdZgZgZgZdZedZ edZ edZ edZ ede efdZede eeeffd Zede efd Zede efd Zej,d edefd ZdZedZdZedZy)AutoPipelineBlocksa A Pipeline Blocks that automatically selects a block to run based on the inputs. This class inherits from [`ModularPipelineBlocks`]. Check the superclass documentation for the generic methods the library implements for all the pipeline blocks (such as loading or saving etc.) This is an experimental feature and is likely to change in the future. Attributes: block_classes: List of block classes to be used block_names: List of prefixes for each block block_trigger_inputs: List of input names that trigger specific blocks, with None for default ct}t|j|jD]\}}|||<||_t |jt |jcxk(rt |j k(s%ntd|jjd|j Dcgc]}|| }}t |dkDst |dk(r2|j d#td|jjdtt|j |jj|_ tt|j |jj|_tt|jj|j |_ycc}w)NzIn zV, the number of block_classes, block_names, and block_trigger_inputs must be the same.rrzQ, exactly one None must be specified as the last element in block_trigger_inputs.)r"zip block_names block_classesrrTblock_trigger_inputsrrrirmr2trigger_to_block_mapr=trigger_to_block_name_mapblock_to_trigger_map)r9rrrrdefault_blockss r:rtzAutoPipelineBlocks.__init__s#% %()9)94;M;M%N 1 !J %.[Jz " 1$D&&'3t/?/?+@bCHaHaDbbdnn--./EF &*%>%>L!)!LL ~  "s>':a'?DD]D]^`DaDmdnn--./++  %)T-F-FH^H^H`)a$b!)-c$2K2KT__MaMaMc.d)e&$(T__-A-A-CTE^E^)_$`!Ms ;G G cntt|jjjSrh)nextiterrr2rrIs r:rzAutoPipelineBlocks.model_name5s%D//123>>>r<cyNrr[rIs r:rzAutoPipelineBlocks.description9r<cg}|jjD])}|jD]}||vs|j|+|Srhrr2rr8r9rblock components r:rz&AutoPipelineBlocks.expected_components=X __++- :E"66 : $77'..y9 : :#"r<cg}|jjD])}|jD]}||vs|j|+|Srhrr2rr8r9rr6rs r:rz#AutoPipelineBlocks.expected_configsFX__++- 4E00 4!11$++F3 4 4 r<r?c d|jvrgStt|jj }t t |dt }t|jj ddD]1}t t |dt }|j|3t|SNrr) r(r.r/rr2r;rvrSintersection_update)r9 first_blockrequired_by_allr6block_requireds r:rz"AutoPipelineBlocks.required_inputsOs t00 0I4 6 6 89: gk3DceLM$//0023AB7 @E 0A35!IJN  / / ? @O$$r<c|jjDcgc]\}}||jf}}}|j|}|D])}|j|j vrd|_#d|_+|Scc}}w)NTF)rrdrr rrr)r9rr6 named_inputscombined_inputsrs r:rzAutoPipelineBlocks.inputs^s@D@U@U@WXuu||,X X-$--|<* -K4#7#77'+ $', $  - YsA8c|jjDcgc]\}}||jf}}}|j|}|Scc}}wrh)rrdrr r9rr6 named_outputscombined_outputss r:rz'AutoPipelineBlocks.intermediate_outputsjsPOSOdOdOfg e$ : :;g g/4//?hA c|jjDcgc]\}}||jf}}}|j|}|Scc}}wrh)rrdrr rGs r:rzAutoPipelineBlocks.outputspsNBF//BWBWBYZ;4$ .Z Z/4//?[rJrc<|jjd}|jD]'}||j||j|}n|0tj d|j j ||fS tjd|j j d|||S#t$rU}d|j j dt|dtj}tj|d}~wwxYw)Nzskipping auto block: zRunning block: z , trigger: z Error in block: z Error details: Traceback: ) r)rCr(loggerwarningrriinfo ExceptionrB traceback format_excerror)r9pipelinerr6re error_msgs r:__call__zAutoPipelineBlocks.__call__vs))--d333 J%%))J*?*K11*=  = NN24>>3J3J2KL MU? "  KK/%//*B*B)C;zl[ \5) ) $U__%=%=$>?""%a&*(33568  LL #  s7B== DADDc~fdt|j}|j|j|S) Returns a set of all unique trigger input values found in the blocks. Returns: Set[str] containing all unique block_trigger_inputs values c$t}||jD]o\}}t|dr.|j"|j d|jD|j sM|j }|j |q|S)Nr(c3&K|] }|| ywrhr[r]rs r:r_z[AutoPipelineBlocks._get_trigger_inputs..fn_recursive_get_trigger..-eAWXWda-er;rdrRr(updaterrtrigger_valuesrr6nested_triggersfn_recursive_get_triggers r:rezHAutoPipelineBlocks._get_trigger_inputs..fn_recursive_get_trigger UN!#)<<> ?KD%u&<=%B\B\Bh&---e9S9S-ee''*B5CSCS*T&--o> ?" !r<)r;r(rar)r9trigger_inputsres @r:_get_trigger_inputsz&AutoPipelineBlocks._get_trigger_inputss8  ""T6676tGHr<c"|jSrhrhrIs r:rgz!AutoPipelineBlocks.trigger_inputs''))r<c p|jj}|jjdj}|r |dk7r|d|dn|d}|jr8|dz }|dz }|dz }|d|jDcgc]}|| c}dz }|d z }|jj d}g}|j d |dt|d kDr|jd |d dDdj|dz}t|d g}t|dd}t|dg} t| dd} d} t|jjD]\} \} }d}t!|dr}|j"j%| }|d}n9t'|t(t*frddjd|Dd}nd|d}| d| d|d|jjdz } n#| d| d| d|jjdz } |jj d}|d}t|d kDr!|ddjd|d dDzz }| d |d!z } |d|}|j-r|d!|z }| j-r|d!| z }|d!| d"z }|Scc}w)#Nrobject ( Class: rX( g ==================================================================================================== N This pipeline contains blocks that are selected at runtime based on inputs.  Trigger Inputs: h ====================================================================================================  Description: rc3&K|] }d| ywz Nr[r]lines r:r_z.AutoPipelineBlocks.__repr__..CD&CrrF indent_leveladd_empty_linesr Sub-Blocks: r+ [default] [trigger: , c32K|]}t|ywrhrBr]s r:r_z.AutoPipelineBlocks.__repr__..8QAQ8Qrb] •   ()  [] c3&K|] }d|z ywz Nr[rws r:r_z.AutoPipelineBlocks.__repr__..1jSW2G$2N1jrz Description:  rQ)rri __bases__rgrrr8rTextendrcrvr$r% enumeraterrdrRr+rCrArSr~strip)r9r base_classheaderinp desc_linesdescrcomponents_strr configs_str blocks_strirr6trigger trigger_str indented_descresults r:rgzAutoPipelineBlocks.__repr__s6^^,, ^^--a099 9C V^H^zl,zl" 5gqfrrudv     dNF - -F g gF *4;N;N+bCRURaC+b*ccef fF / /F%%++D1  ojm_56 z?Q  KKCJqrNC Cyy%&d,A2F*+>Q`ef#4);R@$%5AW\] ' )$//*?*?*A B E A}eGt343377=?"-K$7$.tyy8Q8Q/Q.RRS"TK$.wiq"9Ka }Bu?W?W>XX[\\ aS4&5??3K3K2LCPP **006J&qMM:" 1j[efgfh[i1j(j!jj 0tD DJ/ E482dV$    ! ^,- -F     [M* *F D A&& },cs 9J3J3ct|j|j|j|jj |j |jSrrrIs r:rzAutoPipelineBlocks.docrr<N)rirjrkrlr'r&r(rtrrrrrr rBrr rrrrtorchno_gradr0rXrhrgrgrr[r<r:r#r#sR$MKa2??##   %c % % U38_-   d3i   c  U]]_ -28**IV  r<r#creZdZdZgZgZedZedZedZ edZ e de e efddfdZd Zd Zedeee effd Zedee fd Zedee fd Zedee fdZej2dedefdZdZedZdZdZdZ edZ!y)SequentialPipelineBlocksaI A Pipeline Blocks that combines multiple pipeline block classes into one. When called, it will call each block in sequence. This class inherits from [`ModularPipelineBlocks`]. Check the superclass documentation for the generic methods the library implements for all the pipeline blocks (such as loading or saving etc.) This is an experimental feature and is likely to change in the future. Attributes: block_classes: List of block classes to be used block_names: List of prefixes for each block cyr1r[rIs r:rz$SequentialPipelineBlocks.descriptionr2r<cXtd|jjDdS)Nc3NK|]}|j|jywrh)r)r]r6s r:r_z6SequentialPipelineBlocks.model_name..#s!l%uO_O_OkU%%ls%%)r.rr2rIs r:rz#SequentialPipelineBlocks.model_name!s#l4??3I3I3Klnrssr<cg}|jjD])}|jD]}||vs|j|+|Srhr4r5s r:rz,SequentialPipelineBlocks.expected_components%r8r<cg}|jjD])}|jD]}||vs|j|+|Srhr:r;s r:rz)SequentialPipelineBlocks.expected_configs.r<r< blocks_dictr?cP|}t}|jD]*\}}tj|r |||<&|||<,|j Dcgc]}|j c}|_t|j|_ ||_ |Scc}w)zCreates a SequentialPipelineBlocks instance from a dictionary of blocks. Args: blocks_dict: Dictionary mapping block names to block classes or instances Returns: A new SequentialPipelineBlocks instance r"rdrisclassr2rr'rSr=r&rrrinstancerrr6s r:from_blocks_dictz)SequentialPipelineBlocks.from_blocks_dict7s5$% &,,. )KD%u%#(7 4 #( 4  ) @J?P?P?R!Se%//!S#JOO$56("T!B#ct}t|j|jD]\}}|||<||_yrhr"r%r&r'rr9rrrs r:rtz!SequentialPipelineBlocks.__init__PD#% %()9)94;M;M%N 1 !J %.[Jz " 1$r<cg}t}|jjD]}|jD]I}|j|vs|j|Dchc]}|jc}vs9|j |Kd}t |drd|jvrd}|s||jDcgc]}|j}}|j||Scc}wcc}wNTr(F) r;rr2rrr8rRr(rra) r9rrr6rinputshould_add_outputsoutblock_intermediate_outputss r: _get_inputsz$SequentialPipelineBlocks._get_inputsVs%__++- ;E|| '887*sxxX^?_u ?_/_MM#& ' "& u45$eF`F`:`%*"!BGB\B\-]3chh-]*-]9: ;  @`.^s C 1C c"|jSrhrrIs r:rzSequentialPipelineBlocks.inputsns!!r<c `tt|jj}t t |dt }t |jjddD]1}t t |dt }|j|3t |Sr>)r.r/rr2r;rvrSra)r9r@required_by_anyr6rBs r:rz(SequentialPipelineBlocks.required_inputsrs4 6 6 89: gk3DceLM$//0023AB7 3E 0A35!IJN  " "> 2 3O$$r<cg}|jjD]J\}}|jDchc]}|j}}||vs.|j ||j fL|j |}|Scc}wrh)rrdrrr8rr )r9rHrr6r inp_namesrIs r:rz-SequentialPipelineBlocks.intermediate_outputss ??002 IKD%-2\\:c:I:9$$$dE,F,F%GH  I 04//? ;sA;c|jSrhrrIs r:rz SequentialPipelineBlocks.outputss(((r<rc 0|jjD]\}} |||\}}||fS#t$rX}d|d|jjdt |dt j}tj|d}~wwxYwNz Error in block: (rz) Error details: rM rrdrQrrirBrRrSrNrT)r9rUrrr6rVrWs r:rXz!SequentialPipelineBlocks.__call__s!%!6!6!8  J "'%"8%  )*R8P8P7QR&&)!fX.##,#7#7#9":<  Y' s 4 BABBc2fd|jS)rZc$t}||jD]o\}}t|dr.|j"|j d|jD|j sM|j }|j |q|S)Nr(c3&K|] }|| ywrhr[r]s r:r_zaSequentialPipelineBlocks._get_trigger_inputs..fn_recursive_get_trigger..r^r_r`rbs r:rezNSequentialPipelineBlocks._get_trigger_inputs..fn_recursive_get_triggerrfr<)r)r9res @r:rhz,SequentialPipelineBlocks._get_trigger_inputss  ""(88r<c"|jSrhrjrIs r:rgz'SequentialPipelineBlocks.trigger_inputsrkr<ct|}fdt}|jjD] \}}|||}|j |"|S)Nct}t|ds|jrq|jjD]R\}} |||} |||}|jDcic] \}}|d||}}}|j |T|S|||<t|dr"|j d|j D|Sd} |j D]} | | |vs |j| } n| d|j vr|jd} | Z| jr|j  | |||S| ||<t| dr"|j d| j D|Scc}}w)Nr(rrc34K|]}|jywrhrr]rs r:r_zcSequentialPipelineBlocks._traverse_trigger_blocks..fn_recursive_traverse..s.QCsxx.Qc34K|]}|jywrhrrs r:r_zcSequentialPipelineBlocks._traverse_trigger_blocks..fn_recursive_traverse..s2Z3882Zr)rrRrrdrarr(r)) r6ractive_triggers result_blockssub_block_name sub_blockblocks_to_updater^rV this_block trigger_inputfn_recursive_traverses r:rzPSequentialPipelineBlocks._traverse_trigger_blocks..fn_recursive_traverses'MM5"89##5:5E5E5K5K5M?1 +@N\k+l(+@N\k+l(O_OeOeOg+htq!zl!A3,?,B+h(+h%,,-=> ?%$ 16M*-ui0'...Q5==.QQ$$ " %*%?%?M$0]o5U%*%?%? %N  %$%2L2L*L!&!;!;D!AJ)!,,%,,-B:z[j-kl! 5? j1#:y9+222ZzGYGY2ZZ G,is+E2)r;rrrdra)r9rgr all_blocksrr6rrs @r:_traverse_trigger_blocksz1SequentialPipelineBlocks._traverse_trigger_blocksscn-- !^!] !%!6!6!8 0 J4UJX    . / 0r<c^|j}|`t|tttfs|g}|Dcgc] }||vs| }}|r,t j d||Dcgc] }||vs| }}|d|vrdg}n|dg}|j|}tj|Scc}wcc}w)NzHThe following trigger inputs will be ignored as they are not supported: r) rgrArSr~r;rNrOrrr)r9rgtrigger_inputs_allxinvalid_inputsblocks_triggereds r:get_execution_blocksz-SequentialPipelineBlocks.get_execution_blockss!00  %ntUC.@A"0!1)7WA1DV;VaWNW^_m^no..s Qq1= Qr_zd Use `get_execution_blocks()` with input names to see selected blocks (e.g. `get_execution_blocks('z')`). rsrtrc3&K|] }d| ywrvr[rws r:r_z4SequentialPipelineBlocks.__repr__..#ryrzrrFr{rr~r+rrrc32K|]}t|ywrhrr]s r:r_z4SequentialPipelineBlocks.__repr__..9rrbrrrrrrrc3&K|] }d|z ywrr[rws r:r_z4SequentialPipelineBlocks.__repr__..FrrzrrrQ)rrirrgr.rrr8rTrrcrvr$r%rrrdrRr+rCrArSr~r)r9rrrr example_inputrrrrrrrrrr6rrrrs r:rgz!SequentialPipelineBlocks.__repr__ su^^,, ^^--a099 9C V^H^zl,zl" 5gqfrrudv     dNF - -F g gF *4;N;N+bCRURaC+b*ccef fF QD,?,? QQM |~K}LLST TF / /F%%++D1  ojm_56 z?Q  KKCJqrNC Cyy%&d,A2F*+>Q`ef#4);R@$%5AW\] ' )$//*?*?*A B E A}eGt343377=?"-K$7$.tyy8Q8Q/Q.RRS"TK$.wiq"9Ka }Bu?W?W>XX[\\ aS4&5??3K3K2LCPP **006J&qMM:" 1j[efgfh[i1j(j!jj 0tD DJ/ E482dV$    ! ^,- -F     [M* *F D A&& C,cs 9KKct|j|j|j|jj |j |jSrrrIs r:rzSequentialPipelineBlocks.docYrr<N)"rirjrkrlr'r&rrrrrrrrBrrrtrr r rrrrrrr0rXrhrgrrrgrr[r<r:rrs$MK tt##  4S>>X0% 0"U38_-"" %c % %  d3i    )c))U]]_  -  92**7rK*L\  r<rceZdZdZdZgZgZedefdZ ede e fdZ ede e fdZede efdZede efdZede efd Zed Zed Zd Zed Zede efdZede efdZede efdZdZedeeefddfdZde fdZ!de de fdZ"edZ#dZ$e%jLjNddZ(dZ)y)LoopSequentialPipelineBlocksaP A Pipeline blocks that combines multiple pipeline block classes into a For Loop. When called, it will call each block in sequence. This class inherits from [`ModularPipelineBlocks`]. Check the superclass documentation for the generic methods the library implements for all the pipeline blocks (such as loading or saving etc.) This is an experimental feature and is likely to change in the future. Attributes: block_classes: List of block classes to be used block_names: List of prefixes for each block Nr?ctd)rz4description method must be implemented in subclassesNotImplementedErrorrIs r:rz(LoopSequentialPipelineBlocks.description|s""XYYr<cgSrhr[rIs r:loop_expected_componentsz5LoopSequentialPipelineBlocks.loop_expected_componentsrr<cgSrhr[rIs r:loop_expected_configsz2LoopSequentialPipelineBlocks.loop_expected_configsrr<cgSrr[rIs r: loop_inputsz(LoopSequentialPipelineBlocks.loop_inputsrr<c|g}|jD]*}|js|j|j,|Srh)rrr8rrs r:loop_required_inputsz1LoopSequentialPipelineBlocks.loop_required_inputssA ++ 5K##"";#3#34 5r<cgSrr[rIs r:loop_intermediate_outputsz6LoopSequentialPipelineBlocks.loop_intermediate_outputsrr<cg}|jjD])}|jD]}||vs|j|+|jD]}||vs|j||Srh)rr2rr8rr5s r:rz0LoopSequentialPipelineBlocks.expected_componentss __++- :E"66 : $77'..y9 : :66 6I 33#**95 6#"r<cg}|jjD])}|jD]}||vs|j|+|jD]}||vs|j||Srh)rr2rr8rr;s r:rz-LoopSequentialPipelineBlocks.expected_configss__++- 4E00 4!11$++F3 4 400 0F-- ''/ 0 r<cg}|j|jt}|jj D]\}}|j D]'}|j |vs||vs|j|)d}t|drd|jvrd}|s]|jDcgc]}|j }}|j||D])} | j |jvrd| _ #d| _ +|Scc}wr)rrr;rrdrrr8rRr(rrarr) r9rrrr6rrrrrs r:rz(LoopSequentialPipelineBlocks._get_inputss d&&'%??002 ;KD%|| '887*s&/@MM#& ' "& u45$eF`F`:`%*"!BGB\B\-]3chh-]*-]9: ; " -K4#7#77'+ $', $  -  .^s-Dc"|jSrhrrIs r:rz#LoopSequentialPipelineBlocks.inputss!!r<c tt|jj}t t |dt }t t |dt }|j |t|jjddD]1}t t |dt }|j |3t|S)Nrrr)r.r/rr2r;rvrarS)r9r@rrequired_by_loopr6rBs r:rz,LoopSequentialPipelineBlocks.required_inputss4 6 6 89: gk3DceLMwt-CSUKL/0$//0023AB7 3E 0A35!IJN  " "> 2 3O$$r<c<|jjDcgc]\}}||jf}}}|j|}|jD]:}|j |Dchc]}|j c}vs*|j <|Scc}}wcc}wrh)rrdrr rrr8)r9rr6rHrIoutputs r:rz1LoopSequentialPipelineBlocks.intermediate_outputssOSOdOdOfg e$ : :;g g/4//?44 0F{{=M"N66;;"NN ''/ 0  h#Os B&Bcntt|jjjSrh)r.reversedrr2rrIs r:rz$LoopSequentialPipelineBlocks.outputss%HT__33567LLLr<ct}t|j|jD]\}}|||<||_yrhrrs r:rtz%LoopSequentialPipelineBlocks.__init__rr<rcP|}t}|jD]*\}}tj|r |||<&|||<,|j Dcgc]}|j c}|_t|j|_ ||_ |Scc}w)a Creates a LoopSequentialPipelineBlocks instance from a dictionary of blocks. Args: blocks_dict: Dictionary mapping block names to block instances Returns: A new LoopSequentialPipelineBlocks instance rrs r:rz-LoopSequentialPipelineBlocks.from_blocks_dicts5$% &,,. )KD%u%#(7 4 #( 4  ) @K?Q?Q?S!Te%//!T#K$4$4$67)"Urrc 2|jjD]\}} |||fi|\}}||fS#t$rX}d|d|jjdt |dt j}tj|d}~wwxYwrr)r9 componentsrrsrr6rVrWs r: loop_stepz&LoopSequentialPipelineBlocks.loop_steps!%!6!6!8  J $)*e$Fv$F! E 5   )*R8P8P7QR&&)!fX.##,#7#7#9":<  Y' s 5 BABBctd)Nz9`__call__` method needs to be implemented by the subclassr)r9rrs r:rXz%LoopSequentialPipelineBlocks.__call__&s!"]^^r<ct|j|j|j|jj |j |jSrrrIs r:rz LoopSequentialPipelineBlocks.doc)rr<c |jj}|jjdj}|r |dk7r|d|dn|d}|jj d}g}|j d|dt |dkDr|jd|ddDdj|dz}t|d g}t|d d }t|d g}t|d d } d} t|jjD]\} \} } | d| d| d| jjdz } | jj d}|d}t |dkDr!|ddjd|ddDzz }| d|dz } |d|}|jr|d|z }| jr|d| z }|d| dz }|S)NrrmrnrXrortrc3&K|] }d| ywrvr[rws r:r_z8LoopSequentialPipelineBlocks.__repr__..EryrzrrFr{rr~rrrrc3&K|] }d|z ywrr[rws r:r_z8LoopSequentialPipelineBlocks.__repr__..ZrrzrrrQ)rrirrrr8rTrrcrvr$r%rrrdr)r9rrrrrrrrrrrrr6rrs r:rgz%LoopSequentialPipelineBlocks.__repr__7s5^^,, ^^--a099 9C V^H^zl,zl" 5gqfrrudv  %%++D1  ojm_56 z?Q  KKCJqrNC Cyy%&d,A2F*+>Q`ef#4);R@$%5AW\] ' )$//*?*?*A B E A}e E!BtfBu/G/G.HL LJ**006J&qMM:" 1j[efgfh[i1j(j!jj 0tD DJ E82dV$    ! ^,- -F     [M* *F D A&& r<ct|dsi|_nD$=$=> >  AeAt'@'@A ANO Or<c ||_yrh)r)r9rss r:set_progress_bar_configz4LoopSequentialPipelineBlocks.set_progress_bar_config}s $*!r<NN)*rirjrkrlrr'r&rrBrr rrr rr!rrr#rrrrrrrrrtrrrrr0rrXrrgrcompilerdisablerrr[r<r:rres$JMK ZSZZ$}*=tJ'7T*-d3i4 +<  # #    :"" %c % %" d3i  McMM% 4S>>\2 != !_-_M_  4l ^^ P P+r<rc (eZdZdZdZdZ d,deedeee e jfdee dee fdZ ed ee effd Zd Zee d-deee e jfd eedee dee fd Zd.dee e jfdefdZedZdZed ej6fdZedZed ej:fdZed ee fdZed ee fdZ ed ee fdZ!ed ee fdZ"ed ee effdZ#de d e$fdZ%dZ&deee e ffdZ' d/d ed!eejPjRd efd"Z*d e+fd#Z,e-d$e$d efd%Z.e-de d&ee efd e$fd'Z/d(Z0d0d)e1d*ee ee ffd+Z2y)1rz Base class for all Modular pipelines. This is an experimental feature and is likely to change in the future. Args: blocks: ModularPipelineBlocks, the blocks to be used in the pipeline zmodular_model_index.jsonNrrrrc h|tj|jj}|)t j d}t ||}|}n,tjd|jj||_ ||_ ||_ |jjD cic]} | jt| c} |_|jj D cic]} | jt| c} |_||j$|fi|} | j'D]\} } | |jvrSt)| t*t,fr=t/| dk(r/| \} }}|j1| |}d|_||j| <g| |j"vsv| |j"| _i}|jj'D],\} }|j2dk(r|j7}nd}||| <.|j8di|i}|j"j'D]\} }|j4|| <|j:di||j;|j&|jjjydycc} wcc} w) a Initialize a ModularPipeline instance. This method sets up the pipeline by: - creating default pipeline blocks if not provided - gather component and config specifications based on the pipeline blocks's requirement (e.g. expected_components, expected_configs) - update the loading specs of from_pretrained components based on the modular_model_index.json file from huggingface hub if `pretrained_model_name_or_path` is provided - create defaultfrom_config components and register everything Args: blocks: `ModularPipelineBlocks` instance. If None, will attempt to load default blocks based on the pipeline class name. pretrained_model_name_or_path: Path to a pretrained pipeline configuration. If provided, will load component specs (only for from_pretrained components) and config values from the saved modular_model_index.json file. components_manager: Optional ComponentsManager for managing multiple component cross different pipelines and apply offloading strategies. collection: Optional collection name for organizing components in the ComponentsManager. **kwargs: Additional arguments passed to `load_config()` when loading pretrained configuration. Examples: ```python # Initialize with custom blocks pipeline = ModularPipeline(blocks=my_custom_blocks) # Initialize from pretrained configuration pipeline = ModularPipeline(blocks=my_blocks, pretrained_model_name_or_path="my-repo/modular-pipeline") # Initialize with components manager pipeline = ModularPipeline( blocks=my_blocks, components_manager=ComponentsManager(), collection="my_collection" ) ``` Notes: - If blocks is None, the method will try to find default blocks based on the pipeline class name - Components with default_creation_method="from_config" are created immediately, its specs are not included in config dict and will not be saved in `modular_model_index.json` - Components with default_creation_method="from_pretrained" are set to None and can be loaded later with `load_default_components()`/`load_components()` - The pipeline's config dict is populated with component specs (only for from_pretrained components) and config values, which will be saved as `modular_model_index.json` during `save_pretrained` - The pipeline's config dict is also used to store the pipeline blocks's class name, which will be saved as `_blocks_class_name` in the config dict Nrz6`blocks` is `None`, no default blocks class found for r from_config)_blocks_class_namer[)MODULAR_PIPELINE_BLOCKS_MAPPINGrCrrirrrvrNrOr_components_manager _collectionrrr_component_specsr _config_specsrrdrAr~rSrT_dict_to_component_specdefault_creation_methodr>createregister_componentsr)r9rrrrrsblocks_class_namer blocks_classspec config_dictrr5libraryrcomponent_spec_dictcomponent_specregister_components_dictr7default_configs config_specs r:rtzModularPipeline.__init__sp > ? C CDNND[D[ \  ,#,#:#:;#G &'79JK %!WX\XfXfXoXoWpqr #5 %GK{{GfGf gtHTN!: gDHKKD`D`aDdii$7a ) 4*$**+HSFSK*002 = e4000Zt}5UZ]^cZdhiZi?Dr)r9paramsrs r:default_call_parametersz'ModularPipeline.default_call_parameterss= ;;-- ;K'2':':F;## $ ; r<c |jjDcgc] }|j|jdk(r|"}}|jdd|i|ycc}w)z Load from_pretrained components using the loading specs in the config dict. Args: **kwargs: Additional arguments passed to `from_pretrained` method, e.g. torch_dtype, cache_dir, etc. rnamesNr[)r r=r#load_components)r9rsrr4s r:load_default_componentsz'ModularPipeline.load_default_componentssi--224 $$T*BBFWW   353F3  s%Arc ddlm} tj|fd|i|}|j dd}|j dd} |j dd} |j d d} |j d d} |j d d} || | | | | d } |j |fi|}||| }|d||||d|}|S#t$rd}YwxYw#t$r|}d}Y/wxYw)a Load a ModularPipeline from a huggingface hub repo. Args: pretrained_model_name_or_path (`str` or `os.PathLike`, optional): Path to a pretrained pipeline configuration. If provided, will load component specs (only for from_pretrained components) and config values from the modular_model_index.json file. trust_remote_code (`bool`, optional): Whether to trust remote code when loading the pipeline, need to be set to True if you want to create pipeline blocks based on the custom code in `pretrained_model_name_or_path` components_manager (`ComponentsManager`, optional): ComponentsManager instance for managing multiple component cross different pipelines and apply offloading strategies. collection (`str`, optional):` Collection name for organizing components in the ComponentsManager. r)_get_pipeline_classrNrrFrrrr)rrrrrr)rrr[) pipelines.pipeline_loading_utilsr8rrEnvironmentErrorrr)rrrrrrsr8rrrrrrrload_config_kwargsr)rrUs r:rzModularPipeline.from_pretraineds94 K *::-ARV\F JJ{D1 $4e<**Y- 7D)!::&8%@::j$/#, 0   1)#//*G^K]^K0[IN " *G1!    C  F ,  1 N,0 ) 1s#CC CC C#"C#rrc (|r|jdd}|jdd}|jdd}|jdd}|jd|jtjjd}t |d || j }t||d } t| } | jtjj|d |j| |r|j|yy)a Save the pipeline to a directory. It does not save components, you need to save them separately. Args: save_directory (`str` or `os.PathLike`): Path to the directory where the pipeline will be saved. push_to_hub (`bool`, optional): Whether to push the pipeline to the huggingface hub. **kwargs: Additional arguments passed to `save_config()` method commit_messageNprivate create_prFrrepo_idrT)exist_okr>r)r is_pipelinez README.md)r)rr=r?) rrrpathsepr r@rrsavercr_upload_folder) r9rrrsr=r>r?rr@ model_cards r:rzModularPipeline.save_pretrainedYs #ZZ(8$?NjjD1G ;6IJJw-EjjN,@,@,Mb,QRG!'D'QVW__G37%UYZJ,Z8J OOBGGLLE F 7    -#   r<c.|jjS)zM Returns: - The docstring of the pipeline blocks )rrrIs r:rzModularPipeline.doc}s {{r<c |jD]\}}|jj|}|tj d|d>t ||}|j dk(}|t|\}}nd\}}|j|} |||| fi} |sY|r|jdi| t||||5|r3|j'|jj|||jt||d} | |urtjd|d| 3|1tjd|d | j j"d nN| L|Jt%|| j r4| |k7r/tj'd |d t)| j"d |r|jdi| t|||||s|j|jj|||jy)a Register components with their corresponding specifications. This method is responsible for: 1. Sets component objects as attributes on the loader (e.g., self.unet = unet) 2. Updates the config dict, which will be saved as `modular_model_index.json` during `save_pretrained` (only for from_pretrained components) 3. Adds components to the component manager if one is attached (only for from_pretrained components) This method is called when: - Components are first initialized in __init__: - from_pretrained components not loaded during __init__ so they are registered as None; - non from_pretrained components are created during __init__ and registered as the object itself - Components are updated with the `update_components()` method: e.g. loader.update_components(unet=unet) or loader.update_components(guider=guider_spec) - (from_pretrained) Components are loaded with the `load_default_components()` method: e.g. loader.load_default_components(names=["unet"]) Args: **kwargs: Keyword arguments where keys are component names and values are component objects. E.g., register_components(unet=unet_model, text_encoder=encoder_model) Notes: - When registering None for a component, it sets attribute to None but still syncs specs with the config dict, which will be saved as `modular_model_index.json` during `save_pretrained` - component_specs are updated to match the new component outside of this method, e.g. in `update_components()` method NzAModularPipeline.register_components: skipping unknown component ''rrz%ModularPipeline.register_components: z1 is already registered with same object, skippingz.ModularPipeline.register_components: setting 'z' to None (was rQz9ModularPipeline.register_components: replacing existing 'z ' (same type z, new instance)r[)rdr rCrNrOrRr#r_component_spec_to_dictrrrraddrrvrPrrirAdebugr) r9rsrrr, is_registeredis_from_pretrainedr*rr+ register_dictcurrent_modules r:r%z#ModularPipeline.register_componentss>:#LLNI MLD&!2266t">~"N !GZ9L#MNM!%+D++aA *&v~'?'?@"f, OPTvV""&~"6"?"?!@Q "'''8-8 D$ '!&8T=U=U=a((,,T64;K;KLSI Mr<c|jj}|Dcgc])}t|tjj s(|+}}|D]}|j cStj dScc}w)zi Returns: `torch.device`: The torch device on which the pipeline is located. cpu)rr2rArnnModuledevicer9modulesmrs r:rVzModularPipeline.devicesj //((*%HAuxx)G1HH !F==  !||E"" Is )A8 A8c|jjD]\}}t|tjj s+t |ds|jcS|jD]i}t |dst |jds'|jj>tj|jjccS|jS)z Returns the device on which the pipeline's models will be executed. After calling [`~DiffusionPipeline.enable_sequential_cpu_offload`] the execution device can only be inferred from Accelerate's module hooks. _hf_hookexecution_device) rrdrArrTrUrRrVrXr[r\)r9rmodelrs r:_execution_devicez!ModularPipeline._execution_devices ??002 JKD%eUXX__55*-{{"--/ JFJ/1CD88D <<(H(HII  J J{{r<c|jj}|Dcgc])}t|tjj s(|+}}|D]}|j cStjScc}w)zg Returns: `torch.dtype`: The torch dtype on which the pipeline is located. )rr2rArrTrUrNfloat32rWs r:rNzModularPipeline.dtypese //((*%HAuxx)G1HH F<<  }} Is )A3 A3c|jjDcgc]}t||st||| c}Scc}w)z] Returns: - List of names for components that needs to be loaded r r=rRrvr9rs r:null_component_namesz$ModularPipeline.null_component_names s? "&!6!6!;!;!=utATY`aegkYlYtuuusA AAcHt|jjS)zI Returns: - List of names for all components )rSrr=rIs r:component_nameszModularPipeline.component_names(s DOO((*++r<c|jjDcgc] }|j|jdk(r|"c}Scc}w)zU Returns: - List of names for from_pretrained components rr r=r#rcs r:pretrained_component_namesz*ModularPipeline.pretrained_component_names0sM--224 $$T*BBFWW    %Ac|jjDcgc] }|j|jdk(r|"c}Scc}w)zQ Returns: - List of names for from_config components rrhrcs r:config_component_namesz&ModularPipeline.config_component_names<sL--224 $$T*BBmS    rjc|jjDcic]}t||s|t||c}Scc}w)z Returns: - Dictionary mapping component names to their objects (include both from_pretrained and from_config components) rbrcs r:rzModularPipeline.componentsHs?7;6K6K6P6P6RjdV]^bdhVigdD))jjjs AArc2t|j|S)zh Returns: - a copy of the ComponentSpec object for the given component name )rr rcs r:get_component_specz"ModularPipeline.get_component_specRs --d344r<c F|jDcic]-}||vst||ts||j|/}}|jDcic]-}||vst||tr||j|/}}|jDcic]}||vs||j|}}|j D]\}}|j|}|j \t||j sFtjd|d|jjd|j jtj||} | j|jk7r3tjd|d|jd| jd| |j|<t|d kDr&tjd |ji} |j D]\}} | jd k(r td | j!| |<|j|}|j bt| ||j sItjd|d| |jjd|j j| |j|<|j"d i|| i} |j D]\}} | |j|_| | |< |j&d i| ycc}wcc}wcc}w)ae Update components and configuration values and specs after the pipeline has been instantiated. This method allows you to: 1. Replace existing components with new ones (e.g., updating `self.unet` or `self.text_encoder`) 2. Update configuration values (e.g., changing `self.requires_safety_checker` flag) In addition to updating the components and configuration values as pipeline attributes, the method also updates: - the corresponding specs in `_component_specs` and `_config_specs` - the `config` dict, which will be saved as `modular_model_index.json` during `save_pretrained` Args: **kwargs: Component objects, ComponentSpec objects, or configuration values to update: - Component objects: Only supports components we can extract specs using `ComponentSpec.from_component()` method i.e. components created with ComponentSpec.load() or ConfigMixin subclasses that aren't nn.Modules (e.g., `unet=new_unet, text_encoder=new_encoder`) - ComponentSpec objects: Only supports default_creation_method == "from_config", will call create() method to create a new component (e.g., `guider=ComponentSpec(name="guider", type_hint=ClassifierFreeGuidance, config={...}, default_creation_method="from_config")`) - Configuration values: Simple values to update configuration settings (e.g., `requires_safety_checker=False`) Raises: ValueError: If a component object is not supported in ComponentSpec.from_component() method: - nn.Module components without a valid `_diffusers_load_id` attribute - Non-ConfigMixin components without a valid `_diffusers_load_id` attribute Examples: ```python # Update multiple components at once pipeline.update_components(unet=new_unet_model, text_encoder=new_text_encoder) # Update configuration values pipeline.update_components(requires_safety_checker=False) # Update both components and configs together pipeline.update_components(unet=new_unet_model, requires_safety_checker=False) # Update with ComponentSpec objects (from_config only) pipeline.update_components( guider=ComponentSpec( name="guider", type_hint=ClassifierFreeGuidance, config={"guidance_scale": 5.0}, default_creation_method="from_config", ) ) ``` Notes: - Components with trained weights must be created using ComponentSpec.load(). If the component has not been shared in huggingface hub and you don't have loading specs, you can upload it using `push_to_hub()` - ConfigMixin objects without weights (e.g., schedulers, guiders) can be passed directly - ComponentSpec objects with default_creation_method="from_pretrained" are not supported in update_components() Nz*ModularPipeline.update_components: adding z with new type: z, previous type: zKModularPipeline.update_components: changing the default_creation_method of z from z to rrz/Unexpected keyword arguments, will be ignored: rzuComponentSpec object with default_creation_method == 'from_pretrained' is not supported in update_components() methodr[)r rArrr!rd type_hintrNrOrrifrom_componentr#rTr=rr$r%r>r)r9rsr^passed_component_specspassed_componentspassed_config_valuesrr7current_component_specnew_component_speccreated_componentsr,config_to_register new_values r:update_componentsz!ModularPipeline.update_componentsYsz'+&;&;" !"qF{zZ`abZcerOsAvzz!} " " '+&;&; !"qF{S]^def^givSwAvzz!}   ;?:L:L\QPQU[P[6::a= 0\\0668 =OD)%)%:%:4%@ "&//;J1;;E@FVW`WjWjWsWsVtuFG]GgGgGpGpFqr"/!=!=dI!N !99=S=k=kkabfaggmoEo]o]n^^bcucMcMbNNOP+=D ! !$ '# =& v;? NNLV[[]O\ ]$:$@$@$B 9 D.559JJ L(6'<'<'> t $%)%:%:4%@ "%//;J"4(*@*J*JE@FVWijnWoWyWyXCXCWDDUVlVvVvVVU@A+9D ! !$ ' 9 !  K#4K8JK399; 1OD)/8D  t $ ,'0 t $ 1 5"45m"   ]s- LLL LL/L LLr4c t|tr|g}n't|tstdt ||Dchc]}||j vs|}}|Dchc]}||j vs|}}t |dkDrtjd|i}|D]q}|j |}i}|jD]5\} } t| ts| || <|| vr | ||| <)d| vs.| d|| <7 |jdi|||<s|jdi|ycc}wcc}w#t$r%} tjd|d| Yd} ~ d} ~ wwxYw) aX Load selected components from specs. Args: names: List of component names to load; by default will not load any components **kwargs: additional kwargs to be passed to `from_pretrained()`.Can be: - a single value to be applied to all components to be loaded, e.g. torch_dtype=torch.bfloat16 - a dict, e.g. torch_dtype={"unet": torch.bfloat16, "default": torch.float32} - if potentially override ComponentSpec if passed a different loading field in kwargs, e.g. `repo`, `variant`, `revision`, etc. zInvalid type for names: rz$Unknown components will be ignored: r>zFailed to create component 'rNr[)rArBrSrrr rTrNrOrdrmloadrQr%) r9r4rsrcomponents_to_load unknown_namescomponents_to_registerr(component_load_kwargsr4r5rVs r:r5zModularPipeline.load_componentss eS !GEE4(7U }EF F/4Vt@U@U8UdVV*/U$4t?T?T3TU U }  ! NNA-Q R!#& LD((.D$& !$lln F U!%.16)#.u}5:4[-c2"e+5:95E-c2 F L/8tyy/Q;P/Q&t, L( !  :#9:5WU* L!=dV3qcJKK Ls0D)D)D.2D.?D33 E!<EE! raise_errorrcddlm}||jjn|g}|Dcgc])}t |t j js(|+}}|D]}||s |r tdyycc}w)Nr)_is_group_offload_enabledzYou are trying to apply model/sequential CPU offloading to a pipeline that contains components with group offloading enabled. This is not supported. Please disable group offloading for components of the pipeline to use other offloading methods.TF) hooks.group_offloadingrrr2rArrTrUr)r9rrrrr7s r:*_maybe_raise_error_if_group_offload_activez:ModularPipeline._maybe_raise_error_if_group_offload_actives G17T__++-fX 1;fIz)UZU]U]UdUd?eif f# I(3$V  gs )A9A9c & ddlmddlmmm}m}|jdd}|jdd}|jdd}d}d} t|d k(rCt|d tjr|d }n|d tj|d nd} ntt|dk(rMt|d tjr td |d tj|d nd} |d }nt|dkDr td | | td |xs|}| | td|xs| }|tj|jnd} tfd|j j#D} fdfdtfd|j j#D} |j$duxrt|j$d kD} | r td| dvr%| r | s td| rddr tdtfd|j j#D}|rD| dvr@t&j)ddj+|j j-d| dk(r|jddr|rd t.j0d!<t&j3d"d dl}t7tdrtj8j;s td#d t.j0d$<t&j3d%|j j=}|Dcgc])}t|tj>j@s(|+}}|xs| }|D]n}|\}}}|jC|&}|s|r@|>t&j)d'|jDjFd(|rd)nd*d+|d,|rd)nd*d- |r?|=t&j)d'|jDjFd.|d/|jd0|jCd|1r2|0t&j)d'|jDjFd2|d3|r||d4d5r|jI|6n|s|s|s|jI|||jtjJk(sCtM|d7vsR|rV|rZt&j)d8q|Scc}w)9ug Performs Pipeline dtype and/or device conversion. A torch.dtype and torch.device are inferred from the arguments of `self.to(*args, **kwargs).` If the pipeline already has the correct torch.dtype and torch.device, then it is returned as is. Otherwise, the returned pipeline is a copy of self with the desired torch.dtype and torch.device. Here are the ways to call `to`: - `to(dtype, silence_dtype_warnings=False) → DiffusionPipeline` to return a pipeline with the specified [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) - `to(device, silence_dtype_warnings=False) → DiffusionPipeline` to return a pipeline with the specified [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) - `to(device=None, dtype=None, silence_dtype_warnings=False) → DiffusionPipeline` to return a pipeline with the specified [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) and [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) Arguments: dtype (`torch.dtype`, *optional*): Returns a pipeline with the specified [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) device (`torch.Device`, *optional*): Returns a pipeline with the specified [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) silence_dtype_warnings (`str`, *optional*, defaults to `False`): Whether to omit warnings if the target `dtype` is not compatible with the target `device`. Returns: [`DiffusionPipeline`]: The pipeline converted to specified `dtype` and/or `dtype`. r)_check_bnb_status)ris_accelerate_versionis_hpu_availableis_transformers_versionrNNrVsilence_dtype_warningsFrrzbWhen passing two arguments, make sure the first corresponds to `device` and the second to `dtype`.zPPlease make sure to pass at most two arguments (`device` and `dtype`) `.to(...)`zgYou have passed `dtype` both as an argument and as a keyword argument. Please only pass one of the two.zhYou have passed `device` both as an argument and as a keyword argument. Please only pass one of the two.c3FK|]\}}t|ywrh)any)r]_rrs r:r_z%ModularPipeline.to..[s iIAvs$5f$=?is!cfr ddry|\}}}|ryt|dxrt|jtjj xsSt|jdxr;t|jjdtjj S)N.module_is_sequentially_offloaded^s*,0Ec80T*;F*C 'Aq'$6:.6??J,<,<,M,MN\6??G4\v44Q79I9I9Z9Z[ r<cr ddryt|dxr.t|jtjj S)Nrz 0.17.0.dev0Fr[)rRrAr[rr CpuOffload)rrrs r:module_is_offloadedz/ModularPipeline.to..module_is_offloadedms?*,0Ec=0Y6:.k:foozO_O_OjOj3k kr<c34K|]\}}|ywrhr[)r]rrrs r:r_z%ModularPipeline.to..ts 1 9BF ,V 41 zIt seems like you have activated a device mapping strategy on the pipeline which doesn't allow explicit device placement using `to()`. You can call `reset_device_map()` to remove the existing device map from the pipeline.)cudaxpua7It seems like you have activated sequential model offloading by calling `enable_sequential_cpu_offload`, but are now attempting to move the pipeline to GPU. This is not compatible with offloading. Please, move your pipeline `.to('cpu')` or consider removing the move altogether if you use sequential offloading.rz 1.1.0.dev0zYou are trying to call `.to('cuda')` on a pipeline that has models quantized with `bitsandbytes`. Your current `accelerate` installation does not support it. Please upgrade the installation.c34K|]\}}|ywrhr[)r]rrrs r:r_z%ModularPipeline.to..s#iIAv$7$?#ira5It seems like you have activated model offloading by calling `enable_model_cpu_offload`, but are now manually moving the pipeline to GPU. It is strongly recommended against doing so as memory gains from offloading are likely to be lost. Offloading automatically takes care of moving the individual components rz to GPU when needed. To make sure offloading works as expected, you should consider moving the pipeline back to CPU: `pipeline.to('cpu')` or removing the move altogether if you use offloading.hpu hpu_migrationT1PT_HPU_GPU_MIGRATIONz0Environment variable set: PT_HPU_GPU_MIGRATION=1zBYou are trying to call `.to('hpu')` but HPU device is unavailable.PT_HPU_MAX_COMPOUND_OP_SIZEz7Environment variable set: PT_HPU_MAX_COMPOUND_OP_SIZE=1)rz The module 'z$' has been loaded in `bitsandbytes` 4bit8bitz and conversion to z& is not supported. Module is still in z precision.z:' has been loaded in `bitsandbytes` 8bit and moving it to z2 via `.to()` is not supported. Module is still on r)rrz&' is group offloaded and moving it to z via `.to()` is not supported.>z4.44.0)rV)rSaPipelines loaded with `dtype=torch.float16` cannot run with `cpu` device. It is not recommended to move them to `cpu` as running them will fail. Please make sure to use an accelerator to run the pipeline in inference, due to the lack of support for`float16` operations on this device in PyTorch. Please, remove the `torch_dtype=torch.float16` argument, or use another device for inference.)'pipelines.pipeline_utilsrutilsrrrrrrTrArrNrVrrrrrd hf_device_maprNrOrcr=renvironrMhabana_frameworks.torchrRr is_availabler2rTrUrrritofloat16rB)r9argsrsrrrNrVr dtype_arg device_arg device_typepipeline_has_bnb"pipeline_is_sequentially_offloadedis_pipeline_device_mappedpipeline_is_offloadedhabana_frameworksrXrY is_offloadedrris_loaded_in_4bit_bnbris_group_offloadedrrrrrs @@@@@r:rzModularPipeline.tosH Auu 7D)Hd+!',De!L  t9>$q'5;;/ G 6:1g6IU\\$q'2t Y!^$q'5;;/ x37q'2Ed1g.4JQI Y]op p  !6y "  *"8z %:393Eell6*//4 iQUQ`Q`QfQfQhii  l.11 FJooF[F[F]1 . *%)$6$6d$B$bs4K]K]G^abGb! $p  / )1:J N"&;C&N U !$#iQUQ`Q`QfQfQh#i i [O%C NNHIMIRIRSWSbSbSgSgSiIjHkkkl  % FJJ$EJZJ\14BJJ- . LLK L *E5)eii.D.D.F !eff8;BJJ4 5 LLR S//((*%HAuxx)G1HH,R0R + F>OPV>W ;A$&;!%!P!PX^!P!_ %)>EDU"6#3#3#<#<"==amBbhHNbOObchbiiOZoPVu{O||GH%);"6#3#3#<#<"==wx~w@rsys@s@rAABC??EZ`?a&"6#3#3#<#<"==cdjcklJK %);@WX[]e@f  (*3HQc &%(  -K7*.$bK+ X _Is ")T Tr,c|jdk7ry|jt|j\}}nd}d}|jDcic]}|t ||}}d||fi|Scc}w)uo Convert a ComponentSpec into a JSON‐serializable dict for saving as an entry in `modular_model_index.json`. If the `default_creation_method` is not `from_pretrained`, return None. This dict contains: - "type_hint": Tuple[str, str] Library name and class name of the component. (e.g. ("diffusers", "UNet2DConditionModel")) - All loading fields defined by `component_spec.loading_fields()`, typically: - "repo": Optional[str] The model repository (e.g., "stabilityai/stable-diffusion-xl"). - "subfolder": Optional[str] A subfolder within the repo where this component lives. - "variant": Optional[str] An optional variant identifier for the model. - "revision": Optional[str] A specific git revision (commit hash, tag, or branch). - ... any other loading fields defined on the spec. Args: component_spec (ComponentSpec): The spec object describing one pipeline component. Returns: Dict[str, Any]: A mapping suitable for JSON serialization. Example: >>> from diffusers.pipelines.modular_pipeline_utils import ComponentSpec >>> from diffusers import UNet2DConditionModel >>> spec = ComponentSpec( ... name="unet", ... type_hint=UNet2DConditionModel, ... config=None, ... repo="path/to/repo", ... subfolder="subfolder", ... variant=None, ... revision=None, ... default_creation_method="from_pretrained", ... ) >>> ModularPipeline._component_spec_to_dict(spec) { "type_hint": ("diffusers", "UNet2DConditionModel"), "repo": "path/to/repo", "subfolder": "subfolder", "variant": None, "revision": None, } rNrq)r#rqrloading_fieldsrv)r,lib_namerr^load_spec_dicts r:rKz'ModularPipeline._component_spec_to_dictsL  1 15F F  # # /!;N>> spec_dict = { ... "type_hint": ("diffusers", "UNet2DConditionModel"), ... "repo": "stabilityai/stable-diffusion-xl", ... "subfolder": "unet", ... "variant": None, ... "revision": None, ... } >>> ModularPipeline._dict_to_component_spec("unet", spec_dict) ComponentSpec( name="unet", type_hint=UNet2DConditionModel, config=None, repo="stabilityai/stable-diffusion-xl", subfolder="unet", variant=None, revision=None, default_creation_method="from_pretrained" ) rqN)rrqr[)copyrrr)rrrrrqs r:r"z'ModularPipeline._dict_to_component_spec sdPNN$ &]];7(  H$8,Xx@II    r<c |jjjD]$\}}t|ds|jdi|&y)Nrr[)rrrdrRr)r9rsrrs r:rz'ModularPipeline.set_progress_bar_config; sG)-)?)?)E)E)G < %NIy";<1 11;F; r6r;rr2rTrrr=rrrQrrirNrTrArBrCrSr~r) r9rrrs passed_kwargsexpected_input_paramrr>r6rrWs r:rXzModularPipeline.__call__@ sP =!OE %)KK$6$6 6 ',,D*22G.::K}$ $ 1 1$ 7EU\\) $5 6 }  ! MM.}/A/A/C.DDkl m ]]_  ;;tU35  >L fc "99V$ $ u .99V$ $xx/KLM M / 0E0E0N0N/OtT  Y'   s.F00E))AF--F00F9)NNNNrr)FNr)3rirjrkrlrrr rr rBrr rrtrrrr2r6rrrrrrr%rrVr^rNr rdrfrirlrrror{r5rTrUrrrr!rKr"rr0rXr[r<r:rrs@ -KM 37KO:>$( dx./dx(0c2;;6F0G'Hdx%%67 dx SM dxLc3h 4-1:>$( ?'/c2;;6F0G'H?$D>?%%67 ? SM ??B"eC4D.E"TX"HfMP # # #* u{{  vd3ivv,c,,  DI      S    kDcNkk5s5}5r6l,;U49c>%:,;`NR19%((//1J &}T}~1 1 #1 1 f4 4 S>4  4 4 l< NNmNNE#tCy.rs) #(:: '6"9_DDbL1      H %'#.# GwGw GwT D/D/ D/Nh Kh V  . D[ 4[ | Y+#8Y+@ INk>INr<