Mh_dZddlmZddlmZmZmZddlmZdZ ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlmZmZddlmZGd d Zgd Zd Zd ZdZdZdZdefdefdefgZeddfgdZGddZ gdZ!d dZ"eddfdZ#eGddeZ$dZ%dS)!a IPython extension to reload modules before executing user code. ``autoreload`` reloads modules automatically before entering the execution of code typed at the IPython prompt. This makes for example the following workflow possible: .. sourcecode:: ipython In [1]: %load_ext autoreload In [2]: %autoreload 2 In [3]: from foo import some_function In [4]: some_function() Out[4]: 42 In [5]: # open foo.py in an editor and change some_function to return 43 In [6]: some_function() Out[6]: 43 The module was reloaded without reloading it explicitly, and the object imported with ``from foo import ...`` was also updated. Usage ===== The following magic commands are provided: ``%autoreload``, ``%autoreload now`` Reload all modules (except those excluded by ``%aimport``) automatically now. ``%autoreload 0``, ``%autoreload off`` Disable automatic reloading. ``%autoreload 1``, ``%autoreload explicit`` Reload all modules imported with ``%aimport`` every time before executing the Python code typed. ``%autoreload 2``, ``%autoreload all`` Reload all modules (except those excluded by ``%aimport``) every time before executing the Python code typed. ``%autoreload 3``, ``%autoreload complete`` Same as 2/all, but also adds any new objects in the module. See unit test at IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects Adding ``--print`` or ``-p`` to the ``%autoreload`` line will print autoreload activity to standard out. ``--log`` or ``-l`` will do it to the log at INFO level; both can be used simultaneously. ``%aimport`` List modules which are to be automatically imported or not to be imported. ``%aimport foo`` Import module 'foo' and mark it to be autoreloaded for ``%autoreload 1`` ``%aimport foo, bar`` Import modules 'foo', 'bar' and mark them to be autoreloaded for ``%autoreload 1`` ``%aimport -foo`` Mark module 'foo' to not be autoreloaded. Caveats ======= Reloading Python modules in a reliable way is in general difficult, and unexpected things may occur. ``%autoreload`` tries to work around common pitfalls by replacing function code objects and parts of classes previously in the module with new versions. This makes the following things to work: - Functions and classes imported via 'from xxx import foo' are upgraded to new versions when 'xxx' is reloaded. - Methods and properties of classes are upgraded on reload, so that calling 'c.foo()' on an object 'c' created before the reload causes the new code for 'foo' to be executed. Some of the known remaining caveats are: - Replacing code objects does not always succeed: changing a @property in a class to an ordinary method or a method to a member variable can cause problems (but in old objects only). - Functions that are removed (eg. via monkey-patching) from a module before it is reloaded are not upgraded. - C extension modules cannot be reloaded, and so cannot be autoreloaded. - While comparing Enum and Flag, the 'is' Identity Operator is used (even in the case '==' has been used (Similar to the 'None' keyword)). - Reloading a module, or importing the same module by a different name, creates new Enums. These may look the same, but are not. )magic_arguments)Magics magics_class line_magic)DeduperReloaderTN) import_modulereload)source_from_cachecHeZdZdZ dZ dZ d dZdZdZdZ dZ d d Z dS) ModuleReloaderFTNci|_i|_i|_i|_i|_||_d|_t|_| ddd|_ dS)NcdSNmsgs ]/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/IPython/extensions/autoreload.pyz)ModuleReloader.__init__..s4TF) check_all do_reload) failedmodules skip_modules old_objectsmodules_mtimesshell_reportrdeduper_reloadercheck hide_errors)selfrs r__init__zModuleReloader.__init__ss    (' !0 1 1 TU 333!rcN |j|=n#t$rYnwxYwd|j|<dS)z-Skip reloading the named module in the futureTN)rKeyErrorrr" module_names rmark_module_skippedz"ModuleReloader.mark_module_skippedsG  [))    D )-+&&&  cN |j|=n#t$rYnwxYwd|j|<dS)z9Reload the named module in the future (if it is imported)TN)rr%rr&s rmark_module_reloadablez%ModuleReloader.mark_module_reloadablesG !+..    D $( [!!!r)c||t||dd}tj|}||fS)zImport a module, and mark it reloadable Returns ------- top_module : module The imported module if it is top-level, or the top-level top_name : module Name of top_module .r)r+rsplitsysr)r"r'top_name top_modules raimport_modulezModuleReloader.aimport_modulesU ##K000k"""$$S))!,[* 8##rct|dr|jdSt|dddvrdS|j}tj|\}}|dkr|}n" t|}n#t$rYdSwxYw tj |j }n#t$rYdSwxYw||fS)N__file__)NN__name__)N __mp_main____main__z.py) hasattrr4getattrospathsplitextlowerr ValueErrorstatst_mtimeOSError)r"modulefilenamer;ext py_filenamepymtimes rfilename_and_mtimez!ModuleReloader.filename_and_mtimesvz** fo.E: 6:t , ,0Q Q Q:?G$$X.. c 99;;%  "KK "/99  " " "!zz " gk**3GG   :: G##s$4B BBB00 B>=B>c |js|sdS|s|jr,ttj}n&t|j}|D]}tj|d}||jvr-||\}}|H ||j |kr[ |j |d|kr|n#t$r ||j |<YwxYw||j |<|r| d|d |j r"t|t|j|jn6|j|rnt|t|j||j vr|j |=/#|jsAt+d|t/jdtj||j |<YxYw|jdS)z/Check whether some modules need to be reloaded.Nz Reloading 'z'.z[autoreload of {} failed: {}] )file)enabledrlistr/rkeysgetrrGrrr%r autoload_obj superreloadr rrrmaybe_reload_moduler!printformat traceback format_excstderrupdate_sources)r"rrrmodnamemrErFs rr zModuleReloader.checksg| I  F  0 03;++--..GG4<,,..//G+ 7+ 7G ..A$+++#'#:#:1#=#= K" d1':::; ;??;55@@A    /6#G, ,3D  ( 7 676667777(A#Avt/?LLLL.BB1EEA#Avt/?@@@"dk11 K 47+;BB ')=b)A)A"%  07DK ,,,) 7* ,,.....s 2C&&C=<C=&A0FAG/r)FT) r5 __module__ __qualname__rKrrOr#r(r+r2rGr rrrr r sG*IDL=!!!!2...)))$$$$$$$47/7/7/7/7/7/rr )__code__ __defaults____doc__ __closure__ __globals____dict__c tD]9} t||t||##ttf$rY6wxYwdS)z%Upgrade the code object of a functionN) func_attrssetattrr9AttributeError TypeError)oldnewnames rupdate_functionrj9sd  CwsD11 2 2 2 2 *    D s +??ctj|}|D]/}t||urt|d|0dS)zUse garbage collector to find all instances that refer to the old class definition and update their __class__ to point to the new class definition __class__N)gc get_referrerstypeobject __setattr__)rgrhrefsrefs rupdate_instancesrtBsW  C D66 99     sK 5 5 566rc t|jD]}t||} t||}||kdur,nD#t$r, t ||n#tt f$rYnwxYwYbt$rYnwxYwt||r t||t||#tt f$rYwxYwt|jD]b}|t|jvr8 t||t||K#tt f$rY^wxYwct||dS)zjReplace stuff in the __dict__ of a class, and upgrade method code objects, and add new methods, if anyTN) rLrarMr9redelattrrfr>update_genericrdrt)rgrhkeyold_objnew_objs r update_classr{NsCL%%''((#s## c3''G7"t++,    S!!!!"I.     H    D  '7 + +    Cgc3// 0 0 0 0 *    D CL%%''(( d3<,,..// / / S'#s"3"34444"I.     0S#s_A BA0/B0BBBB BB*C  CC2EE&%E&ct|j|jt|j|jt|j|jdS)z+Replace get/set/del functions of a propertyN)rwfdelfgetfset)rgrhs rupdate_propertyrxsD38SX&&&38SX&&&38SX&&&&&rcBt||ot||Sr) isinstance)abtyps r isinstance2rs! a   4*Q"4"44rc.t||tSr)rrorrs rrrs+aD))rc8t||tjSr)rtypes FunctionTypers rrrs+aE$677rc.t||tSr)rpropertyrs rrrs+aH--rc8t||tjSr)rr MethodTypers rrrsQ5+;<<rc6t|j|jSr)rj__func__rs rrrsQZ@@rcVtD] \}}|||r|||dS!dS)NTF) UPDATE_RULES)rr type_checkupdates rrwrwsL* F :a    F1aLLL44  5rceZdZdZdZdS) StrongRefc||_dSrobj)r"rs rr#zStrongRef.__init__s rc|jSrr)r"s r__call__zStrongRef.__call__s xrN)r5rZr[r#rrrrrrs2rr)r5r^ __package__ __loader____spec__r4 __cached__ __builtins__Fct|do|j|jk}|r|s |tvrdSn|sdS|j|f} ||gt j|n#t$rYnwxYwdS)NrZFT) r8rZr5 mod_attrs setdefaultappendweakrefrsrf)rBdrirautoload in_modulerxs r append_objrs\**Ps~/PI TY..5 5 ?D !C  S"$$W[%5%56666      4s;A;; BBc|i}t|jD]m\}}t||||s|j|f} ||gtj|^#t$rYjwxYw |j }|j}|j ||jd<|d|jd<n#tttf$rYnwxYw ||}n #|j|xYwt|jD]\}} |j|f}||vr&||dkst|||| ds.| |j|<g} ||D]4} | } | | | t!| | 5| r| ||<||=|S)a2Enhanced version of the builtin reload function. superreload remembers objects previously in the module, and - upgrades the class dictionary of every old class in the module - upgrades the code object of every old function and method - clears the module's namespace before reloading Nr5rEnumT)rLraitemsrr5rrrrsrfcopyclearrer%ruser_nsrw) rBr rrrirrxold_dictold_namerznew_refsold_refrys rrPrPsV &///1122 c&+tS99  %   " "3 + + 2 27;s3C3C D D D D    D  ?''))?&. #(0(> %% ~x 0     x((( fo335566!! g% k ! ! 6>>!&+tWdKK"")EM$ "3' - -GgiiG OOG $ $ $ 7G , , , ,  !'K  C  Ms1 ;B  BBAC..DD DD5c eZdZfdZeejejdedddejddd d d ejd dd d d ejdd d d ejdd d d ddZeddZ dZ dZ xZ S)AutoreloadMagicsctj|i|t|j|_d|j_d|j_ttj |_ dS)NF) superr#r r _reloaderrrOsetr/rloaded_modules)r"rkwrls rr#zAutoreloadMagics.__init__ s\!"r"""' 33#( &+#!#+..rmodenow?ablank or 'now' - Reload all modules (except those excluded by %%aimport) automatically now. '0' or 'off' - Disable automatic reloading. '1' or 'explicit' - Reload only modules imported with %%aimport every time before executing the Python code typed. '2' or 'all' - Reload all modules (except those excluded by %%aimport) every time before executing the Python code typed. '3' or 'complete' - Same as 2/all, but also adds any new objects in the module. By default, a newer autoreload algorithm that diffs the module's source code with the previous version and only reloads changed parts is applied for modes 2 and below. To use the original algorithm, add the `-` suffix to the mode, e.g. '%autoreload 2-', or pass in --full. )rodefaultnargshelpz-pz--print store_trueFz1Show autoreload activity using `print` statements)actionrrz-lz--logz)Show autoreload activity using the loggerz --hide-errorszHide autoreload errorsz--fullz$Don't ever use new diffing algorithmctj|j|}|j}|j }|dr d}|dd}||jj_ ttj d}|j fd}|j dur|jdurd|j_nA|j dur#|jdur ||j_n"|j_n|jdur |j_|j|j_|d ks|d kr|jddS|d ks|d krd|j_ dS|d ks|dkr&d|j_ d|j_d|j_dS|dks|dkr&d|j_ d|j_d|j_dS|dks|dkr&d|j_ d|j_d|j_dSt)d|d)a* %autoreload => Reload modules automatically %autoreload or %autoreload now Reload all modules (except those excluded by %aimport) automatically now. %autoreload 0 or %autoreload off Disable automatic reloading. %autoreload 1 or %autoreload explicit Reload only modules imported with %aimport every time before executing the Python code typed. %autoreload 2 or %autoreload all Reload all modules (except those excluded by %aimport) every time before executing the Python code typed. %autoreload 3 or %autoreload complete Same as 2/all, but also but also adds any new objects in the module. See unit test at IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects The optional arguments --print and --log control display of autoreload activity. The default is to act silently; --print (or -p) will print out the names of modules that are being reloaded, and --log (or -l) outputs them to the log at INFO level. The optional argument --hide-errors hides any errors that can happen when trying to reload code. Reloading Python modules in a reliable way is in general difficult, and unexpected things may occur. %autoreload tries to work around common pitfalls by replacing function code objects and parts of classes previously in the module with new versions. This makes the following things to work: - Functions and classes imported via 'from xxx import foo' are upgraded to new versions when 'xxx' is reloaded. - Methods and properties of classes are upgraded on reload, so that calling 'c.foo()' on an object 'c' created before the reload causes the new code for 'foo' to be executed. Some of the known remaining caveats are: - Replacing code objects does not always succeed: changing a @property in a class to an ordinary method or a method to a member variable can cause problems (but in old objects only). - Functions that are removed (eg. via monkey-patching) from a module before it is reloaded are not upgraded. - C extension modules cannot be reloaded, and so cannot be autoreloaded. -FN autoreloadc4||dSrr)rlps rplz'AutoreloadMagics.autoreload..pls! AcFFF AcFFFFFrcdSrrrs rrz-AutoreloadMagics.autoreload..srTrr0off1explicit2all3completezUnrecognized autoreload mode "z".)rparse_argstringrrr=fullendswithrrrKrRlogging getLoggerinfologrr!r rrOr>) r"lineargsrenable_deduperreloadloggerrrrs @@rrzAutoreloadMagics.autoreloads2X.tEEy  #'9} ==   #( 9D2F'/ "<00 K       :  48u#4#4%5%5DN " " Z4  x4)+&&)*&& X  %&DN "%)%5" 2:: N  & & & & & S[[DEMM%*DN " " " S[[DJ..%)DN "',DN $*/DN ' ' ' S[[DEMM%)DN "'+DN $*/DN ' ' ' S[[DJ..%)DN "'+DN $*.DN ' ' 'FdFFFGG GrNc|}|st|jj}t|jj}| t j}|jjr|dn+|dd |z|dd |zdSd| dDD]}| dr7|d d }|j |N|j|\}}|j||idS) a"%aimport => Import modules for automatic reloading. %aimport List modules to automatically import and not to import. %aimport foo Import module 'foo' and mark it to be autoreloaded for %autoreload explicit %aimport foo, bar Import modules 'foo', 'bar' and mark them to be autoreloaded for %autoreload explicit %aimport -foo, bar Mark module 'foo' to not be autoreloaded for %autoreload explicit, all, or complete, and 'bar' to be autoreloaded for mode explicit. Nz&Modules to reload: all-except-skipped zModules to reload: %s  z Modules to skip: %s c6g|]}|Sr)strip).0_s r z,AutoreloadMagics.aimport..s BBB!AGGIIBBBr,r)sortedrrrMrr/stdoutrwritejoinr. startswithrr(r2rpush) r" parameter_sstreamrX to_reloadto_skip_moduler1r0s raimportzAutoreloadMagics.aimports~" <t~5::<<==IT^8==??@@G~~' O GHHHH 7#((9:M:MMNNN LL3chhw6G6GG H H H H HBBw}}S/A/ABBB < <%%c**<%abbk//11GN66w????+/>+H+H+Q+Q(JJOOXz$:;;;; < !  $$&&&&&    s).cttj|jz }|D]@}|jtj|\}}|||jj|<A|j|dS)zFCache the modification times of any modules imported in this executionN)rr/rrrrGrr)r"newly_loaded_modulesrXrrFs rpost_execute_hookz"AutoreloadMagics.post_execute_hooks"3;//$2EE+ A AG::3;w;OPPJAw"9@-g6 ""#788888r)r)rN) r5rZr[r#rrargumentstrrrrr __classcell__)rls@rrr s/////$_$&&_  2_  @ _  8 _ %  _ 3  gHgHgH  3'&ZjgHR$<$<$<Z$rsiiV)(((((??????????JJJJJJ$   ++++++++,,,,,,V/V/V/V/V/V/V/V/|  6 6 6'''T'''555 *)<877I--?   = < @ @     $ &4tCCCCV\9\9\9\9\9v\9\9\9~FFFFFr