^h[dSrSSKJr SSKJrJrJr SrSSKrSSK r SSK r SSK r SSK r SSK r SSKrSSKJrJr SSKJr "SS 5r/S QrS rS rS rSrSrS\4S\4S\4/r\R9SS4/5 Sr"SS5r/SQrSSjr \SS4Sjr!\"SS\55r"Sr#g)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_cachecR\rSrSrSrSrSrS SjrSrSr Sr S r S S jr S r g)ModuleReloaderFTNc0Ul0Ul0Ul0Ul0UlXlSUlURSSS9 SUlg)NcgNmsgs W/home/james-whalen/.local/lib/python3.13/site-packages/IPython/extensions/autoreload.py)ModuleReloader.__init__..s4TF) check_all do_reload) failedmodules skip_modules old_objectsmodules_mtimesshell_reportcheck hide_errors)selfrs r__init__ModuleReloader.__init__sR    (  TU 3!rc^URU SURU'g![a Nf=f)z-Skip reloading the named module in the futureTN)rKeyErrorrr" module_names rmark_module_skipped"ModuleReloader.mark_module_skippeds9  [)*.+&     ,,c^URU SURU'g![a Nf=f)z9Reload the named module in the future (if it is imported)TN)rr&rr's rmark_module_reloadable%ModuleReloader.mark_module_reloadables9 !!+.%) [!   r+cURU5 [U5 URS5Sn[RUnX24$)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_moduleModuleReloader.aimport_modulesF ##K0k"$$S)!,[[* ##rc[US5(a URcg[USS5S;agURn[RR U5up4UR 5S:XaUnO [U5n[R"U5RnXV4$![a gf=f![a gf=f)N__file__)NN__name__)N __mp_main____main__z.py) hasattrr8getattrospathsplitextlowerr ValueErrorstatst_mtimeOSError)r"modulefilenamer?ext py_filenamepymtimes rfilename_and_mtime!ModuleReloader.filename_and_mtimesvz**foo.E 6:t ,0Q Q??GG$$X.  99;% "K "/9  ggk*33G## "! "   s$7 B& B6& B32B36 CCc \UR(dU(dgU(dUR(a([[RR 55nO#[URR 55nUGH%n[RR US5nX@R;aM5URU5upgUcMMXpRU::aMbURR US5U:XaMXpRU'U(dMURSUS35 UR(a'[U[UR UR"5 O[U[UR 5 X`R;aURU GM%GM( g![a XpRU'GMGf=f! UR$(d<['SR)U[*R,"S55[R.S9 XpRU'GM=f)z/Check whether some modules need to be reloaded.Nz Reloading 'z'.z[autoreload of {} failed: {}] )file)enabledrlistr2rkeysgetrrKrrr&r autoload_obj superreloadrrrr!printformat traceback format_excstderr)r"rrrmodnamemrIrJs rr ModuleReloader.checks||I  3;;++-.G4<<,,./GG .A+++#'#:#:1#= K" 11'::; ;;??;5@A,3   (y {7)2677((#Avt/?/?L#Avt/?/?@"kk1 KK 42= /6##G, &7++;BB ')=)=b)A"%  07KK ,s F*2A/G *GG AH+)rrr!rrrrrr)FT)r9 __module__ __qualname____firstlineno__rPrrTr#r)r-r5rKr __static_attributes__rrrr r s8G*IDL=!,.)$$$437rr )__code__ __defaults____doc__ __closure__ __globals____dict__c x[Hn[X[X55 M g![[4a M1f=f)z%Upgrade the code object of a functionN) func_attrssetattrr=AttributeError TypeError)oldnewnames rupdate_functionrp1s9  Cws1 2 *   s %99c[R"U5nUH*n[U5ULdM[R USU5 M, g)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__)rmrnrefsrefs rupdate_instancesrz:s<   C D 9    sK 5rc [URR55HMn[X5n[X5nX4:HSLaM#[UW5(aM7[X[X55 MO [URR55HBnU[URR55;dM,[X[X55 MD [X5 g![a' [ X5 O![[ 4a Of=fM[a Nf=f![[ 4a GMf=f![[ 4a Mf=f)zfReplace stuff in the __dict__ of a class, and upgrade method code objects, and add new methods, if anyTN) rQrgrRr=rkdelattrrlrBupdate_genericrjrz)rmrnkeyold_objnew_objs r update_classrFs?CLL%%'(## c'G"t+, '7 + +   Cgc/ 01)8CLL%%'( d3<<,,./ / '#"34)S9  !"I.       *   #I.  s_C*D)E* D&5 DD&DD&DD& D&%D&)D>=D>EEc[URUR5 [URUR5 [URUR5 g)z+Replace get/set/del functions of a propertyN)r}fdelfgetfset)rmrns rupdate_propertyrps8388SXX&388SXX&388SXX&rc<[X5=(a [X5$r) isinstance)abtyps r isinstance2rws a  4*Q"44rc"[X[5$r)rrurrs rrr|s +aD)rc6[X[R5$r)rtypes FunctionTypers rrr}s+aE$6$67rc"[X[5$r)rpropertyrs rrr~s +aH-rc6[X[R5$r)rr MethodTypers rrrsQ5+;+; %foo3356 %  ! 6>!&tdKK")MM$ "'GiG OOG $ 7 , ( '  /72 M_    ~x 0   x( s15F# A F5+G# F21F25G  G G.c :^\rSrSrU4Sjr\\R "5\R"S\SSSS9\R"SS S S S S 9\R"SSS S SS 9\R"SS S SS 9SSj555555r \SSj5r Sr Sr Sr U=r$)AutoreloadMagicsic>[TU]"U0UD6 [UR5UlSURlSURl[[R5Ul g)NF) superr#r r _reloaderrrTsetr2rloaded_modules)r"rkwrrs rr#AutoreloadMagics.__init__sN !"r"' 3#( &+#!#++.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. )rudefaultnargshelpz-pz--print store_trueFz1Show autoreload activity using `print` statements)actionrrz-lz--logz)Show autoreload activity using the loggerz --hide-errorszHide autoreload errorsc^^^[R"URU5nURR 5n[ m[ R"S5nURmUU4SjnUR SLa"URSLaSURl OaUR SLa2URSLaXPRl O2TURl O URSLaTURl URURl US:XdUS:XaURRS5 gUS:XdUS :XaSURlgUS :XdUS :Xa4SURlSURlSURlgUS :XdUS :Xa4SURlSURlSURlgUS:XdUS:Xa4SURlSURlSURlg[#SUS35e)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. autoreloadc&>T"U5 T"U5 grr)rlps rpl'AutoreloadMagics.autoreload..plvs cF cFrFcgrrrs rr-AutoreloadMagics.autoreload..{srTr0off1explicit2all3completezUnrecognized autoreload mode "z".N)rparse_argstringrrrArVlogging getLoggerinfologrrr!r rPrrTrB)r"lineargsrloggerrrrs @@rrAutoreloadMagics.autoreload sB..tEyy  ""<0 KK  :: 488u#4%5DNN " ZZ4 xx4)+&)*& XX %&DNN "%)%5%5" 2: NN  & S[DEM%*DNN " S[DJ.%)DNN "',DNN $*/DNN ' S[DEM%)DNN "'+DNN $*/DNN ' S[DJ.%)DNN "'+DNN $*.DNN '=dV2FG GrcLUnU(d[URRR55n[URRR55nUc[ R nURR(aURS5 O#URSSRU5-5 URSSRU5-5 gURS5Vs/sHofR5PM snHnURS5(a0USSR5nURRU5 MIURRU5upURR!X05 M gs snf) 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 ,-)sortedrrrRrr2stdoutrwritejoinr1strip startswithr)r5rpush) r" parameter_sstreamr[ to_reloadto_skip__moduler4r3s raimportAutoreloadMagics.aimports3"t~~55::<=IT^^88==?@G~~~'' GH 7#((9:MMN LL3chhw6GG H/6}}S/AB/A!GGI/AB%%c**%abk//1GNN66w?+/>>+H+H+Q(JJJOOX$:;CBs>F!cURR(aURR5 gg! g=fr)rrPr )r"rs r pre_run_cellAutoreloadMagics.pre_run_cells3 >> ! ! $$& " s9=c.[[R5UR- nUHNnURR [RU5up4UcM6X@RR U'MP URRU5 g)zFCache the modification times of any modules imported in this executionN)rr2rrrrKrr)r"newly_loaded_modulesr[rrJs rpost_execute_hook"AutoreloadMagics.post_execute_hookst"3;;/$2E2EE+G::3;;w;OPJA"9@--g6, ""#78r)rr)r)rN)r9r^r_r`r#rrargumentstrrrrrra __classcell__)rrs@rrrs/$$&   (  @   8  %  aH )'TaHF$<$r2rXrrrsr importlibrrimportlib.utilr r rirprzrrrrextendr}rrrrUrrrrrrsiV)??$   +,O7O7n  6'T'5 *<87I-?   = @   $ &4tCVK9vK9K9\Fr