3 g@sddlZddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z ddlmZdd lmZdd lmZmZdd lmZGd d d ZdS)N)chain)settings)models) operations) Migration)AlterModelOptions)MigrationOptimizer)MigrationQuestioner)COMPILED_REGEX_TYPE RegexObject)stable_topological_sortc@steZdZdZdXddZdYddZddZd d ZdZd d Zd dZ ddZ e ddZ d[ddZ ddZddZddZd\ddZddZd 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'dJdKZ(dLdMZ)dNdOZ*dPdQZ+d]dRdSZ,dTdUZ-e.dVdWZ/dS)^MigrationAutodetectora  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.||_||_|pt|_dd|jD|_dS)NcSsh|] \}}|qSr).0Zappmodelrr_/var/www/tester-filtro-web/env/lib/python3.6/site-packages/django/db/migrations/autodetector.py !sz1MigrationAutodetector.__init__..) from_stateto_stater questionerr existing_apps)selfrrrrrr__init__s zMigrationAutodetector.__init__cCs.|j||}|j|||}|r*|j||}|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)rgraphZ trim_to_apps convert_appsmigration_namechangesrrrr#s   zMigrationAutodetector.changescs t|trfdd|DSt|tr6sz:MigrationAutodetector.deep_deconstruct..c3s|]}j|VqdS)N)r )rr!)rrr 8sz9MigrationAutodetector.deep_deconstruct..csi|]\}}j||qSr)r )rkeyr!)rrr :sz:MigrationAutodetector.deep_deconstruct.. deconstructNcsg|]}j|qSr)r )rr!)rrrr"Nscsi|]\}}j||qSr)r )rr$r!)rrrr%Os) isinstancelisttupledictitems functoolspartialfuncr argskeywordsr r typehasattrr&rZField)robjZ deconstructedpathr0kwargsr)rrr /s.             z&MigrationAutodetector.deep_deconstructcCsNg}xDt|jD]4\}}|j|}|jr<|jjr<|dd=|j|qW|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). to)sortedr,r remote_fieldrappend)rfieldsZ fields_defnamefieldZdeconstructionrrronly_relation_agnostic_fieldsWs  z3MigrationAutodetector.only_relation_agnostic_fieldscCs(i|_i|_i|_|jj|_|jj|_t |_ t |_ t |_ t |_ t |_t |_xr|jjD]f\}}|jj||}|jjs|j j||fq`||jjkr`|jjr|j j||fq`|j j||fq`Wx|jjD]x\}}|jj||}|jjs|jj||fq||jjks |r||kr|jjr<|jj||fq|j j||fqW|j|j|j|j|j|j|j|j|j|j |j!|j"|j#|j$|j%|j&|j'|j(|j)|j*|j+|j,|j-|j.|j/||j0|j1S)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. )2generated_operationsaltered_indexesaltered_constraintsrZ concrete_appsold_appsrZappsnew_appssetold_model_keysold_proxy_keysold_unmanaged_keysnew_model_keysnew_proxy_keysnew_unmanaged_keysr get_model_metamanagedaddZ real_appsproxygenerate_renamed_models_prepare_field_lists_generate_through_model_mapgenerate_deleted_modelsgenerate_created_modelsgenerate_deleted_proxiesgenerate_created_proxiesgenerate_altered_optionsgenerate_altered_managerscreate_altered_indexescreate_altered_constraintsgenerate_removed_constraintsgenerate_removed_indexesgenerate_renamed_fieldsgenerate_removed_fieldsgenerate_added_fieldsgenerate_altered_fields&generate_altered_order_with_respect_to generate_altered_unique_togethergenerate_altered_index_togethergenerate_added_indexesgenerate_added_constraintsgenerate_altered_db_table_sort_migrations_build_migration_list_optimize_migrations migrations)rrralmnrrrrresn       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|]8\}}jj|jj||f|fjD]}|||fq,qSr)rrrenamed_modelsgetr<)r app_label model_name field_name)rrrrsz=MigrationAutodetector._prepare_field_lists..cs2h|]*\}}jj||fjD]}|||fqqSr)rrr<)rrprqrr)rrrrsN) rFrIkept_model_keysrGrJkept_proxy_keysrHrKkept_unmanaged_keys through_usersold_field_keysnew_field_keys)rr)rrrRs   z*MigrationAutodetector._prepare_field_listscCsxt|jD]\}}|jj||f|}|jj||f}xr|jD]h}|jj||j j |}t |dr>t |j ddr>|j jj j r>|j jj j|j jj jf}|||f|j|<q>Wq WdS)zThrough model map generation.r:throughN)r9rFrnrorrr<rCrLrM get_fieldr3getattrr:ry auto_createdrprqrv)rrprqold_model_nameold_model_staterr old_fieldZ through_keyrrrrSs  z1MigrationAutodetector._generate_through_model_mapcCsH|ddkr|dfStt|djd\}}||jf|dddfS) zp Return the resolved dependency and a boolean denoting whether or not it was swappable. r __setting__Fr'.r7NT)r{rsplitlower) dependencyZresolved_app_labelZresolved_object_namerrr_resolve_dependencys z)MigrationAutodetector._resolve_dependencycCsi|_tdd|jjD}d}x\|rxt|jD]}g}t}xPt|j|D]<}d}t} x|jD]} | } |j| \} } | d|krvx,|jj | dgD]} |j | | rd}PqW|sPqv| r| j | d| dfqv| d|jkr| j | d|j| ddj fqv|rh|rT|j | drT| j |j | ddn| j | ddfqvd}qvW|r|j||j| |j|d=q\Pq\W|s|r:|j| s|r&tdtfggd }|d t|jj |gd|}t||_||_||jk|_|jj|gj|d}q:||j||j|<q:Wtd d|jjD}||krz|sld}ntd |j|}q&Wd S)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). css|]}t|VqdS)N)len)rxrrrr#sz>MigrationAutodetector._build_migration_list..FTrr' __first__r)r dependencieszauto_%icss|]}t|VqdS)N)r)rrrrrr#Gsz)Cannot resolve operation dependencies: %rN)rksumr@valuesr9rEr) _auto_depsrrocheck_dependencyrOr= leaf_nodesr;updater2rrrrrinitial setdefault ValueError)rrZnum_opsZ chop_moderpZchoppedr operationZdeps_satisfiedZoperation_dependenciesdepZ original_depZis_swappable_depZother_operationsubclassinstanceZ new_num_opsrrrrisd    $       z+MigrationAutodetector._build_migration_listcCsxt|jjD]\}}dd|D}x^|D]V}xP|jD]F}|j|d}|d|kr8x&|D]}|j||r\||j|q\Wq8Wq,Wt|||j|<qWdS)z{ Reorder to make things possible. Reordering may be needed so FKs work nicely inside the same app. cSsi|] }t|qSr)rE)roprrrr%Vsz:MigrationAutodetector._sort_migrations..rN)r9r@r,rrrrOr )rrpopsZdependency_graphrrZop2rrrrhOs     z&MigrationAutodetector._sort_migrationscCsxH|jjD]:\}}x0t||ddD]\}}|jj||jfq(Wq Wx0|jjD]"}x|D]}tt|j|_q`WqVWx6|jjD](\}}x|D]}t j |j ||_ qWqWdS)Nr') rkr,ziprr;r=rr)rEroptimizer)rrprkm1m2 migrationrrrrjds  z*MigrationAutodetector._optimize_migrationscs<ddkr6ddkr6t|tjo4|jdjkSddk rddkrt|tjr|jdjkrtfdd|jDpt|tjo|jdjko|jdjkSddk oʈddkrt|tj o|jdjko|jdjkSddkr>ddkr>t|tj o<|jdjkSddk rdd krt|tj o|jdjko|jdjkSddk rdd krt|tj o|jdjko|j pd jdjkSddk r*dd kr*t|tjtjfo(|jdjkStd fdS)zn Return True if the given operation depends on the given dependency, False otherwise. r7NTr'c3s|]\}}d|kVqdS)r7Nr)rry)rrrr#sz9MigrationAutodetector.check_dependency..Falterorder_wrt_unsetfoo_together_changezCan't handle dependency %r)r(r CreateModel name_lowerranyr<AddFieldZmodel_name_lower RemoveField DeleteModel AlterFieldAlterOrderWithRespectToorder_with_respect_toAlterUniqueTogetherAlterIndexTogetherr)rrrr)rrrts<    z&MigrationAutodetector.check_dependencyFcCs>|pg|_|r&|jj|gjd|n|jj|gj|dS)Nr)rr@rinsertr;)rrprr beginningrrr add_operations z#MigrationAutodetector.add_operationc Csy|jj|d|d}dd|jD}d|d|df}|jjsfd|ksfd|ksftjj|jkr~d|dd|dfSWntk rYnX|S) z| Place potential swappable models first in lists of created models (only real way to solve #22783). rr'cSsg|] }|jqSr)__name__)rbaserrrr"sz=MigrationAutodetector.swappable_first_key..z%s.%sZ AbstractUserZAbstractBaseUserZ___) rDrL __bases__rMZ swappablerZAUTH_USER_MODELr LookupError)ritemrZ base_namesZstring_versionrrrswappable_first_keysz)MigrationAutodetector.swappable_first_keycCs\i|_i|_|j|j}xZrenamed_models_rel_keyrrrrQsD     z-MigrationAutodetector.generate_renamed_modelsc sH|j|jB}|j|}|j|}tt||jddt||jdd}x|D]\|jjf}|j j j }id}xd|j D]Z}|j r|j jr|jr|j j}n|j js||j<t|j ddr|j jj j r||j<qWxH|jD]>}|j jr||j<t|j ddr|j jj j r||j<qW|jjd} |jjd} |jjdd} |jjdd} |jjd d} dd fg}x|jD]}t|trd |kr|jd d \}}|j||ddf|jjj||f}|jjj||f}|r|rt|j j!|j j"|j }x |D]}|j|||d fqWqW|rR|j|j j#|j j$ddf|j%t&j'|jfd d|j j(D|j|j|j)d|dd|j*sqJxZtj(D]J\}}|j+|}|jddf|j%t&j,||dt-t|dqW| r*|j%t&j.| d| dfddfgdfddtD}|jddfx(| D] }|j%t&j/|d|dqZWx(| D] }|j%t&j0|d|dqW| r|j%t&j1| d|d| r|j%t&j2| d|df|j3krJxH|j4D]>}|j%|j5j j#t&j6|j5j j$|j7j|j7dddfgdqWqJWdS)a 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, index_together). T)r$reverseNryindexes constraintsunique_togetherindex_togetherrFrr'csg|]}|dkr|qS)rr)rd)related_fieldsrrr"KszAMigrationAutodetector.generate_created_models..)r=r<optionsbasesmanagers)rr)rqr=r>)r)r=rcsg|]}|dfqS)Tr)rr=)rprqrrr"us)rqindex)rq constraint)r=r)r=r)8rFrHrIrKrr9rrrrDrLrM local_fieldsr:rZ primary_keyZ parent_linkr=r{ryr|local_many_to_manyrpoprr(strrr;rrorEr< difference intersectionrp object_namerrrr,rrNrrr)rAddIndex AddConstraintrrrGrelated_objects related_modelrr>)rZold_keysrZadded_unmanaged_modelsZall_added_modelsrrZprimary_key_relr>rrrrrrrbase_app_label base_nameZold_base_model_stateZnew_base_model_stateZremoved_base_fieldsZremoved_base_fieldr=Zrelated_dependenciesrrrelated_objectr)rprqrrrUs                      z-MigrationAutodetector.generate_created_modelsc Cs|j|j}xt|D]\}}|jj||f}|jjds>t||ddfg}xB|jD]8}t |t rTd|krT|j dd\}}|j ||ddfqTW|j |tj|jg|j|j|jd|dqWdS) 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. rPNFrr'T)r=r<rrr)r)rJrGr9rrrroAssertionErrorrr(rrr;rrrr=r) raddedrprqrrrrrrrrrWs$  z.MigrationAutodetector.generate_created_proxiescCsd|j|jB}|j|}|j|}tt|t|}x*|D] \}}|jj||f}|jj ||}i} xN|j j D]B} | j rp| j j r| | | j<t| j ddrp| j jj j rp| | | j<qpWxH|j jD]<} | j j r| | | j<t| j ddr| j jj j r| | | j<qW|jjdd} |jjdd} | r8|j|tj|dd| rT|j|tj|ddx(t| D]} |j|tj|| dq^Wg}xZ|j jD]N}|jj j}|jj j}|jj}|j|||df|j s|j|||d fqWx$t| D]} |j||| dfqW|j!j"||j#f}|r:|j|d |d |d df|j|tj$|jd t%t&|dq:WdS)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(). ryNrr)r=r)r=r)rqr=Frrr'r7)r=)r)'rIrKrFrHrr9rrrCrLrMrr:rr=r{ryr|rrrrrrrrrrrprr>r; many_to_manyrvrorrr)rE)rZnew_keysZdeleted_modelsZdeleted_unmanaged_modelsZall_deleted_modelsrprqrrrr>rrr=rrZrelated_object_app_labelrrrZ through_userrrrrTst         z-MigrationAutodetector.generate_deleted_modelscCs\|j|j}xJt|D]>\}}|jj||f}|jjds>t|j|t j |j dqWdS)z*Make DeleteModel options for proxy models.rP)r=N) rGrJr9rrrrorrrrr=)rZdeletedrprqrrrrrV%s z.MigrationAutodetector.generate_deleted_proxiesc Csi|_xt|j|jD]\}}}|jj||f|}|jj||f}|jj ||j j |}|j |}x6t|j|jD] \}} } ||ko| |kr||j | } |j | } |jr|jjrd| dkr| dd} | |jkr|j| | dd<| j| | jd}| |ks>| dd|ddkr|t| d|d|dkr||jj|| ||r||j|tj|| |d|jj|| | f|jj|||f| |j|||f<Pq|WqWdS)zWork out renamed fields.r8r7r'r)Z db_column)rqrrN)renamed_fieldsr9rxrwrnrorrrDrLrMrzr r<r:rrZset_attributes_from_nameZget_attname_columnr+rZ ask_renamerrZ RenameFieldrrO)rrprqrrr}r~r>Z field_decrrZrem_field_namer old_field_decZ old_rel_toZ old_db_columnrrrr^2s<           z-MigrationAutodetector.generate_renamed_fieldscCs2x,t|j|jD]\}}}|j|||qWdS)zMake AddField operations.N)r9rxrw_generate_added_field)rrprqrrrrrr`Xsz+MigrationAutodetector.generate_added_fieldscCs|jj||jj|}g}|jr8|jjr8|j|j|tj tj tj f}|j pv|j pv|jpv|jrh|jpvt||ov|j}|s|j}t||r|jr|jj|||_n|jj|||_|j|tj||||d|ddS)N)rqr=r>preserve_default)r)rDrLrMrzr:rrrrZ DateFieldZ DateTimeFieldZ TimeFieldnull has_defaultrZblankZempty_strings_allowedr(Zauto_nowcloneZ auto_now_addrZask_auto_now_add_additiondefaultZask_not_null_additionrrr)rrprqrrr>rZ time_fieldsrrrrr]s* z+MigrationAutodetector._generate_added_fieldcCs2x,t|j|jD]\}}}|j|||qWdS)zMake RemoveField operations.N)r9rwrx_generate_removed_field)rrprqrrrrrr_|sz-MigrationAutodetector.generate_removed_fieldscCs2|j|tj||d|||df|||dfgddS)N)rqr=rr)r)rrr)rrprqrrrrrrs z-MigrationAutodetector._generate_removed_fieldc sxtjj@D]t\}}}jj||f|}jj|||f|}jj||jj |}j j||jj |}g}t |dot |j ddr\|j jjj|j jjjfjkr|j j|j _t |j dd} | r| f} | jkr|j j|j _|j j|j _t |dd} | rL||ftfdd| D|_tfdd|jD|_|jj|t |drt |j d dr|j jjj|j jjjfjkr|j j|j _j|} j|} | | kr|jo|j}|j o|j }|s|rnd }|jrJ|j rJ|j rJ|j rJ|j}jj||}|tj k rN||_!d }n|}j"|t#j$||||d |d qj%|||j&|||qWdS)zp Make AlterField operations, or possibly RemovedField/AddField if alter isn's possible. r:rNrr from_fieldscs g|]}jj|f|qSr)rro)rZ from_field)from_rename_keyrrrr"szAMigrationAutodetector.generate_altered_fields..cs g|]}jj|f|qSr)rro)rZto_field) rename_keyrrrr"sryTF)rqr=r>r)r)'r9rwrxrnrorrCrLrMrzrDr3r{r:rrprqrrr*rZ to_fieldsrrryr rrrrrZask_not_null_alterationrZ NOT_PROVIDEDrrrrrr)rrprqrrr}Zold_field_namerZ new_fieldrZremote_field_nameZto_field_rename_keyrrZ new_field_decZboth_m2mZ neither_m2mrr>Z new_defaultr)rrrrrasr                     z-MigrationAutodetector.generate_altered_fieldsc stjj}xt|jD]\}}|jj||f|}|jj||f}|j j||f}|j ||j |fddD}fddD}|j j ||f||diqWdS)Ncsg|]}|kr|qSrr)ridx) old_indexesrrr"sz@MigrationAutodetector.create_altered_indexes..csg|]}|kr|qSrr)rr) new_indexesrrr"s) added_indexesremoved_indexes) rr option_namer9rsrnrorrrrrAr) rrrprqr}r~new_model_stateZadd_idxZrem_idxr)rrrrZs  z,MigrationAutodetector.create_altered_indexescCsHxB|jjD]4\\}}}x&|dD]}|j|tj||dq"Wq WdS)Nr)rqr)rAr,rrr)rrprq alt_indexesrrrrresz,MigrationAutodetector.generate_added_indexescCsJxD|jjD]6\\}}}x(|dD]}|j|tj||jdq"Wq WdS)Nr)rqr=)rAr,rrZ RemoveIndexr=)rrprqrrrrrr]sz.MigrationAutodetector.generate_removed_indexesc stjj}xt|jD]\}}|jj||f|}|jj||f}|j j||f}|j ||j |fddD}fddD}|j j ||f||diqWdS)Ncsg|]}|kr|qSrr)rc)old_constraintsrrr"szDMigrationAutodetector.create_altered_constraints..csg|]}|kr|qSrr)rr)new_constraintsrrr"s)added_constraintsremoved_constraints) rrrr9rsrnrorrrrrBr) rrrprqr}r~rZadd_constraintsZrem_constraintsr)rrrr[ s  z0MigrationAutodetector.create_altered_constraintscCsHxB|jjD]4\\}}}x&|dD]}|j|tj||dq"Wq WdS)Nr)rqr)rBr,rrr)rrprqalt_constraintsrrrrrfsz0MigrationAutodetector.generate_added_constraintscCsJxD|jjD]6\\}}}x(|dD]}|j|tj||jdq"Wq WdS)Nr)rqr=)rBr,rrZRemoveConstraintr=)rrprqrrrrrr\)sz2MigrationAutodetector.generate_removed_constraintscCst|dd}|dk rd}|}n|jjjj}|jjjj}||ddfg}t|jddr|jjjj r|j|jjjj|jjjjddf|S)Nswappable_settingrTry) r{r:rrMrprryr|r;)rr>r dep_app_labelZdep_object_namerrrrr4s     z7MigrationAutodetector._get_dependencies_for_foreign_keyc s |j}xtjD]\jjf}jj|f}jjf}|jj|}|rvfdd|Dnt }|jj|}|rt |nt }||krg}xN|D]F} x@| D]8} j j j j | } | jr| jjr|jj| qWqWj|fdi||i|dqWdS)Ncs&h|]}tfdd|DqS)c3s"|]}jj|f|VqdS)N)rro)rn)rprqrrrr#RszQMigrationAutodetector._generate_altered_foo_together...)r*)runique)rprqrrrrPszGMigrationAutodetector._generate_altered_foo_together..r=)r)rr9rsrnrorrrrrErDrLrMrzr:rrrr) rrrr}r~r old_value new_valuerZ foo_togethersrrr>r)rprqrr_generate_altered_foo_togetherGs,      z4MigrationAutodetector._generate_altered_foo_togethercCs|jtjdS)N)rrr)rrrrrclsz6MigrationAutodetector.generate_altered_unique_togethercCs|jtjdS)N)rrr)rrrrrdosz5MigrationAutodetector.generate_altered_index_togetherc Cs|jj|j|j}x|t|D]p\}}|jj||f|}|jj||f}|j j||f}|j jd}|j jd}||kr|j |t j ||dqWdS)NZdb_table)r=table)rsunionrtrur9rnrorrrrrrZAlterModelTable) rmodels_to_checkrprqr}r~rZold_db_table_nameZnew_db_table_namerrrrgrs  z/MigrationAutodetector.generate_altered_db_tablec Cs|jj|j|j|j|j@|j|j@}xt|D]\}}|j j ||f|}|j j ||f}|j j ||f}dd|jjD}dd|jjD}||kr0|j|tj||dq0WdS)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). cSs i|]\}}|tjkr||qSr)rALTER_OPTION_KEYS)rr$r!rrrr%szBMigrationAutodetector.generate_altered_options..cSs i|]\}}|tjkr||qSr)rr)rr$r!rrrr%s)r=rN)rsrrtrurHrIrFrKr9rnrorrrrr,rrr) rrrprqr}r~rZ old_options new_optionsrrrrXs& z.MigrationAutodetector.generate_altered_optionscCsxt|jD]\}}|jj||f|}|jj||f}|jj||f}|jjd|jjdkr g}|jjdr|j|||jddf|j |t j ||jjdd|dq WdS)NrT)r=r)r) r9rsrnrorrrrr;rrr)rrprqr}r~rrrrrrbs&  z.) rr)r,rZ ask_initialr= parse_number enumeraterr;Z suggest_namejoinr)rrrrZleavesrprkZapp_leafZleafrZ next_numberiZnew_name_partsrr)r rrsF          "z'MigrationAutodetector.arrange_for_graphc sixJ|jD]>\}}x4|D],}x&|jD]\}}j|tj|q(WqWqWt|}d} x,| |krt|} |jfdd|Dq^Wxt|D]}||kr||=qW|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|]}j|fqSr)ro)rrp)app_dependenciesrrr"sz7MigrationAutodetector._trim_to_apps..)r,rrrErOrr)) rrZ app_labelsrprkrrr=Z required_appsZold_required_appsr)rrrs    z#MigrationAutodetector._trim_to_appscCs tjd|}|rt|dSdS)z Given a migration name, try to extract a number from the beginning of it. If no number is found, return None. z^\d+rN)rematchint)clsr=rrrrr s  z"MigrationAutodetector.parse_number)N)NNN)NN)N)NF)N)0r __module__ __qualname____doc__rrr r?rrRrS staticmethodrrirhrjrrrrQrUrWrTrVr^r`rr_rrarZrer]r[rfr\rrrcrdrgrXrbrYrr classmethodr rrrrr sX   ( a W? ./!Y &S    %$ 2r )r-r itertoolsrZ django.confrZ django.dbrZdjango.db.migrationsrZdjango.db.migrations.migrationrZ&django.db.migrations.operations.modelsrZdjango.db.migrations.optimizerrZdjango.db.migrations.questionerr Zdjango.db.migrations.utilsr r Zdjango.utils.topological_sortr r rrrrs