jYdZddlmZddlmZmZmZdZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZmZddlmZGdd Zgd Zd Zd Zd ZdZdZdefdefdefgZeddfgdZGddZgdZddZ 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_magicTN) import_modulereload)source_from_cachecHeZdZdZ dZ dZ d dZdZdZdZ dZ d d Z dS) ModuleReloaderFTNci|_i|_i|_i|_i|_||_d|_|dddS)NcdSNmsgs j/var/www/finuniver-perm.ru/html/student/venv/lib/python3.11/site-packages/IPython/extensions/autoreload.pyz)ModuleReloader.__init__..s4TF) check_all do_reload)failedmodules skip_modules old_objectsmodules_mtimesshell_reportcheck)selfrs r__init__zModuleReloader.__init__sY    ('  TU 33333rcN |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)rr$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) hasattrr1getattrospathsplitextlowerr ValueErrorstatst_mtimeOSError)rmodulefilenamer8ext 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]g}tj|d}||jvr-||\}}|H ||j |kr[ |j |d|kr|n#t$r ||j |<YwxYw||j |<|r| d|d |j r"t|t|j|jnt|t|j||j vr|j |=#t%d|t)jdtj||j |<YdxYwidS)z/Check whether some modules need to be reloaded.Nz Reloading 'z'.z[autoreload of {} failed: {}] )file)enabledrlistr,rkeysgetrrDrrr"r autoload_obj superreloadrrrprintformat traceback format_excstderr)rrrrmodnamemrBrCs rrzModuleReloader.checks,| I  F  0 03;++--..GG4<,,..//G' 7' 7G ..A$+++#'#:#:1#=#= K" d1':::; ;??;55@@A    /6#G, ,3D  ( 7 676667777(A#Avt/?LLLL#Avt/?@@@"dk11 K 477>>#Y%9"%=%=!Z  07DK ,,,! 7/' 7' 7s 2C&&C=<C=&AE==A G r)FT) r2 __module__ __qualname__rHrrLr r%r(r/rDrrrrr r sG*IDL=4444&...)))$$$$$$$4272727272727rr )__code__ __defaults____doc__ __closure__ __globals____dict__c tD]9} t||t||##ttf$rY6wxYwdS)z%Upgrade the code object of a functionN) func_attrssetattrr6AttributeError TypeError)oldnewnames rupdate_functionre-sd  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__)rbrcrefsrefs rupdate_instancesro6sW  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) rIr\rJr6r`delattrrar;update_genericr_ro)rbrckeyold_objnew_objs r update_classrvBsCL%%''((#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)rrfdelfgetfset)rbrcs rupdate_propertyr{lsD38SX&&&38SX&&&38SX&&&&&rcBt||ot||Sr) isinstance)abtyps r isinstance2rss! a   4*Q"4"44rc.t||tSr)rrjr~rs rrrxs+aD))rc8t||tjSr)rtypes FunctionTypers rrrys+aE$677rc.t||tSr)rpropertyrs rrrzs+aH--rc8t||tjSr)rr MethodTypers rrrsQ5+;<<rc6t|j|jSr)re__func__rs rrrsQZ@@rcVtD] \}}|||r|||dS!dS)NTF) UPDATE_RULES)r~r type_checkupdates rrrrrsL* F :a    F1aLLL44  5rceZdZdZdZdS) StrongRefc||_dSrobj)rrs rr zStrongRef.__init__s rc|jSrrrs r__call__zStrongRef.__call__s xrN)r2rUrVr rrrrrrs2rr)r2rY __package__ __loader____spec__r1 __cached__ __builtins__Fct|do|j|jk}|r|s |tvrdSn|sdS|j|f} ||gt j|n#t$rYnwxYwdS)NrUFT) r5rUr2 mod_attrs setdefaultappendweakrefrnra)r?drdrautoload in_modulerss 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 Nr2rEnumT)rIr\itemsrr2rrrrnracopyclearr`r"ruser_nsrr) r?rrrrdrrsold_dictold_namerunew_refsold_refrts rrMrMsV &///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 ddZeddZ dZ dZ xZ S)AutoreloadMagicsctj|i|t|j|_d|j_d|j_ttj |_ dS)NF) superr r r _reloaderrrLsetr,rloaded_modules)rr~kwrgs rr zAutoreloadMagics.__init__s\!"r"""' 33#( &+#!#+..rmodenow?aGblank 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 but also adds any new objects in the module. )rjdefaultnargshelpz-pz--print store_trueFz1Show autoreload activity using `print` statements)actionrrz-lz--logz)Show autoreload activity using the loggercTtj|j|}|j}t t jd}|jfd}|jdur|j durd|j _ nA|jdur#|j dur ||j _ n"|j _ n|j dur |j _ |dks|dkr|j ddS|dks|d krd|j _ dS|d ks|d kr&d|j _ d|j _d|j _dS|d ks|d kr&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. 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. autoreloadc4||dSrr)rlps rplz'AutoreloadMagics.autoreload..plis! AcFFF AcFFFFFrFcdSrrrs rrz-AutoreloadMagics.autoreload..nsrTrr0off1explicit2all3completezUnrecognized autoreload mode "z".N)rparse_argstringrrr:rNlogging getLoggerinfologrrrrHrrLr;)rlineargsrloggerrrrs @@rrzAutoreloadMagics.autoreloadsp.tEEy   "<00 K       :  48u#4#4%5%5DN " " Z4  x4)+&&)*&& X  %&DN " 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,-)sortedrrrJrr,stdoutrwritejoinr+ startswithrr%r/rpush) r parameter_sstreamrS to_reloadto_skip_moduler.r-s 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,rrrrDrr)rnewly_loaded_modulesrSrrCs rpost_execute_hookz"AutoreloadMagics.post_execute_hooks"3;//$2EE+ A AG::3;w;OPPJAw"9@-g6 ""#788888r)r)rN) r2rUrVr rrargumentstrrrrr __classcell__)rgs@rrrsM/////$_$&&_   (_  @ _  8 \H\H\H)'&ZH\H|$<$<$<Z$rs}iiV)(((((??????????$   ++++++++,,,,,,K7K7K7K7K7K7K7K7f  6 6 6'''T'''555 *)<877I--?   = < @ @     $ &4tCCCCV@9@9@9@9@9v@9@9@9FFFFFFr