o hP@sddlZddlZddlmZmZddlmZddlmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZddlmZGdddeddZGdddZ dS)N) defaultdict namedtuple)Enum)TopologicalSorter)chain)settings)models) operations) Migration)AlterModelOptions)MigrationOptimizer)MigrationQuestioner)COMPILED_REGEX_TYPE RegexObjectresolve_relation)cached_propertyc@s4eZdZGdddeZeddZeddZdS)OperationDependencyc@s eZdZdZdZdZdZdZdS)zOperationDependency.TyperN)__name__ __module__ __qualname__CREATEREMOVEALTERREMOVE_ORDER_WRTALTER_FOO_TOGETHERrra/var/www/html/premium_crap/venv/lib/python3.10/site-packages/django/db/migrations/autodetector.pyTypes r!cC |jSN) model_namelowerselfrrr model_name_lower! z$OperationDependency.model_name_lowercCr"r#) field_namer%r&rrr field_name_lower%r)z$OperationDependency.field_name_lowerN)rrrrr!rr(r+rrrr rs  rz$app_label model_name field_name typec@seZdZdZdjddZdkddZddZd d Zdld d Zd dZ ddZ e ddZ djddZ ddZddZddZdmddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Z dd?Z"d@dAZ#dBdCZ$dDdEZ%dFdGZ&dHdIZ'e dJdKZ(dLdMZ)dNdOZ*dPdQZ+dRdSZ,dTdUZ-dVdWZ.dXdYZ/dZd[Z0d\d]Z1d^d_Z2d`daZ3dbdcZ4djdddeZ5dfdgZ6e7dhdiZ8dS)nMigrationAutodetectora  Take a pair of ProjectStates and compare them to see what the first would need doing to make it match the second (the second usually being the project's current state). Note that this naturally operates on entire projects at a time, as it's likely that changes interact (for example, you can't add a ForeignKey without having a migration to add the table it depends on first). A user interface may offer single-app usage if it wishes, with the caveat that it may not always be possible. NcCs.||_||_|p t|_dd|jD|_dS)NcSsh|]\}}|qSrr).0appmodelrrr ;sz1MigrationAutodetector.__init__..) from_stateto_stater questionerr existing_apps)r'r1r2r3rrr __init__7s zMigrationAutodetector.__init__cCs.|||}||||}|r|||}|S)z Main entry point to produce a list of applicable changes. Take a graph to base names on and an optional set of apps to try and restrict to (restriction is not guaranteed) )_detect_changesarrange_for_graph _trim_to_apps)r'graph trim_to_apps convert_appsmigration_namechangesrrr r==s  zMigrationAutodetector.changescst|trfdd|DSt|trtfdd|DSt|tr.fdd|DSt|tjrB|j|j |j fSt|t rKt |St|t rR|St|dr|}t|tjrg|dd }|\}}}|fd d|Dfd d|DfS|S) z Recursive deconstruction for a field and its arguments. Used for full comparison for rename/alter; sometimes a single-level deconstruction will not compare correctly. cg|]}|qSrdeep_deconstructr-valuer&rr Pz:MigrationAutodetector.deep_deconstruct..c3s|]}|VqdSr#r?rAr&rr Rsz9MigrationAutodetector.deep_deconstruct..ci|] \}}||qSrr?r-keyrBr&rr Tz:MigrationAutodetector.deep_deconstruct.. deconstructrNcr>rr?rAr&rr rCirDcrFrr?rGr&rr rIjrJ) isinstancelisttupledictitems functoolspartialfuncr@argskeywordsrrtypehasattrrKrField)r'obj deconstructedpathrTkwargsrr&r r@Is2            z&MigrationAutodetector.deep_deconstructcCsPg}t|D]\}}||}|jr |jjr |ddd||q|S)z Return a definition of the fields that ignores field names and what related fields actually relate to. Used for detecting renames (as the related fields change during renames). rtoN)sortedrPr@ remote_fieldr/popappend)r'fields fields_defnamefielddeconstructionrrr only_relation_agnostic_fieldsos  z3MigrationAutodetector.only_relation_agnostic_fieldscCsHi|_i|_i|_i|_t|_t|_t|_t|_t|_ t|_ |j j D]3\\}}}|jdds@|j||fq*||j jvr]|jdrU|j||fq*|j||fq*|jj D]9\\}}}|jddsz|j ||fqd||j jvs|r||vr|jdr|j ||fqd|j||fqd|j |j||||||||||||| |!|"|#|$|%|&|'|(|)|*|+|,|-|.|/|0||1|j2S)aX Return a dict of migration plans which will achieve the change from from_state to to_state. The dict has app labels as keys and a list of migrations as values. The resulting migrations aren't specially named, but the names do matter for dependencies inside the set. convert_apps is the list of apps to convert to use migrations (i.e. to make initial migrations for, in the usual case) graph is an optional argument that, if provided, can help improve dependency generation and avoid potential circular dependencies. managedTproxy)3generated_operationsaltered_indexesaltered_constraintsrenamed_fieldssetold_model_keysold_proxy_keysold_unmanaged_keysnew_model_keysnew_proxy_keysnew_unmanaged_keysr1rrPoptionsgetadd real_appsr2resolve_fields_and_relationsgenerate_renamed_models_prepare_field_lists_generate_through_model_mapgenerate_deleted_modelsgenerate_created_modelsgenerate_deleted_proxiesgenerate_created_proxiesgenerate_altered_optionsgenerate_altered_managers!generate_altered_db_table_commentcreate_renamed_fieldscreate_altered_indexescreate_altered_constraintsgenerate_removed_constraintsgenerate_removed_indexesgenerate_renamed_fieldsgenerate_renamed_indexes(generate_removed_altered_unique_togethergenerate_removed_fieldsgenerate_added_fieldsgenerate_altered_fields&generate_altered_order_with_respect_to generate_altered_unique_togethergenerate_added_indexesgenerate_added_constraintsgenerate_altered_constraintsgenerate_altered_db_table_sort_migrations_build_migration_list_optimize_migrations migrations)r'r;r9 app_labelr$ model_staterrr r6}s|       z%MigrationAutodetector._detect_changescs`jj@_jj@_jj@_i_ fddjD_ fddjD_ dS)z Prepare field lists and a list of the fields that used through models in the old state so dependencies can be made from the through model deletion to the field that uses it. cs@h|]\}}jj|j||f|fjD]}|||fqqSr)r1rrenamed_modelsrvrbr-rr$r*r&rr r0sz=MigrationAutodetector._prepare_field_lists..cs2h|]\}}jj||fjD]}|||fqqSr)r2rrbrr&rr r0sN) rorrkept_model_keysrprskept_proxy_keysrqrtkept_unmanaged_keys through_usersold_field_keysnew_field_keysr&rr&r r{s   z*MigrationAutodetector._prepare_field_listscCst|jD];\}}|j||f|}|jj||f}|jD] \}}t|dr?t |j ddr?t |j j ||}|||f|j |<qqdS)zThrough model map generation.r_throughN)r^rorrvr1rrbrPrWgetattrr_rrr)r'rr$old_model_nameold_model_stater*re through_keyrrr r|s&   z1MigrationAutodetector._generate_through_model_mapcCsB|jdkr |dfStt|jd\}}t|||j|jdfS)zp Return the resolved dependency and a boolean denoting whether or not it was swappable. __setting__F.T) rrrr$splitrr%r*rV) dependencyresolved_app_labelresolved_object_namerrr _resolve_dependencys z)MigrationAutodetector._resolve_dependencycCsFi|_tdd|jD}d}|r!t|jD]}g}t}t|j|D]}d}t} |jD]l} | } || \} } | j |kr|j | j gD] } | | | rUd}nqI|sZnD| rf| | j | j fq1| j |jvr|| | j |j| j djfq1|r|r|| j r| || j dq1| | j dfq1d}q1|r|||| |j|d=q'|s|r|j|r|rtdtfggd }|d t|j |gd |}t||_||_||jv|_|j|g|d}q||j||j|<qtd d|jD}||kr|sd}ntd |j|}|sdSdS)ag Chop the lists of operations up into migrations with dependencies on each other. Do this by going through an app's list of operations until one is found that has an outgoing dependency that isn't in another app's migration yet (hasn't been chopped off its list). Then chop off the operations before it into a migration and move onto the next app. If the loops completes without doing anything, there's a circular dependency (which _should_ be impossible as the operations are all split at this point so they can't depend and be depended on). cs|]}t|VqdSr#lenr-xrrr rE3z>MigrationAutodetector._build_migration_list..FTr __first__r )r dependencieszauto_%ircsrr#rrrrr rErz)Cannot resolve operation dependencies: %rN)rsumrjvaluesr^rnrM _auto_depsrrrvcheck_dependencyrwr$rd leaf_nodesraupdaterVr rrr r4initial setdefault ValueError)r'r9num_ops chop_moderchoppedr operationdeps_satisfiedoperation_dependenciesdep original_depis_swappable_depother_operationsubclassinstance new_num_opsrrr r's             z+MigrationAutodetector._build_migration_listcstjD]>\}}t}|D]+}|||jD] dj|kr)q|j|gfdd|DRqqt| j|<qdS)z{ Reorder to make things possible. Reordering may be needed so FKs work nicely inside the same app. rc3s |] }|r|VqdSr#)rrrr'rr rEsz9MigrationAutodetector._sort_migrations..N) r^rjrPrrwrrrrM static_order)r'ropstsoprrr rs   $z&MigrationAutodetector._sort_migrationscCs|jD]\}}t||ddD] \}}|j||jfqq|jD]}|D] }tt|j|_q*q&|jD]\}}|D] }t |j ||_ qAq;dS)Nr) rrPziprrardrrMrnr optimizer )r'rrm1m2 migrationrrr rsz*MigrationAutodetector._optimize_migrationscsjdurjtjjkrt|tjo|jj kSjdurNjtjjkrNt|tjo;|jj ko;t fdd|j DpMt|tj oM|j j koM|jj kSjdurljtjjkrlt|tjok|j j kok|jj kSjdurjtjjkrt|tjo|jj kSjdurjtjjkrt|tjo|j j ko|jj kSjdurĈjtjjkrt|tjo|jj ko|jpdj kSjdur߈jtjjkrt|tjtjfo|jj kStdf)zn Return True if the given operation depends on the given dependency, False otherwise. Nc3s|] \}}j|kVqdSr#)r*)r-ryrrr rEsz9MigrationAutodetector.check_dependency..zCan't handle dependency %r)r*rVrr!rrLr CreateModel name_lowerr(anyrbAddFieldr+r RemoveField DeleteModelr AlterFieldrAlterOrderWithRespectToorder_with_respect_tor%rAlterUniqueTogetherAlterIndexTogetherr)r'rrrrr rsl                            z&MigrationAutodetector.check_dependencyFcCs@|pg|_|r|j|gd|dS|j|g|dS)Nr)rrjrinsertra)r'rrr beginningrrr add_operations z#MigrationAutodetector.add_operationcCsz?|jj|}dd|jD}d|d|df}|jds0d|vs0d|vs0tj|kr=d |dd |dfWSW|StyIY|Sw) z| Place potential swappable models first in lists of created models (only real way to solve #22783). cSs h|] }t|tr |n|jqSr)rLstrr)r-baserrr r0'z.%s.%srr swappable AbstractUserAbstractBaseUser___) r2rbasesrurvrAUTH_USER_MODELr% LookupError)r'itemr base_namesstring_versionrrr swappable_first_key s$   z)MigrationAutodetector.swappable_first_keyc Csli|_i|_|j|j}t|D]\}}|jj||f}||j}|j|j}|D]\}}||kr|j j||f} || j} || kr|j | |rg} t |j dd|jj||f D} | D]} | jrv| |||| |jqe|j|tj| j|jd| d||j||f<d| j| jf}d|j|jf|j|<|j||f|j||fnq*qdS)z Find any renamed models, generate the operations for them, and remove the old entry from the model lists. Must be run before other model-level generation. cSs g|] }|D]}|jqqSr)rr_)r- relationsrerrr rCRszAMigrationAutodetector.generate_renamed_models..)old_namenew_namerrN)rrenamed_models_relrrror^r2rrgrbr1r3ask_rename_modelrMrr is_relationextend!_get_dependencies_for_foreign_keyrr RenameModelrdrrremoverw)r' added_modelsrr$rmodel_fields_defremoved_models rem_app_labelrem_model_namerem_model_staterem_model_fields_defrrbrerenamed_models_rel_keyrrr rz7sz    z-MigrationAutodetector.generate_renamed_modelsc s|j|jB}|j|}|j|}tt||jddt||jdd}|D]\|jjf}id}|j D]&\}}|j r_|j j rT|j rL|j j }n|j jsT||<t|j ddr_||<q9|jd} |jd} |jdd} |jdd} tdtjjg} |jD]S}t|trd |vr|d d \}}| t||dtjj|jj||f}|jj||f}|r|rt|j |j |j }|D]}| t|||tjjqq|r| tgt |dtjjR|j!t"j#|j$fd d |j D|j|j|j%d | dd|jddsq#t D],\}}|&||j} | tdtjj|j!t"j'||dt(t| dq| rl|j!t"j)| dt| tjjtdtjjgdfdd tD}|tdtjj| D]}|j!t"j*|d|dq| D]}|j!t"j+|d|dq| r|j!t"j,| d|d|jj-}f|j.vr|f D]-\}|jj|} D]\}}|j!|j/t"j0|j$||dtdtjjgdqܐqq#dS)ar Find all new models (both managed and unmanaged) and make create operations for them as well as separate operations to create any foreign key or M2M relationships (these are optimized later, if possible). Defer any model options that refer to collections of fields that might be deferred (e.g. unique_together). T)rHreverseNrindexes constraintsunique_togetherrrrcsg|] }|dvr|qS)rrr-d)related_fieldsrr rCs  zAMigrationAutodetector.generate_created_models..rdrbrurmanagers)rrrhr$rdrerrdrcsg|] }t|tjjqSr)rr!r)r-rd)rr$rr rCs  r$indexr$ constraintrdr)1rorqrrrtrr^rr2rrbrPr_r/ primary_key parent_linkrrur`rr!rrrLrrrarr1rvrn difference intersectionrrr rrdrrrrMrAddIndex AddConstraintrrrprr)r'old_keysradded_unmanaged_modelsall_added_modelsrprimary_key_relr*rer r rrrrbase_app_label base_nameold_base_model_statenew_base_model_stateremoved_base_fieldsremoved_base_fieldrdrelated_dependenciesrrrrelated_model_keyrelated_model_staterelated_field_name related_fieldr)rr$rr r~{s                        z-MigrationAutodetector.generate_created_modelsc Cs|j|j}t|D]U\}}|jj||f}|jdsJt||dtjj g}|j D]}t |t rJd|vrJ| dd\}}|t||dtjjq+|j|tj|jg|j|j |jd|dq dS)z Make CreateModel statements for proxy models. Use the same statements as that way there's less code duplication, but for proxy models it's safe to skip all the pointless field stuff and chuck out an operation. riNrrrr)rsrpr^r2rrurvrr!rrrLrrrarrr rrdr) r'addedrr$rrrr%r&rrr rXs@    z.MigrationAutodetector.generate_created_proxiesc Cs|j|jB}|j|}|j|}tt|t|}|D]\}}|jj||f}i}|j D]\} } | j rH| j j r=| || <t | j ddrH| || <q.|j dd} | r]||tj|ddt|D] } ||tj|| dqag} |jj}|||f D]*\\}}}| D]\} } | t||| tjj| js| t||| tjjqq}t|D]} | t||| tjjq|j||jf}|r| tg|tjjR|j|tj|jdtt | dqdS)a Find all deleted models (managed and unmanaged) and make delete operations for them as well as separate operations to delete any foreign key or M2M relationships (these are optimized later, if possible). Also bring forward removal of any model options that refer to collections of fields - the inverse of generate_created_models(). rNrrr$rdrdr)!rrrtrorqrr^r1rrbrPr_r/rrur`rr rrrrarr!r many_to_manyrrrvrrrdrMrn)r'new_keysdeleted_modelsdeleted_unmanaged_modelsall_deleted_modelsrr$rrr*rerrdrrrelated_object_app_label object_namerelation_related_fields through_userrrr r}s         z-MigrationAutodetector.generate_deleted_modelscCsX|j|j}t|D]\}}|jj||f}|jdsJ||tj |j dq dS)z*Make DeleteModel options for proxy models.rir2N) rprsr^r1rrurvrr rrd)r'deletedrr$rrrr rs z.MigrationAutodetector.generate_deleted_proxiesc Csg|_|j}t|j|D]\}}}|j||f|}|jj||f}|j j||f}| |}| |} t||jD]\} } } | |kr| |kr| | } | | }|j rv|j j rvd|dvrv|dd}||jvrv|j||dd<| | | d}|| ks|dd| ddkrt|d|d| dkr|j|| ||r|j| | | j| ||||f|| | | f||||f| |j|||f<nq>qdS)zWork out renamed fields.r]rrr) db_columnN)renamed_operationsrcopyr^rrrvr1rr2 get_fieldr@r_r/rset_attributes_from_nameget_attname_columnrOr3 ask_renamerar=rrwrm)r'rrr$r*rrnew_model_statere field_decrrrem_field_name old_field old_field_dec old_rel_to old_db_columnrrr rsp           z+MigrationAutodetector.create_renamed_fieldsc Cs|jD]@\}}}}}}}}||jkr%|} || _||tj||| d||tj|||d|j |||f|j |||fqdS)z Generate RenameField operations.r)r$rrN) r>r=clonerdrr r RenameFieldrrrw) r'rr rem_db_columnrFrr$rer* altered_fieldrrr r,s@  z-MigrationAutodetector.generate_renamed_fieldscC.t|j|jD] \}}}||||qdS)zMake AddField operations.N)r^rr_generate_added_fieldr'rr$r*rrr rQ  z+MigrationAutodetector.generate_added_fieldsc CsN|jj||f|}t|||tjjg}|jr(|jjr(|| ||||j|j r3|| |tj tj tjf}tjtjtjf}|jpc|pc|pc|jpc|joV|jpct||o^|jpct||}|s|}t||r{|jr{|j|||_n|j|||_|j r|rt!|jr|j"|||j#|t$j%||||d|ddS)Nr$rdrepreserve_defaultr)&r2rr@rr!rr_r/rr generated%_get_dependencies_for_generated_field DateField DateTimeField TimeField AutoFieldSmallAutoField BigAutoFieldnull has_defaulthas_db_defaultr3blankempty_strings_allowedrLauto_nowrK auto_now_addr3ask_auto_now_add_additiondefaultask_not_null_additionuniquecallable$ask_unique_callable_default_additionrr r) r'rr$r*rer time_fields auto_fieldsrTrrr rPXsh    z+MigrationAutodetector._generate_added_fieldcCrO)zMake RemoveField operations.N)r^rr_generate_removed_fieldrQrrr rrRz-MigrationAutodetector.generate_removed_fieldsc Cs>|j|tj||dt|||tjjt|||tjjgddS)Nr1r)rr rrr!rrrQrrr rls( z-MigrationAutodetector._generate_removed_fieldc stjj@D]J\}}}j||f|}j|||f|}jj||f|}j j||f|}g}t |drt |j ddrt |j j||jvrX|j j|j _t |j dd} | rw| f} | jvrw|j j|j _|j j|j _t |dd} | r||ftfdd| D|_tfdd|jD|_t |dd} rt| |_t|j|_||||j t |drt |j d drt |j j||jvr|j j|j _|} |}| |krS||krS|jo|j}|j o|j }|s|rEd }|jr3|js3|s3|s3|js3|}j||}|tjur2||_d }n|}j |t!j"||||d |d q#|||$|||qdS)zp Make AlterField operations, or possibly RemovedField/AddField if alter isn't possible. r_r/Nr* from_fieldsc g|] }j|f|qSrrmrv)r- from_field)from_rename_keyr'rr rCs  zAMigrationAutodetector.generate_altered_fields..crnrro)r-to_field) rename_keyr'rr rCrrTFrSr)%r^rrrrvrmr1rr@r2rWrr_rr/r*rNrm to_fieldsrrrr@r3r]r^r_rKr3ask_not_null_alteration NOT_PROVIDEDrerr rrlrP)r'rr$r*rold_field_namerG new_fieldrremote_field_nameto_field_rename_keyrmold_from_fieldsrH new_field_decboth_m2m neither_m2mrTre new_defaultr)rqrsr'r rs                        z-MigrationAutodetector.generate_altered_fieldscs&tjj}tt|_t|jD]\}}|j ||f|}|j j ||f}|j j ||f}|j ||j |fddD}fddD}g} gg|D]7} | } | dd} |D]'} | }|dd}| |kr| |kr| || df| | q_qP|tjjD]`\}}}}}||ks||krq||}|D]H}g}|D]} | \}}}|s| jt|krt|ddhkr|| qt|dkr|d}|| d|j|f|j||f|qqfd d|D}fd d|D}|j||f||| d iqdS) Ncg|]}|vr|qSrrr-idx) old_indexesrr rC9z@MigrationAutodetector.create_altered_indexes..crrrr) new_indexesrr rC:rrrdrbrrcrrrr)remove_from_addedrr rCtcrrrr)remove_from_removedrr rCwr) added_indexesremoved_indexesrenamed_indexes)r r option_namerrMrenamed_index_together_valuesr^rrrvr1rr2rurKr`ra$_get_altered_foo_together_operationsrrrbrnrrdrkr)r'rrr$rrrDrrr new_index new_index_decnew_index_name old_index old_index_decold_index_name old_value new_valueindex_together_app_labelindex_together_model_namerremoved_valuesremoved_index_togetherrenamed_index_together_indexes_rTr\ renamed_indexr)rrrrr r,s            z,MigrationAutodetector.create_altered_indexescCP|jD] \\}}}|||}|dD]}|j|tj||d|dqqdS)Nrrr)rkrP_get_dependencies_for_modelrr r)r'rr$ alt_indexesrrrrr rs  z,MigrationAutodetector.generate_added_indexesc CB|jD]\\}}}|dD]}||tj||jdqqdS)Nrr1)rkrPrr RemoveIndexrd)r'rr$rrrrr rs z.MigrationAutodetector.generate_removed_indexesc CsJ|jD]\\}}}|dD]\}}}||tj||||dqqdS)Nr)r$rr old_fields)rkrPrr RenameIndex)r'rr$rrrrrrr rsz.MigrationAutodetector.generate_renamed_indexesc Cs`|\}}}|\}}}|jD]} || dq|jD]} || dq|||f|||fkSr#)rK non_db_attrsr`) r'old_constraintnew_constraintold_pathold_args old_kwargsnew_pathnew_args new_kwargsattrrrr +_constraint_should_be_dropped_and_recreateds  zAMigrationAutodetector._constraint_should_be_dropped_and_recreatedcs tjj}t|jD]z\}}|j||f|}|jj||f}|j j||f}|j ||j |g}gD]*}D]%} | } | } | | kr_|j | j kr_| || s_|| | j q:q6fddD} fddD} |j||f| | |diq dS)Nc"g|] }|vr|jvr|qSrr2r-c)alt_constraints_nameold_constraintsrr rC zDMigrationAutodetector.create_altered_constraints..crrr2r)rnew_constraintsrr rCr)added_constraintsremoved_constraintsrl)r r rr^rrrvr1rr2rurKrdrrarlr)r'rrr$rrrDalt_constraintsold_cnew_c old_c_dec new_c_decadd_constraintsrem_constraintsr)rrrr rsP       z0MigrationAutodetector.create_altered_constraintscCr)Nrrr)rlrPrrr r r'rr$rrrrrr rs"  z0MigrationAutodetector.generate_added_constraintsc Cr)Nrr1)rlrPrr RemoveConstraintrd)r'rr$rrrrr rs z2MigrationAutodetector.generate_removed_constraintsc CsT|jD]"\\}}}|||}|dD]}|j|tj||j|d|dqqdS)Nrl)r$rdrr)rlrPrrr AlterConstraintrdrrrr r s$  z2MigrationAutodetector.generate_altered_constraintscsd}tjdr jj}n(|j||f}|D]\\}}}tfdd|Dr4|d|}nqtdd} | durDd} | } nt|||\} } t | | dt j j g} tjddrstjj ||\} }| t | |dt j j | S)Nr/c3s|]}|jkVqdSr#)r_)r-r/rerr rE"s  zJMigrationAutodetector._get_dependencies_for_foreign_key..rswappable_settingrr)rWr_r/rrPrrrrrr!rrra)rr$re project_stateremote_field_modelrremote_app_labelremote_model_namerbr dep_app_labeldep_object_namerthrough_app_labelthrough_object_namerrr rsN     z7MigrationAutodetector._get_dependencies_for_foreign_keyc Cs~g}t|jj}t|j|j}|D])\}}}|jj||f|}|j r*|j j s/|j |vr<| t |||j t jjq|Sr#)rQ expressionreferenced_base_fieldsr^rrr2r@r_r/rdrarr!r) r'rerrnewly_added_fieldsrr$added_field_name added_fieldrrr rVHs, z;MigrationAutodetector._get_dependencies_for_generated_fieldc CsFg}|jj||f}|jD]}|jr ||||||jq|S)z3Return foreign key dependencies of the given model.)r2rrbrrrr)r'rr$rrrerrr r]sz1MigrationAutodetector._get_dependencies_for_modelc #stjD]r\jf}jj|f}jjf}|j|}|r6fdd|Dnt}|j|}|rEt|nt}||krxg}|D]}|D]} | | } | j rn| j j rn|  | jqTqP|||fVqdS)Ncs&h|]}tfdd|DqS)c3s$|] }j|f|VqdSr#ro)r-nrr$r'rr rEys  zWMigrationAutodetector._get_altered_foo_together_operations...)rN)r-rgrrr r0xs zMMigrationAutodetector._get_altered_foo_together_operations..)r^rrrvr1rr2rurnr@r_r/rr) r'rrrrDrrr foo_togethersr*rerrr rmsP     z:MigrationAutodetector._get_altered_foo_together_operationscsv|jD]2\}}}|tjkrfdd|D}||}|s&|r8j|ddi|j|i|dqdS)Ncs"h|] }|jfvr|qSr)rrArrr r0s zOMigrationAutodetector._generate_removed_altered_foo_together..rdrr)rrr rrr)r'rrrr removal_valuerrr &_generate_removed_altered_foo_togethers0   zMigrationAutodetector.generate_removed_altered_unique_togethercCsV||jD]"\}}}}}||}||kr(|j||dd|i|j|i|dqdS)Nrdrr)rrrr)r'rrrrr$rrrrr _generate_altered_foo_togethers  z4MigrationAutodetector._generate_altered_foo_togethercCrr#)rr rr&rrr rrz6MigrationAutodetector.generate_altered_unique_togetherc C|j|j|j}t|D]8\}}|j||f|}|jj||f}|j j||f}|j d}|j d}||krE| |t j ||dq dS)Ndb_table)rdtable)runionrrr^rrvr1rr2rurr AlterModelTable) r'models_to_checkrr$rrrDold_db_table_namenew_db_table_namerrr rs*  z/MigrationAutodetector.generate_altered_db_tablec Cr)Ndb_table_comment)rd table_comment)rrrrr^rrvr1rr2rurr AlterModelTableComment) r'rrr$rrrDold_db_table_commentnew_db_table_commentrrr rs*  z7MigrationAutodetector.generate_altered_db_table_commentc Cs|j|j|j|j|j@|j|j@}t|D]@\}}|j ||f|}|j j ||f}|j j ||f}dd|jD}dd|jD}||krW||tj||dqdS)z Work out if any non-schema-affecting options have changed and make an operation to represent them in state changes (in case Python code in migrations needs them). cS i|] \}}|tjvr||qSrr ALTER_OPTION_KEYSrGrrr rI   zBMigrationAutodetector.generate_altered_options..cSrrrrGrrr rIr)rdruN)rrrrrqrrrortr^rrvr1rr2rurPrr r ) r'rrr$rrrD old_options new_optionsrrr rs8   z.MigrationAutodetector.generate_altered_optionscCst|jD]Q\}}|j||f|}|jj||f}|jj||f}|jd|jdkrVg}|jdrE|t |||jdt j j |j |t j||jdd|dqdS)Nrrr)r^rrrvr1rr2rurarr!rrr r)r'rr$rrrDrrrr rsB   z.) rrMrPr3 ask_initialrd parse_number enumeraterra suggest_namejoinr)r'r=r9r<leavesrrapp_leafleafr next_numberinew_name_partsrrrr r7PsP           z'MigrationAutodetector.arrange_for_graphc si|D]\}}|D]}|jD]\}}|t|qq qt|}d} | |kr@t|} |jfdd|D| |ks,t|D] }||vrM||=qD|S)a1 Take changes from arrange_for_graph() and set of app labels, and return a modified set of changes which trims out as many migrations that are not in app_labels as possible. Note that some other migrations may still be present as they may be required dependencies. Ncsg|]}|dqS)rr)r-rapp_dependenciesrr rCrz7MigrationAutodetector._trim_to_apps..)rPrrrnrwrrM) r'r= app_labelsrrrrrd required_appsold_required_appsrrr r8s( z#MigrationAutodetector._trim_to_appscCs<td|}rt|dStd|}|rt|dSdS)u Given a migration name, try to extract a number from the beginning of it. For a squashed migration such as '0001_squashed_0004…', return the second number. If no number is found, return None. z.*_squashed_(\d+)rz^\d+rN)researchintmatch)clsrdsquashed_matchrrrr rs    z"MigrationAutodetector.parse_numberr#)NNN)NN)NF)9rrr__doc__r5r=r@rgr6r{r| staticmethodrrrrrrrrzr~rr}rrrrrPrrlrrrrrrrrrrrrVrrrrrrrrrrrr7r8 classmethodrrrrr r,*sr  & j  x T D^*_ >%8{Y   2 -/(" 4r,)!rQr collectionsrrenumrgraphlibr itertoolsr django.confr django.dbrdjango.db.migrationsr django.db.migrations.migrationr &django.db.migrations.operations.modelsr django.db.migrations.optimizerr django.db.migrations.questionerr django.db.migrations.utilsrrrdjango.utils.functionalrrr,rrrr s&