NXc@@sdZddlmZmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlmZddlmZddlmZddlmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd l m!Z!m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(m)Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddl<m=Z=m>Z>m?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZIddlJmKZKdd lLmMZMdd!lNmOZOdd"lPmQZQdd#lPmZdd$lPmRZRdd%lPmSZSdd&lTmUZUdd'lVmWZWdd(lXmYZYdd)lZm[Z[dd*l\m]Z]m^Z^m_Z_m`Z`dd+lambZbmcZcdd,ldmeZemfZfmgZgmhZhmiZidd-ljmkZkdd.llmmZmdd/lnmoZompZpmqZqmrZrdd0lsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}dd1l~mZmZddlZe jd2ZeUd3ZeUd4ZeUd5efd6YZeZd7efd8YZeUd9fd:YZd;Zd<e{fd=YZd>efd?YZeUd@efdAYZdBefdCYZdDefdEYZdFehejefdGYZejedS(HsMain IPython class.i(tabsolute_importtprint_functionN(topen(t PickleShareDB(tSingletonConfigurable(tdebuggertoinspect(tmagic(tpage(t prefilter(tshadowns(tultratb(tAliast AliasManager(t ExitAutocall(t BuiltinTrap(t EventManagertavailable_events(tCachingCompilertcheck_linecache_ipython(t DisplayTrap(t DisplayHook(tDisplayPublisher(t InputRejectedt UsageError(tExtensionManager(tDisplayFormatter(tHistoryManager(tIPythonInputSplittert ESC_MAGICt ESC_MAGIC2(tLogger(tMacro(tPayloadManager(tPrefilterManager(t ProfileDir(t PromptManager(tdefault_banner(t skip_doctest(t PyColorize(tio(t py3compat(topenpy(tundoc(t ask_yes_no(tStruct(tget_ipython_dir(t get_home_dirtget_py_filenametunquote_filenametensure_dir_exists(tsystemt getoutput(t builtin_modt unicode_typet string_typestwith_metaclasst iteritems(t StrDispatch(tprepended_to_syspath(t format_screentLSStringtSListtDollarFormatter( tIntegertBooltCBooltCaselessStrEnumtEnumtListtDicttUnicodetInstancetType(twarnterrors^\s+raise|^\s+return|^\s+passcC@sRd}y |j}Wntk r&nXy ||_Wnttfk rMnX|S(s-Copied from code.py, to remove the dependencyi(t softspacetAttributeErrort TypeError(tfiletnewvaluetoldvalue((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRL]s   cO@sdS(N((tatkw((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytno_opmst NoOpContextcB@seZdZdZRS(cC@sdS(N((tself((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt __enter__rscC@sdS(N((RVttypetvaluet traceback((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt__exit__ss(t__name__t __module__RWR[(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRUps t SpaceInInputcB@seZRS((R\R](((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR^vstBunchcB@seZRS((R\R](((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR_xscC@s.tjdkrdStjdkr&dSdSdS(NtdarwintLightBGtnttLinux(tsystplatformtostname(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytget_default_colors|s tSeparateUnicodecB@seZdZdZRS(sA Unicode subclass to validate separate_in, separate_out, etc. This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``. cC@s@|dkrd}n|jdd}tt|j||S(Nt0ts\ns (treplacetsuperRitvalidate(RVtobjRY((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRns (R\R]t__doc__Rn(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRistReadlineNoRecordcB@s>eZdZdZdZdZdZddZRS(sContext manager to execute some code, then reload readline history so that interactive input to the code doesn't appear when pressing up.cC@s||_d|_dS(Ni(tshellt _nested_level(RVRr((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt__init__s cC@st|jdkray"|j|_|j|_Wqattfk r]dg|_|_qaXn|jd7_dS(Nii?Bi(Rstcurrent_lengtht orig_lengthtget_readline_tailt readline_tailRMt IndexError(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRWscC@s|jd8_|jdkry|j|j}|dkrpx-t|D]}|jjj|jqMWn|j|jks|j|jkr|jj nWqt t fk rqXnt S(Nii( RsRuRvtrangeRrtreadlinetremove_history_itemRwRxtrefill_readline_histRMRytFalse(RVRXRYRZtet_((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR[s cC@s|jjjS(N(RrR{tget_current_history_length(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRusi cC@s^|jjjd}t||d}|jjj}gt||D]}||^qHS(s)Get the last n items in readline history.i(RrR{Rtmaxtget_history_itemRz(RVtntendtstarttghitx((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRws(R\R]RpRtRWR[RuRw(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRqs    tDummyModcB@seZdZRS(stA dummy module used for IPython's interactive module when a namespace must be assigned to the module's __dict__.(R\R]Rp(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRstExecutionResultcB@s>eZdZdZdZdZdZedZ dZ RS(smThe result of a call to :meth:`InteractiveShell.run_cell` Stores information about what took place. cC@s|jdko|jdkS(N(terror_before_exectNonet error_in_exec(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytsuccessscC@s:|jdk r|jn|jdk r6|jndS(s>Reraises error if `success` is `False`, otherwise does nothingN(RRR(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt raise_errors N( R\R]RpRtexecution_countRRtresulttpropertyRR(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRstInteractiveShellc B@s eZdZdZegdeddZeddddeddZ e ededd Z e ededd Z e ededd Ze d dedd ZeddeddZe ededdZeddededdZe eddZe edeZe ededdZe ededdZeedeZee Z!ee"Z#dZ$e eZ%ee&Z'dZ(edZ)e dZ*e d deZ+eddied6Z,eddied6Z-e ededdZ.e d deddZ/e d deddZ0eddddeZ1e ededd Z2e e3j4d!kdedd"Z5e6ededd#Z7e d$dedd%Z8e d&dedd'Z9e d(dedd)Z:e ededd*Z;d+Z<e<Z=e<Z>e<Z?e<Z@e ededd,ZAe edeZBed-deZCeddedd.ZDe edeZEe d/deZFe ZGed0d1d2d3d4d5d6d7d8d9d:d;g deZHeZId<ZJed=d>d?d@gdd?deddAZKeLdBdeZMeLd deZNeLd deZOe edeZPedddCdeZQedFdeZRedGdeZSedHdeZTedIdeZUedJdeZVedKdeZWedLdeZXedMdeZYedNdeZZe[dOZ\e]Z^dZ_ddddddPZ`dQZadRZbddSZcdTZddUZedVZfdWZgdXZhdYZidZZjd[Zkd\Zld]Zmd^Znd_Zod`ZpdaZqdbZrdcZsddZtdeZudfZvdgZwdhZxe[diZyddjZzdkZ{dlddedmZ|dnZ}doZ~dpZdqZdrZdsZdtZduZe[eeddvZedwZeZdddxZe[dyZdddzZd{Zd|Ze[d}Zed~ZedZddZedZdZddZedZddZddZddZddZdZdZdZdZddZdZddZdddedZdZddZdZdZdZeedZdZdZdZdddZddZdZddZdZejejjdddZdZdZdZdZddZdZdZdZdZeZeddZdZdZdZdZdZdZdZdZdZdZdZeedZdZdZeeedZdZd?eddZddZeZddZddZdeedZdedZdddZdZdZddZdZedZeeeedZdZdZRS(s*An enhanced, interactive shell for Python.tconfigthelps A list of ast.NodeTransformer subclass instances, which will be applied to user input before code is run. iiit default_values Make IPython automatically call any callable object even if you didn't type explicit parentheses. For example, 'str 43' becomes 'str(43)' automatically. The value can be '0' to disable the feature, '1' for 'smart' autocall, where it is not applied if there are no more arguments on the line, and '2' for 'full' autocall, where all callable objects are automatically called (even if no arguments are present). s@ Autoindent IPython code entered interactively. sK Enable magic commands to be called without the leading %. s7The part of the banner to be printed before the profileRks6The part of the banner to be printed after the profileis Set the size of the output cache. The default is 1000, you can change it permanently in your config file. Setting it to 0 completely disables the caching system, and the minimum value accepted is 20 (if you provide a value less than 20, it is reset to 0 and a warning is issued). This limit is defined because otherwise you'll spend more time re-flushing a too small cache than working s Use colors for displaying information about objects. Because this information is passed through a pager (like 'less'), and some pagers get confused with color codes, this capability can be turned off. tNoColorRaRcs2Set the color scheme (NoColor, Linux, or LightBG).sd Force use of ANSI color codes, regardless of OS and readline availability. s **Deprecated** Enable deep (recursive) reloading by default. IPython can use the deep_reload module which reloads changes in modules recursively (it replaces the reload() function, so you don't need to change anything to use it). `deep_reload` forces a full reload of modules whose code may have changed, which the default reload() function does not. When deep_reload is off, IPython will use the normal reload(), but deep_reload will still be available as dreload(). s?Don't call post-execute functions that have failed in the past.t allow_nonecC@s t|S(N(R(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt_exiter_default<sss/IPython.core.inputsplitter.IPythonInputSplittertline_input_checkers Start logging to the default log file in overwrite mode. Use `logappend` to specify a log file to **append** logs to. s1 The name of the logfile to use. s Start logging to the given file in append mode. Use `logfile` to specify a log file to **overwrite** logs to. sL Automatically call the pdb debugger after every exception. twin32s8Save multi-line entries as one entry in readline historyshIf True, anything that would be passed to the pager will be displayed as regular output instead.s In [\#]: s)Deprecated, use PromptManager.in_templates .\D.: s*Deprecated, use PromptManager.in2_templates Out[\#]: s*Deprecated, use PromptManager.out_templates%Deprecated, use PromptManager.justifycC@sridd6dd6dd6dd6}td jd |d |||jdk rnt|jj|||ndS( Nt in_templatet prompt_in1t in2_templatet prompt_in2t out_templatet prompt_outtjustifytprompts_pad_leftsBInteractiveShell.{name} is deprecated, use PromptManager.{newname}Rgtnewname(RJtformatRRtsetattrR$(RVRgtoldtnewttable((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt_prompt_trait_changedxs  s(Show rewritten input, e.g. for autocall.i'so The number of saved history entries to be loaded into the readline buffer at startup. s-/~s tab: completes"\C-l": clear-screensset show-all-if-ambiguous ons"\C-o": tab-inserts"\C-r": reverse-search-historys"\C-s": forward-search-historys"\C-p": history-search-backwards"\C-n": history-search-forwards"\e[A": history-search-backwards"\e[B": history-search-forwards"\C-k": kill-lines"\C-u": unix-line-discardcC@s t|_dS(N(tTruet_custom_readline_config(RVRgRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt _readline_parse_and_bind_changedstalltlastt last_exprtnones 'all', 'last', 'last_expr' or 'none', specifying which nodes should be run interactively (displaying output from expressions).s tContexttPlaintVerbosesIPython.core.alias.AliasManagers'IPython.core.prefilter.PrefilterManagers%IPython.core.builtin_trap.BuiltinTraps%IPython.core.display_trap.DisplayTraps(IPython.core.extensions.ExtensionManagers#IPython.core.payload.PayloadManagers(IPython.core.history.HistoryAccessorBases IPython.core.magic.MagicsManagers#IPython.core.application.ProfileDircC@s;|jdk r7tjj|jj}|jddSdS(Ntprofile_Rk(t profile_dirRRftpathtbasenametlocationRl(RVRg((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytprofilescK@stt|j||g|_|j||j||j|j|j|j |||j |j t t jj|jjd|_|j|j|j|j|j|j|j|j|j|j|j|jtj r/t!|_"n t#|_"|j$|j%|j&||j'|j(|j)|j*|j+|j,|j-|j.|j/|j0|j1|j2|j3j4|j5j6d|t7j8|j9dS(Ntdbtshell_initialized(:RmRRtt configurablestinit_ipython_dirtinit_profile_dirtinit_instance_attrstinit_environmenttinit_virtualenvtinit_create_namespacestsave_sys_module_statetinit_sys_modulesRRfRtjoinRRRt init_historyt init_encodingtinit_prefiltertinit_syntax_highlightingt init_hookst init_eventstinit_pushd_popd_magict init_user_nst init_loggert init_builtinstinit_inspectort init_readlineR)tPY3tinputtraw_input_originalt raw_inputtinit_completertinit_iotinit_traceback_handlerst init_promptstinit_display_formattertinit_display_pubt init_data_pubtinit_displayhookt init_magicst init_aliast init_logstarttinit_pdbtinit_extension_managert init_payloadtinit_deprecation_warningsthookstlate_startup_hookteventsttriggertatexittregistertatexit_operations(RVt ipython_dirRt user_moduletuser_nstcustom_exceptionstkwargs((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRtsX        $                               cC@s|S(s.Return the currently running IPython instance.((RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt get_ipython5scC@st|dS(N(R2(RVRgR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt_ipython_dir_changed=scC@sh|dkr?|j r?tjdkr2tdnd|_dS|dkr[|j |_n ||_dS(srSet the autoindent flag, checking for readline support. If called with no arguments, it acts as a toggle.itposixs5The auto-indent feature requires the readline libraryN(t has_readlineRfRgRJt autoindentR(RVRY((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytset_autoindent@s   cC@s)|dk r||_dSt|_dS(N(RRR.(RVR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRSs  cC@s5|dk r||_dStj|jd|_dS(Ntdefault(RRR#tcreate_profile_dir_by_nameR(RVR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRZs  cC@sat|_t|_t|_g|_g|_t|_t j |_ d|_ i|_ dS(Ni(R~tmoreRtcompileR-tmetat tempfilesttempdirsRR)tgetcwdt starting_dirtindent_current_nspt _post_execute(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRas       cC@sdS(s6Any changes we need to make to the user's environment.N((RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRscC@s:ytjjpd|_Wntk r5d|_nXdS(Ntascii(Rdtstdintencodingtstdin_encodingRM(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs c@s(tjjfd_dS(Nc@s|djS(Ntstr(tcolors(tsrc(RVtpyformat(sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyts(R'tParserRt pycolorize(RV((RVR sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRscC@st|_g|_dS(N(R/thome_dirt dir_stack(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs cC@s"t|jdddd|_dS(Ntlogfnamesipython_log.pytlogmodetrotate(RRtlogger(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRscC@s]|jr |jd|jn9|jr@|jd|jn|jrY|jdndS(sIInitialize logging in case it was requested at the command line. slogstart %s appends logstart %stlogstartN(t logappendRtlogfileR(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs    cC@s)tjddtd|jjddS(s register default filter for deprecation warning. This will allow deprecation warning of function used interactively to show warning to users, and still hide deprecation warning from libraries import. RtcategorytmoduleR\N(twarningstfilterwarningstDeprecationWarningRtget(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRscC@s0ttjdsslAttempting to work in a virtualenv. If you encounter problems, please install IPython inside the virtualenv.RtLibs site-packagestlibs python%d.%dii(RftenvironRtnormcaseRdt executabletislinkRtdirnametreadlinkR-tanyRJRet version_infotsitetinsertt addsitedir(RVR>tpathst virtual_envRJ((R?sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs$  6 " cC@swi|_tj|jds   cC@s)|dkr|j}n|j|dS(N(RRYtwrite(RVRY((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt show_bannerGs  cC@st|_i|_tjj}x3|jD](}|j|t||ddtq+W|j r|jdt j t j dndS(Nidt_warn_deprecatedt show_in_pageriZ( R-RtstrdispatcherstIPythontcoret__all__tset_hooktgetattrR~t display_pageRtas_hook(RVRt hook_name((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRPs   & i2c C@stj||}|dk rZ|jj|t}|j|||||j| sets an internal IPython hook. IPython exposes some of its internal API as user-modifiable hooks. By adding your function to one of these hooks, you can modify IPython's behavior to call at runtime your own routines.Ns#Warning! Hook '%s' is not one of %ss&Hook {} is deprecated. Use {} instead.(ttypest MethodTypeRR^RR:tadd_stadd_retreRRcRR_R`Ratprintt deprecatedRJRtCommandChainDispatchertaddRMR( RVRgR7tprioritytstr_keytre_keyR\tftsdptdpt alternative((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRb`s2       cC@s,t|t|_|jjd|jdS(Nt pre_execute(RRRRt_clear_warning_registry(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRscC@s!td|jjd|dS(sDEPRECATED: Use ip.events.register('post_run_cell', func) Register a function for calling after code execution. s^ip.register_post_execute is deprecated, use ip.events.register('post_run_cell', func) instead.t post_run_cellN(RJRR(RVtfunc((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytregister_post_executes cC@s d|jkr|jd=ndS(Nt__warningregistry__(tuser_global_ns(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRxscC@stjj|}y|j|}Wn:tk r_tjtj|dd}|j| 0 Out[17]: True In [18]: _ip.clear_main_mod_cache() In [19]: len(_ip._main_mod_cache) == 0 Out[19]: True N(RR(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytclear_main_mod_cachescC@s|j|_dS(N(tpdbtcall_pdb(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRscC@s|jS(N(t _call_pdb(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt _get_call_pdbscC@s@|ddttfkr'tdn||_||j_dS(Niis"new call_pdb value must be boolean(R~Rt ValueErrorRt InteractiveTBR(RVtval((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt _set_call_pdbs s,Control auto-activation of pdb at exceptionsc@sv|p jsdSttds0tddStjrLddlm}nfd}j |WdQXdS(s?Call the pydb/pdb debugger. Keywords: - force(False): by default, this routine checks the instance call_pdb flag and does not actually invoke the debugger if the flag is false. The 'force' option forces the debugger to activate even if the flag is false. Ntlast_tracebacks1No traceback has been produced, nothing to debug.i(tpmc@sjjdtS(Ntforce(RRR((RV(sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR s( RthasattrRdRKRthas_pydbtpydbRtreadline_no_record(RVRR((RVsU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs    cC@s|dk s|dk r$t|_n|j||\|_|_i|_i|_i|jjd6|jd6t jd6|_ dS(Nt user_globalt user_localtbuiltin( RR~tdefault_user_namespacestprepare_user_moduleRRtuser_ns_hiddenRRR5tns_table(RVRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR"s%    cC@s |jjS(N(RR(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR}pscC@s|dkr=|dk r=|jddt}||_n|dkratjddd}n|jjdt|jjdt|dkr|j}n||fS(sPrepare the module and namespace in which user code will be run. When IPython is started normally, both parameters are None: a new module is created automatically, and its __dict__ used as the namespace. If only user_module is provided, its __dict__ is used as the namespace. If only user_ns is provided, a dummy module is created, and user_ns becomes the global namespace. If both are provided (as they may be when embedding), user_ns is the local namespace, and user_module provides the global namespace. Parameters ---------- user_module : module, optional The current user module in which IPython is being run. If None, a clean module will be created. user_ns : dict, optional A namespace in which to run interactive commands. Returns ------- A tuple of user_module and user_ns, each properly initialised. R\t__main__R~s@Automatically created module for IPython interactive environmentt __builtin__t __builtins__N(Rt setdefaultRRRgRR5(RVRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRts       cC@s |jj}|jtj||jjn|j|jk r`|jjn|j}t |j }|j d|j d|j dx|D] }||=qW|j j|j |jj|jj|jdS(sClear all internal namespaces, and attempt to release references to user objects. If new_session is True, a new history session will be opened. iRRR\N(RtresetRR9t do_full_cachetflushRR}RtsettkeystdiscardRRt alias_managert clear_aliasest init_aliasesR(RVt new_sessionRt drop_keysRT((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs&            c C@sF|d krtd|n|j}|rax|D]%}y ||=Wq5tk rYq5Xq5Wny|j|}Wn!tk rtd|nX|j|jjxW|D]O}gt|D]\}}||kr|^q}x|D] } || =qWqWx<d D]4} t |j | |kr t |j | dq q WdS( sDelete a variable from the various namespaces, so that, as far as possible, we're not keeping any hidden references to it. Parameters ---------- varname : str The name of the variable to delete. by_name : bool If True, delete variables with the given name in each namespace. If False (default), find the variable in the user namespace, and delete references to it. RRsRefusing to delete %ssname '%s' is not definedRt__t___N(s __builtin__s __builtins__(Rs__R( RRRRt NameErrorR-RRR9RcR9RR( RVtvarnametby_nametns_refsRRoRtot to_deleteRg((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytdel_var$s*        1  cC@s|dk rytj|}Wntk r>tdnXx>|jD]0}x'|D]}|j|rV||=qVqVWqIWndS(sDClear selective variables from internal namespaces based on a specified regular expression. Parameters ---------- regex : string or compiled pattern, optional A regular expression pattern that will be used in searching variable names in the users namespaces. s*regex must be a string or compiled patternN(RRkRRNRtsearch(RVtregexRRtvar((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytreset_selectiveMs   cC@s(d}t|tr|}nt|tttfrt|trU|j}n|}i}tjd}xa|D]J}y t ||j |j || dict with keys: found,obj,ospace,ismagic Has special code to detect magic functions. tdottedtfoundt InteractivesInteractive (global)sPython builtinRlRot namespacetismagictisaliasR+t.iisIPython internals''s""s[]s{}s()N(s''s""s[]s{}s()(tstripR<RRR)t isidentifierRRR~RRR}R5RRRtcompiler_flagst __future__tCO_FUTURE_PRINT_FUNCTIONRRt enumeratetlent_getattr_propertyRctlstriptfind_cell_magictfind_line_magicRR R(RVtonamet namespacestalias_nsRRotospacetdsRRR+t oname_partst oname_headt oname_resttnsnameRtidxtpart((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt_ofindsz           cC@s_t|tsRytt||}Wntk r;qRXt|trR|Snt||S(sProperty-aware getattr to use in object finding. If attrname represents a property, return it unevaluated (in case it has side effects or raises an error. (RRXRcRMR(Rotattrnametattr((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR s cC@st|j||S(s6Find an object and return a struct with info about it.(R-R(RVRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt _object_find2scK@s|j||}|jrt|j|}|jr<tnd}|dkrd||j||q|dkr||j||||q||j|ntd|dSdS(spGeneric interface to the inspector system. This function is meant to be called by pdef, pdoc & friends.tpdoctpinfosObject `%s` not found.s not foundN( RRRcR%RR<RRoRl(RVtmethRRRStinfotpmethodt formatter((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt_inspect6s   c C@sd|jU|j|}|jrD|jj|j|d|d|Stjd|dtSWdQXdS(sGet object info about onameRt detail_levelRgRN( R RRR%RRoRt object_infoR~(RVRR R((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytobject_inspectHs   c C@sZ|jK|j|}|jrD|jj|j|d|d|St|WdQXdS(s!Get object info as formatted textRR N(R RRR%t _format_infoRoR(RVRR R((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytobject_inspect_textSs   cC@s/td|d||_|jj|jdS(s:Sets up the command history, and starts regular autosaves.RrR+N(RRRR-(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRbsc C@sotjdd|_tjdddddddt|_tj|_|j||jj d|j dS(Nt color_schemeRtmodeRt tb_offsetit check_cache( R tSyntaxTBtAutoFormattedTBRRRdROtsys_excepthooktset_custom_exctset_modetxmode(RVR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRks   c@st|tdks$tddd}ddkrN|}ndfd}tj|||_||_dS(sset_custom_exc(exc_tuple,handler) Set a custom exception handler, which will be called if any of the exceptions in exc_tuple occur in the mainloop (specifically, in the run_code() method). Parameters ---------- exc_tuple : tuple of exception classes A *tuple* of exception classes, for which to call the defined handler. It is very important that you use a tuple, and NOT A LIST here, because of the way Python's except statement works. If you only want to trap a single exception, use a singleton tuple:: exc_tuple == (MyCustomException,) handler : callable handler must have the following signature:: def my_handler(self, etype, value, tb, tb_offset=None): ... return structured_traceback Your handler must return a structured traceback (a list of strings), or None. This will be made into an instance method (via types.MethodType) of IPython itself, and it will be called if any of the exceptions listed in the exc_tuple are caught. If the handler is None, an internal basic one is used, which just prints basic info. To protect IPython from crashes, if your handler ever raises an exception or returns an invalid result, it will be immediately disabled. WARNING: by putting in your own exception handler into IPython's main execution loop, you run a very good chance of nasty crashes. This facility should only be used if you really know what you are doing.s/The custom exceptions must be given AS A TUPLE.cS@s5tdtd|td|td|dS(Ns'*** Simple custom exception handler ***sException type :sException value:sTraceback :(Rl(RVtetypeRYttbR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt dummy_handlers   cS@sd|}|dkrgSt|tr0|gSt|tsNt|nx,|D]$}t|tsUt|qUqUW|S(sWvalidate structured traceback return type return type of CustomTB *should* be a list of strings, but allow single strings or None, which are harmless. This function will *always* return a list of strings, and will raise a TypeError if stb is inappropriate. s,CustomTB must return list of strings, not %rN(RRR7RRN(tstbtmsgtline((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt validate_stbs   c@sy)||||d|}|SWn|jddtddtj|jjtj}t|jj |dtj tddtj |jj|||fd|}nX|S(swrap CustomTB handler, to protect IPython from user code This makes it harder (but not impossible) for custom exception handlers to crash IPython. Rs'Custom TB Handler failed, unregisteringROsThe original exception:(N( RRRlR(R*Rtstructured_tracebackRdtexc_infotstb2textR)(RVRRYRRR(thandlerR!(sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytwrappeds N((RXtAssertionErrorRRgRhtCustomTBR(RVt exc_tupleR%RR&((R%R!sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs)     cC@s |j|||fdddS(s2One more defense for GUI apps that call sys.excepthook. GUI frameworks like wxPython trap exceptions and call sys.excepthook themselves. I guess this is a feature that enables them to keep running after exceptions that would otherwise kill their mainloop. This is a bother for IPython which excepts to catch all of the program exceptions with a try: except: statement. Normally, IPython sets sys.excepthook to a CrashHandler instance, so if any app directly invokes sys.excepthook, it will look to the user like IPython crashed. In order to work around this, we can disable the CrashHandler and replace it with this excepthook instead, which prints a regular traceback using our InteractiveTB. In this fashion, apps which call sys.excepthook will generate a regular-looking exception from IPython, and the CrashHandler will only be triggered by real IPython crashes. This hook should be used sparingly, only in places which are not likely to be true IPython errors. RiN(t showtraceback(RVRRYR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyROscC@s|dkr$tj\}}}n|\}}}|dkrqttdrqtjtjtj}}}qqn|dkrtdn|t_|t_|t_|||fS(s get exc_info from a given tuple, sys.exc_info() or sys.last_type etc. Ensures sys.last_type,value,traceback hold the exc_info we found, from whichever source. raises ValueError if none of these contain any information t last_typesNo exception to findN(RRdR#RR+t last_valueRR(RVR)RRYR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt _get_exc_infos       cC@s|jd|dS(s|Show a short message for UsageErrors These are special exceptions that shouldn't show a traceback. sUsageError: %sN(t write_err(RVtexc((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytshow_usage_error scC@s7|j|\}}}tj||}dj|S(s} Return as a string (ending with a newline) the exception that just occurred, without any traceback. Rk(R-RZtformat_exception_onlyR(RVR)RRYRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytget_exception_only'sc C@sby3y|j|\}}}Wntk r@|jddSXt|tr`|j|n|tkr||j|n|rdg}|j|j j ||nuy|j }Wn/t k r|j j |||d|}nX|j||||jr|jdtndS|j|||Wn(tk r]|jd|j nXdS(sDisplay the exception that just occurred. If nothing is known about the exception, this is the method which should be used throughout the code for presenting user tracebacks, rather than directly invoking the InteractiveTB object. A specific showsyntaxerror() also exists, but this method can take care of calling it if needed, so unless you are explicitly catching a SyntaxError exception, don't try to analyze the stack manually and simply call this method.s No traceback available to show. Ns>An exception has occurred, use %tb to see the full traceback. RRs (R-RR.t issubclasst SyntaxErrortshowsyntaxerrorRR0textendRR2t_render_traceback_t ExceptionR"t_showtracebackRRRtKeyboardInterrupt( RVR)RRtexception_onlyRRYRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR*0s4          cC@s#t|jj|dtjdS(sActually show a traceback. Subclasses may override this method to put the traceback on a different place, like a side channel. RON(RlRR$R(R)(RVRtevalueR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR9fscC@ss|j\}}}|rDt|trDy ||_WqDqDXn|jj||g}|j|||dS(s8Display the syntax error that just occurred. This doesn't display a stack trace because there isn't one. If a filename is given, it is stuffed in the exception instead of what was there before (because Python's parser always uses "" when reading from a string). N(R-R3R4RRR"R9(RVRRRYRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR5ns  cC@s|jdS(sCalled by run_cell when there's an IndentationError in code entered at the prompt. This is overridden in TerminalInteractiveShell to show a message about the %paste magic.N(R5(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytshowindentationerrorscC@s||jrddljj}nd|_t|_|j sD|j rt|_ d|_ t |_ t |_t |_|jrhtdqhnt|_ ||_ |tjdRtignoreRk(3t readline_usetIPython.utils.rlineimpltutilst rlineimplRt rl_next_inputR~t rl_do_indentt have_readlineRR{t no_op_contextRRTtset_readline_completertset_custom_completerRJRRdRRRfRgtset_pre_input_hooktreadline_startup_hooktset_startup_hookRt uses_libedittreadline_parse_and_bindtparse_and_bindRBRRRRtisfiletread_init_filetget_completer_delimsR)Rtencodetreadline_remove_delimsRlRtset_completer_delimstreadline_delimstset_history_lengththistory_lengthR}RqRR(RVR{t rlcommandt inputrc_nametdelimstd((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs`                      cC@s|jjtjjpd}d}x|jj|jdtD]\}}}|j }|rA||krAye|j r|jj t j ||n3x0|jD]"}|jj t j ||qW|}Wqtk rqAqXqAqAWdS(Nsutf-8utinclude_latest(R{t clear_historyRdRRRtget_tailthistory_load_lengthRtrstriptmultiline_historyt add_historyR)tunicode_to_strt splitlinesRN(RVRt last_cellRtcellR ((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR}s"      cC@stj||_dS(s Sets the 'default' input string for the next command line. Requires readline. Example:: In [1]: _ip.set_next_input("Hello Word") In [2]: Hello Word_ # cursor is here N(R)RRD(RVtsRl((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytset_next_inputs cC@sT|jr"|jj|jn|jdk rP|jj|jd|_ndS(screadline hook to be used at the start of each line. Currently it handles auto-indent only.N(RER{t insert_textt_indent_current_strRDR(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt pre_readline s  cC@s|jjdS(s3return the current level of indentation as a stringt (tinput_splittert indent_spaces(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRksc C@s1ddlm}ddlm}m}m}m}|d|d|jd|jd|j d||_ |j j |j |j jd t}||j d <||j _|jd |d d |jd |d d |jd |d d |jd |d d|jd |d d|j r-|jndS(sLInitialize the completion machinery. This creates completion machinery that can be used by client code, either interactively in-process (typically triggered by the readline library), programatically (such as in test suites) or out-of-prcess (typically over the network by remote frontends). i(t IPCompleter(tmodule_completertmagic_run_completert cd_completertreset_completerRrRtglobal_namespacet use_readlineR+tcomplete_commandRqtimporttfroms%runs%cds%resetN(tIPython.core.completerRptIPython.core.completerlibRqRrRsRtRR}Rt CompleterRR-R^RR:tcustom_completersRbRH(RVRpRqRrRsRttsdisp((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs$"        cC@s*|j|jj|||SWdQXdS(sReturn the completed text and a list of completions. Parameters ---------- text : string A string of text to be completed on. It can be given as empty and instead a line/position pair are given. In this case, the completer itself will split the line like readline does. line : string, optional The complete line that text is part of. cursor_pos : int, optional The position of the cursor on the input line. Returns ------- text : string The actual text that was completed. matches : list A sorted list with all possible completions. The optional arguments allow the completion to take more context into account, and are part of the low-level completion API. This is a wrapper around the completion mechanism, similar to what readline does at the command line when the TAB key is hit. By exposing it as a method, it can be used by other non-readline environments (such as GUIs) for text completion. Simple usage example: In [1]: x = 'hello' In [2]: _ip.complete('x.l') Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip']) N(R R|tcomplete(RVttextR t cursor_pos((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRDs* cC@s/tj||j}|jjj||dS(sAdds a new custom completer function. The position argument (defaults to 0) is the index in the completers list where you want the completer to be inserted.N(RgRhR|tmatchersRK(RVt completertpostnewcomp((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRIqscC@s|jj|jjdS(s)Reset readline's completer to be our own.N(R{t set_completerR|t rlcomplete(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRHzscC@sI|r'|j|j_|j|j_n|j|j_|j|j_dS(sSet the frame of the completer.N(RR|RRRuRR}(RVtframe((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytset_completer_frame~s cC@sSddlm}tjd|d|d|j||_|jj|j|jj|_ |jj |_ |j |j |j |j |j|j|j|j|j|j|j|j|j|j|j|j}|jdd|jdd |jd d |jd d d|jddd|jddd|jd|jdS(Ni(tmagicsRrR+t user_magicstedteditthistthistorytreptrecalltSVGtsvgRgtHTMLthtmlROt writefiles colors %s(t IPython.coreRRt MagicsManagert UserMagicstmagics_managerRR-Rtregister_magicst define_magict AutoMagicst BasicMagicst CodeMagicst ConfigMagicstDeprecatedMagicst DisplayMagicstExecutionMagicstExtensionMagicst HistoryMagicst LoggingMagicstNamespaceMagicstOSMagicst PylabMagicst ScriptMagicstregister_aliasR(RVRtmman((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs& R cC@s |jj|d|d|dS(Nt magic_kindt magic_name(Rtregister_function(RVRzRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytregister_magic_functionsc C@s|j|}|dkrc|j|}d}|dkrBdnd|}t|||fnud}|j||}|g} i} t|dtrtj|j | d s c C@sZ|j|dd}tjdkrddlm}|y}|d k r_d||f}ntj|}ytj |}Wn.t k r|j d|j d}nXWd QXntj|}tj jd d }ytj|d td |}Wn.t k r.|j d|j d }nX|dkrI|d }n||jdReR=(RVRRRtout((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR4 s cC@s/td|d||_|jj|jdS(NRrR+(R RRR-(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR scC@s/td|d||_|jj|jdS(NRrR+(Rtextension_managerRR-(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR scC@s)td||_|jj|jdS(NR+(R!tpayload_managerRR-(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR scC@s>td|d||_|jj|j|jj|_dS(NRrR+(R"tprefilter_managerRR-tprefilter_linesR (RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR scC@sl|js dS|jjd|}y#t|}t|dtjWntk rgtd|nXdS(sPrint to the screen the rewritten form of the user's command. This shows visual feedback by rewriting input lines that cause automatic calling to kick in, like:: /f x into:: ------> f(x) after the user's input prompt. This helps the user understand that the input line was transformed automatically by IPython. NtrewriteROs------> (tshow_rewritten_inputR,trenderRRlR(R)tUnicodeEncodeError(RVRtrw((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytauto_rewrite_input s   cC@sb|j\}}}|jj||}idd6|d6t|jd6tj|d6}|S(sRreturn simple exception dict for use in user_expressions RKustatusu tracebackuenameuevalue(R-RR2R6R\R)t safe_unicode(RVRR<RRR#((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt_user_obj_error scC@s7|jj|\}}idd6|d6|d6}|S(sZformat a user object to display dict for use in user_expressions toktstatustdatatmetadata(R1R(RVRoRtmdRY((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt_format_user_obj s  cC@sxi}|j}|j}xYt|D]K\}}y|jt|||}Wn|j}nX||| for safe execution.iR;R(N(RR~RfRRt expanduserRRJRFR;RR)texecfileRt SystemExittcodeR*R( RVtfnametwhereRStthefiletdnametglobtlocR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt safe_execfile8 s4     c @s tjjtjjyt}WdQXWntddSXtjj}fd}t|ySxL|D]A}|j|dt d|}|r|j q|j sPqqWWn+|rn|j tdnXWdQXdS(sLike safe_execfile, but for .ipy or .ipynb files with IPython syntax. Parameters ---------- fname : str The name of the file to execute. The filename must have a .ipy or .ipynb extension. shell_futures : bool (False) If True, the code will share future statements with the interactive shell. It will both be affected by previous __future__ imports, and any __future__ imports in the code will affect the shell. If False, __future__ imports are not shared in either direction. raise_exceptions : bool (False) If True raise exceptions everywhere. Meant for testing. Ns,Could not open file <%s> for safe execution.c3@sjdrddlm}tT}||dd}|jsMdSx+|jD] }|jdkrW|jVqWqWWWdQXn t}|jVWdQXdS(s,generator for sequence of code blocks to runs.ipynbi(treadt as_versioniNR(RtnbformatRtio_opentcellst cell_typetsourceR(RRstnbRg(R(sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt get_cells s tsilentRs$Unknown failure executing file: <%s>( RfRRRRRJRFR;trun_cellRRRR*( RVRRRRRRRgR((RsU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytsafe_execfile_ipy s,      cC@s{yUy,|jtjt|dddtWn"tk rS}|jrTqTnXWn|jtd|nXdS(sA safe version of runpy.run_module(). This version will never throw an exception, but instead print helpful error messages to the screen. `SystemExit` exceptions with status code 0 or None are ignored. Parameters ---------- mod_name : string The name of the module to be executed. where : dict The globals namespace. trun_nameRt alter_syss&Unknown failure executing module: <%s>N( Rtrunpyt run_moduleRRRRR*RJ(RVtmod_nameRR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytsafe_run_module s  cC@s%|j}d|_|j|||S(sJSpecial method to call a cell magic with the data stored in self. N(t_current_cell_magic_bodyRR(RVRR Rg((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt_run_cached_cell_magic s  c @st| s|jr S|r/t}n|rD|j_nfd}|jjd|s||jjdnd}y|jj|}Wn#t k rt j }|}nfXt |j dkr#|j?y|jj|d}Wntk rt j }nXWdQXn|rE|jj|j||n|sa|jj||n|dk r|j||r|jd7_n||dS|r|jnt}|j|jj||j} |jty|j|d| } Wntk r;} |j|r1|jd7_n|| Stt tt t!fk r} |j"|r{|jd7_n|| SXy|j#| } Wn<t$k r} |j|r|jd7_n|| SX|j%_&|rd n|j'} |j(| j)| d | d |d d|j%_&|jjd |sS|jjdnWdQXWdQX|r|jj*|j|jd7_nS(sRun a complete IPython cell. Parameters ---------- raw_cell : str The code (including IPython code such as %magic functions) to run. store_history : bool If True, the raw and translated cell will be stored in IPython's history. For user code calling back into IPython's machinery, this should be set to False. silent : bool If True, avoid side-effects, such as implicit displayhooks and and logging. silent=True forces store_history=False. shell_futures : bool If True, the code will share future statements with the interactive shell. It will both be affected by previous __future__ imports, and any __future__ imports in the code will affect the shell. If False, __future__ imports are not shared in either direction. Returns ------- result : :class:`ExecutionResult` c@s |_S(N(R(RY(R(sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR s Rwt pre_run_cellis NiRRt interactivitytcompilerRt post_executeRy(+RtisspaceR~RRRRtinput_transformer_managerttransform_cellR4RdR#RReR RRR8Rt store_inputsRtlogR*RRtcacheR:t ast_parsetIndentationErrorR=t OverflowErrorRRNt MemoryErrorR5t transform_astRR9t exec_resulttast_node_interactivityt run_ast_nodestbodyt store_output( RVtraw_cellt store_historyRRRtpreprocessing_exc_tupleRgRt cell_nametcode_astRR((RsU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR s                     cC@sxi|jD]^}y|j|}Wq tk r9q tk rgtd||jj|q Xq W|jrtj|n|S(sApply the AST transformations from self.ast_transformers Parameters ---------- node : ast.Node The root node to be transformed. Typically called with the ast.Module produced by parsing user input. Returns ------- An ast.Node corresponding to the node it was called with. Note that it may also modify the passed object, so don't rely on references to the original AST. s;AST transformer %r threw an error. It will be unregistered.(tast_transformerstvisitRR8RJtremovetasttfix_missing_locations(RVtnodet transformer((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRi s   c C@s|s dS|dkr>t|dtjr5d}q>d}n|dkrZ|g}}nP|dkr~|d |d}}n,|dkrg|}}ntd||j}yxTt|D]F\} } tj| g} || |d} |j| |rtSqWxTt|D]F\} } tj | g} || |d } |j| |rtSqWt t j d rt nWn.|rt jd |_n|jtSXtS( sRun a sequence of AST nodes. The execution mode depends on the interactivity parameter. Parameters ---------- nodelist : list A sequence of AST nodes to run. cell_name : str Will be passed to the compiler as the filename of the cell. Typically the value returned by ip.compile.cache(cell). interactivity : str 'all', 'last', 'last_expr' or 'none', specifying which nodes should be run interactively (displaying output from expressions). 'last_expr' will run the last node interactively only if it is an expression (i.e. expressions in loops or other blocks are not displayed. Other values for this parameter will raise a ValueError. compiler : callable A function with the same interface as the built-in compile(), to turn the AST nodes into code objects. Default is the built-in compile(). result : ExecutionResult, optional An object to store exceptions that occur during execution. Returns ------- True if an exception occurred while running code, False if it finished running. NRiRRRsInteractivity was %rtexectsingleii(RR+tExprRRRtModuletrun_codeRRRLRdR)RlR#RR*R~( RVtnodelistR&RRRt to_run_exectto_run_interactivet exec_counttiR-tmodR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR  sB         c B@s;ej|j}e_||_d}y9z(|jj||j|jfdUWd|e_XWnek r}|dk r||_ n|j de e dddn|j k rej\}}}|dk r||_ n|j|||n9|dk r#ejd|_ n|j nXd}|S(sExecute a code object. When an exception occurs, self.showtraceback() is called to display a traceback. Parameters ---------- code_obj : code object A compiled code object, to be executed result : ExecutionResult, optional An object to store exceptions that occur during execution. Returns ------- False : successful execution. True : an error occurred. iNR;s'To exit: use 'exit', 'quit', or Ctrl-D.tleveli(RdRORRtpre_run_code_hookR}RRRRR*RRJRR#R(( RVtcode_objRtold_excepthooktoutflagRRRYR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR3 s0       cC@stddS(Ns"Implement enable_gui in a subclass(tNotImplementedError(RVtgui((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt enable_gui scC@sddlm}|j||j\}}|dkr|jdkrR||_q||jkrtd||jf|j|j\}}qn|j||j|||j||j |j |j j d_ ||fS(sEnable interactive matplotlib and inline figure support. This takes the following steps: 1. select the appropriate eventloop and matplotlib backend 2. set up matplotlib for interactive use with that backend 3. configure formatters for inline figure display 4. enable the selected gui eventloop Parameters ---------- gui : optional, string If given, dictates the choice of matplotlib GUI backend to use (should be one of IPython's supported backends, 'qt', 'osx', 'tk', 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by matplotlib (as dictated by the matplotlib build-time options plus the user's matplotlibrc configuration file). Note that not all backends make sense in all contexts, for example a terminal ipython can't display figures inline. i(t pylabtoolstinlinesHWarning: Cannot change to a different GUI toolkit: %s. Using %s instead.RN(RRBtfind_gui_and_backendtpylab_gui_selectRRltactivate_matplotlibtconfigure_inline_supportRAt mpl_runnerRRtregistrytdefault_runner(RVR@tpttbackend((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytenable_matplotlib s    c C@sddlm}|j|\}}i}|||tdg}t|j|jj|}g|D]#} |j| || k ro| ^qo} |jj||jj|||| fS(sActivate pylab support at runtime. This turns on support for matplotlib, preloads into the interactive namespace all of numpy and pylab, and configures IPython to correctly interact with the GUI event loop. The GUI backend to be used can be optionally selected with the optional ``gui`` argument. This method only adds preloading the namespace to InteractiveShell.enable_matplotlib. Parameters ---------- gui : optional, string If given, dictates the choice of matplotlib GUI backend to use (should be one of IPython's supported backends, 'qt', 'osx', 'tk', 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by matplotlib (as dictated by the matplotlib build-time options plus the user's matplotlibrc configuration file). Note that not all backends make sense in all contexts, for example a terminal ipython can't display figures inline. import_all : optional, bool, default: True Whether to do `from numpy import *` and `from pylab import *` in addition to module imports. welcome_message : deprecated This argument is ignored, no welcome message will be displayed. i(t import_pylabR( tIPython.core.pylabtoolsRNRMRt intersectionRt differenceRR( RVR@t import_alltwelcome_messageRNRLRtignoredtbothRgt clobbered((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt enable_pylabG s !0cC@s|jj}ytj|d}Wntk r9nX|j|jy|j|dgd|}Wntk r|nX|S(s(Expand python variables in a string. The depth argument indicates how many frames above the caller should be walked to look for the local namespace where to expand variables. The global namespace for expansion is always the user's interactive namespace. iRR( RtcopyRdRRRRtvformatR8(RVRRR RR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRw s   t ipython_edit_cC@stjd|}|jj|tjd|d|\}}tj||jj||rt|d}|j ||jn|S(sMake a new tempfile and return its filename. This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp), but it registers the created filename internally so ipython cleans it up at exit time. Optional inputs: - data(None): if data is given, it gets written out to the temp file immediately, and the file is closed again.tprefixs.pytdirtw( ttempfiletmkdtempRR-tmkstempRftcloseRRRZ(RVRR[RFthandleRttmp_file((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt mktempfile s    cC@stjj|dS(s$Write a string to the default outputN(R(R)RZ(RVR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRZ scC@stjj|dS(s*Write a string to the default error outputN(R(R*RZ(RVR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR. scC@s|jr tSt||S(N(tquietRR,(RVtpromptR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR, s cC@stjtjjjdS(sShow a usage messageN(RR_R`tusagetinteractive_usage(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyt show_usage scC@s/|jj|d|}djd|DS(sReturn as a string a set of input history slices. Parameters ---------- range_str : string The set of slices is given as a string, like "~5/6-~4/2 4:8 9", since this function is for use by magic functions which get their arguments as strings. The number before the / is the session number: ~n goes n back from the current session. raw : bool, optional By default, the processed input is used. If this is true, the raw input history is used instead. Notes ----- Slices can be described with two notations: * ``N:M`` -> standard python form, means including items N...(M-1). * ``N-M`` -> include items N..M (closed endpoint). traws cs@s|]\}}}|VqdS(N((R=RR((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pys s(Rtget_range_by_strR(RVt range_strRjtlines((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytextract_input_lines scC@s|j|d|}|r|St|}y&|jdrPtj|d|SWn~tk r|syddlm}Wn!tk rddl m}nX||} | j j dSt d|nX|g} y| j dt|Wntk rnXx| D]} tjj| rytj| d|SWqtk r|st| d d d} | j SWd QXnt d|qXqtjjtjj| rt d |qqW|r|j|d d} | dr| dr| dSnyt||j}Wn!tk r?t d|nXt|trS|St|tri|jStd||d S(sGet a code string from history, file, url, or a string or macro. This is mainly used by magic functions. Parameters ---------- target : str A string specifying code to retrieve. This will be tried respectively as: ranges of input history (see %history for syntax), url, correspnding .py file, filename, or an expression evaluating to a string or Macro in the user namespace. raw : bool If true (default), retrieve raw history. Has no effect on the other retrieval mechanisms. py_only : bool (default False) Only try to fetch python code, do not try alternative methods to decode file if unicode fails. Returns ------- A string of code. ValueError is raised if nothing is found, and TypeError if it evaluates to an object of another type. In each case, .args[0] is a printable message. Rjshttp://shttps://tskip_encoding_cookiei(turlopentlatin1s'%s' seem to be unreadable.trRNs('%s' is a directory, not a regular file.R iRRsI'%s' was not found in history, as a file, url, nor in the user namespace.s#%s is neither a string nor a macro.(shttp://shttps://( RnR1R<R*t read_py_urltUnicodeDecodeErrorturllib.requestRpt ImportErrorturllibRtdecodeRRKR0tIOErrorRfRRPt read_py_fileRtisdirRRRRR8RR7R RYRN(RVttargetRjtpy_onlyRot search_nsRtutargetRptresponsetpotential_targetttgtRsR tcodeobj((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytfind_user_code s^           cC@s|jjx6|jD]+}ytj|Wqtk rAqXqWx6|jD]+}ytj|WqPtk rzqPXqPW|jdt |j j dS(sThis will be executed at the time of exit. Cleanup operations and saving of persistent data that is done unconditionally by IPython should be performed here. For things that may depend on startup flags or platform specifics (such as having readline or not), register a separate atexit function in the code that has the appropriate information, rather than trying to clutter RN( Rt end_sessionRRftunlinkRRtrmdirRR~Rt shutdown_hook(RVttfilettdir((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR4 s   cC@s|jdS(N(RV(RV((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pytcleanupW sN(iii(sNoColorsLightBGsLinux(((iii(RsPlainR(((N(R\R]RpRt _instanceRERR(RDtautocallRBRt automagicRGR%RWRXR@R6t color_infoRCRhRR~t colors_forcetdebugt deep_reloadtdisable_failing_post_executeRHRR1RIRR8RR2R4texit_nowRRRRRRRnRRRRR$RRdReRbRARdRRRRRt_prompt_in1_changedt_prompt_in2_changedt_prompt_out_changedt_prompt_pad_left_changedRReRXR`R@RTRVRNRRRRit separate_int separate_outt separate_out2twildcards_case_sensitiveRRRR R:RRRRRRRRFRRERtRRRRRRRRRRRRRRRRRRRRRRRRVRYR[RRbRR{RxRRRRRRRRRR}RRRRRRRRRRt staticmethodRRR RRRRRROR-R0R2R*R9R5R=RR}R&RiRlRkRRRIRHRRt functoolstwrapsRRRRRRRRRRRRR3R4RRRRRRRRRRRRR RRRRR R3truncodeRARMRWR?RRdRZR.R,RiRnRRR(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyRs                                            T                -    1  &      N,  < * )  0  b'     f    5   T   %-  " " $       4!          G<   R 5  -0     Z #tInteractiveShellABCcB@seZdZRS(s,An abstract base class for InteractiveShell.(R\R]Rp(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyR[ s(RpRRRtabcR+RRRfRkR RdR^RZRgRRR(RRt pickleshareRttraitlets.config.configurableRRRRRRR R R tIPython.core.aliasR R tIPython.core.autocallRtIPython.core.builtin_trapRtIPython.core.eventsRRtIPython.core.compileropRRtIPython.core.display_trapRtIPython.core.displayhookRtIPython.core.displaypubRtIPython.core.errorRRtIPython.core.extensionsRtIPython.core.formattersRtIPython.core.historyRtIPython.core.inputsplitterRRRtIPython.core.loggerRtIPython.core.macroR tIPython.core.payloadR!tIPython.core.prefilterR"tIPython.core.profiledirR#tIPython.core.promptsR$tIPython.core.usageR%tIPython.testing.skipdoctestR&t IPython.utilsR'R)R*tIPython.utils.decoratorsR+tIPython.utils.ioR,tIPython.utils.ipstructR-t IPython.pathsR.tIPython.utils.pathR/R0R1R2tIPython.utils.processR3R4tIPython.utils.py3compatR5R6R7R8R9tIPython.utils.strdispatchR:tIPython.utils.syspathcontextR;tIPython.utils.textR<R=R>R?t traitletsR@RARBRCRDRERFRGRHRItIPython.utils.warnRJRKtIPython.core.hooksR_Rt dedent_reRLRTtobjectRURGR8R^R_RhRiRqRRRtABCMetaRR(((sU/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/interactiveshell.pyts               "("F    ."