NXc@s8dZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZddlmZddlmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZm Z dd l!m"Z"m#Z#ddgZ$ej%dkrjdZ&ndZ&dZ'dZ(dZ)dZ*dZ+ede,fdYZ-dZ.dZ/de,fdYZ0de fdYZ1dZ2d Z3d!Z4d"Z5d#Z6de1fd$YZ7dS(%sWord completion for IPython. This module is a fork of the rlcompleter module in the Python standard library. The original enhancements made to rlcompleter have been sent upstream and were accepted as of Python 2.3, but we need a lot more functionality specific to IPython, so this module will continue to live as an IPython-specific utility. Original rlcompleter documentation: This requires the latest extension to the readline module (the completes keywords, built-ins and globals in __main__; when completing NAME.NAME..., it evaluates (!) the expression up to the last dot and completes its attributes. It's very cool to do "import string" type "string.", hit the completion key (twice), and see the list of names defined by the string module! Tip: to use the tab key as the completion key, call readline.parse_and_bind("tab: complete") Notes: - Exceptions raised by the completer function are *ignored* (and generally cause the completion to fail). This is a feature -- since readline sets the tty device in raw (or cbreak) mode, printing a traceback wouldn't work well without some complicated hoopla to save, reset and restore the tty state. - The evaluation of the NAME.NAME... form may cause arbitrary application defined code to be executed if an object with a ``__getattr__`` hook is found. Since it is the responsibility of the application (or the user) to enable this feature, I consider this an acceptable risk. More complicated expressions (e.g. function calls or indexing operations) are *not* evaluated. - GNU readline is also used by the built-in functions input() and raw_input(), and thus these also benefit/suffer from the completer features. Clearly an interactive application can benefit by specifying its own completer function and using raw_input() for all its input. - When the original stdin is not a tty device, GNU readline is never used, and this module (and the readline module) are silently inactive. iN(t Configurable(tTryNext(t ESC_MAGIC(t latex_symbolstreverse_latex_symbol(tgenerics(tio(tundoc(tdir2(t arg_split(t builtin_modt string_typestPY3(tCBooltEnumt Completert IPCompletertwin32t s ()[]{}?=\|;:'#*"^&cCs6|jddrdS|jddr.dStSdS(sReturn whether a string has open quotes. This simply counts whether the number of quote characters of either type in the string is odd. Returns ------- If there is an open quote, the quote character is returned. Else, return False. t"it'N(tcounttFalse(ts((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pythas_open_quotes`s cCs6djg|D]"}|tkr)d|p,|^q S(s.Escape a string to protect certain characters.ts\(tjoint PROTECTABLES(Rtch((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytprotect_filenameus cCsst}d}|}|jdrft}t|d}tjj|}|r]|| }qf|}n|||fS(sExpand '~'-style usernames in strings. This is similar to :func:`os.path.expanduser`, but it computes and returns extra information that will be useful if the input was being used in computing completions, and you wish to return the completions with the original '~' instead of its expanded value. Parameters ---------- path : str String to be expanded. If no ~ is present, the output is the same as the input. Returns ------- newpath : str Result of ~ expansion in the input path. tilde_expand : bool Whether any expansion was performed or not. tilde_val : str The value that ~ was replaced with. Rt~i(Rt startswithtTruetlentostpatht expanduser(R#t tilde_expandt tilde_valtnewpathtrest((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt expand_user{s cCs|r|j|dS|SdS(s8Does the opposite of expand_user, with its outputs. RN(treplace(R#R%R&((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt compress_userscCsb|d dkr/d|dkr/|ddSn|d dkr^d|dkr^|ddSn|S(skey for sorting that penalizes magic commands in the ordering Normal words are left alone. Magic commands have the initial % moved to the end, e.g. %matplotlib is transformed as follows: %matplotlib -> matplotlib% [The choice of the final % is arbitrary.] Since "matplotlib" < "matplotlib%" as strings, "timeit" will appear before the magic "%timeit" in the ordering For consistency, move "%%" to the end, so cell magics appear *after* line magics with the same name. A check is performed that there are no other "%" in the string; if there are, then the string is not a magic command and is left unchanged. is%%t%i((tword((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytpenalize_magics_keystBunchcBseZRS((t__name__t __module__(((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyR/ss `!@#$^&*()=+[{]}\|;:'",<>?s = tCompletionSplittercBsYeZdZeZdZdZddZe dZ e j dZ ddZ RS(sUAn object to split an input line in a manner similar to readline. By having our own implementation, we can expose readline-like completion in a uniform manner to all frontends. This object only needs to be given the line of text to be split and the cursor position on said line, and it returns the 'word' to be completed on at the cursor after splitting the entire line. What characters are used as splitting delimiters can be controlled by setting the `delims` attribute (this is a property that internally automatically builds the necessary regular expression)cCs(|dkrtjn|}||_dS(N(tNoneR2t_delimstdelims(tselfR5((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt__init__scCs|jS(s*Return the string of delimiter characters.(R4(R6((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyR5scCsIddjd|Dd}tj||_||_||_dS(s&Set the delimiters for line splitting.t[Rcss|]}d|VqdS(s\N((t.0tc((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pys st]N(Rtretcompilet _delim_reR4t _delim_expr(R6R5texpr((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyR5s! cCs0|dkr|n|| }|jj|dS(sBSplit a line of text with a cursor at the given position. iN(R3R>tsplit(R6tlinet cursor_postl((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt split_linesN( R0R1t__doc__tDELIMSR4R3R?R>R7tpropertyR5tsetterRE(((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyR2s  cBsJeZeededdZdddZdZdZ dZ RS(tconfigthelpsActivate greedy completion This will enable completion on elements of lists, results of function calls, etc., but can be unsafe because the code is actually evaluated on TAB. cKse|dkrd|_nd|_||_|dkrBi|_n ||_tt|j|dS(sCreate a new completer for the command line. Completer(namespace=ns,global_namespace=ns2) -> completer instance. If unspecified, the default namespace where completions are performed is __main__ (technically, __main__.__dict__). Namespaces should be given as dictionaries. An optional second namespace can be given. This allows the completer to handle cases where both the local and global scopes need to be distinguished. Completer instances should be used as the completion mechanism of readline via the set_completer() call: readline.set_completer(Completer(my_namespace).complete) iiN(R3t use_main_nst namespacetglobal_namespacetsuperRR7(R6RMRNtkwargs((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyR7s       cCs|jrtj|_n|dkrZd|krE|j||_qZ|j||_ny|j|SWntk r}dSXdS(sReturn the next possible completion for 'text'. This is called successively with state == 0, 1, 2, ... until it returns None. The completion should begin with 'text'. it.N( RLt__main__t__dict__RMt attr_matchestmatchestglobal_matchest IndexErrorR3(R6ttexttstate((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytcomplete<s    cCsg}|j}t|}xrtjtjj|jj|jjgD]@}x7|D]/}|| |krY|dkrY||qYqYWqLW|S(sCompute matches when text is a simple name. Return a list of all keywords, built-in functions and names currently defined in self.namespace or self.global_namespace that match. t __builtins__( tappendR!tkeywordtkwlistR RStkeysRMRN(R6RXRUt match_appendtntlstR-((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRVPs      c Csktjd|}|r3|jdd\}}nG|jrvtjd|j}|s[gS|jdd\}}ngSyt||j}Wn(yt||j}WqgSXnX|jrt |drt |}n t |}yt j ||}Wn!tk rntk r'nXt|}g|D]&} | | |kr;d|| f^q;} | S(sCompute matches when text contains a dot. Assuming the text is of the form NAME.NAME....[NAME], and is evaluatable in self.namespace or self.global_namespace, it will be evaluated and its attributes (as revealed by dir()) are used as possible completions. (For class instances, class members are are also considered.) WARNING: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated. s(\S+(\.\w+)*)\.(\w*)$iis (.+)\.(\w*)$it__all__s%s.%s(R<tmatchtgrouptgreedyt line_buffertevalRMRNtlimit_to__all__thasattrtget__all__entriesRRtcomplete_objectRt ExceptionR!( R6RXtmR@tattrtm2tobjtwordsRatwtres((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRTds8      3N( R0R1R RR RfR3R7RZRVRT(((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyR s  $  cCsDyt|d}WngSXg|D]}t|tr%|^q%S(s,returns the strings in the __all__ attributeRc(tgetattrt isinstanceR (RqRrRs((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRks cCs |sAddg|D]'}t|ttfrt|^qfStjd|}|j}yt||i}Wnt k rddgfSXddj d|Dd}tj||tj }|j } |j} g} x|D]} y| j |swnWntttfk r0qnX| t|} t| d}|j dr|dd kryt| jd d}Wqtk rqqXn|d |jd d !}|dkr|jdd}n| jd| |fqW|| | fS(s?Used by dict_key_matches, matching the prefix to a list of keysis["']s[^Rcss|]}d|VqdS(s\N((R9R:((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pys ss]*$RtutuUtasciiiRis\"s%s%sN(R3RvR tbytestreprR<tsearchReRhRmRtUNICODEtstartRtAttributeErrort TypeErrort UnicodeErrorR!tencodetUnicodeEncodeErrortindexR*R\(R_tprefixR5tkt quote_matchtquotet prefix_strtpatternt token_matcht token_startt token_prefixtmatchedtkeytremtrem_repr((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytmatch_dict_keyss@(  !       cCs+|tjko*t|tt||S(s@Checks if obj is an instance of module.class_name if loaded (tsystmodulesRvRut __import__(Rqtmodulet class_name((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt_safe_isinstancescCst|dkrddfS|d}|dkr<dd fS|d}|tjksa|d krkdd fSy(tj|}d|d|gfSWntk r}nXdd fS( uuMatch unicode characters back to unicode name This does ☃ -> \snowman Note that snowman is not a valid python3 combining character but will be expanded. Though it will not recombine back to the snowman character by the completion machinery. This will not either back-complete standard sequences like \n, \b ... Used on Python 3 only. iuis\iRR(((RR(((R!tstringt ascii_letterst unicodedatatnametKeyError(RXt maybe_slashtchartunicte((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytback_unicode_name_matchess       cCst|dkrddfS|d}|dkr<dd fS|d}|tjksa|d krkdd fSyt|}d||gfSWntk r}nXdd fS( uhMatch latex characters back to unicode name This does ->\sqrt Used on Python 3 only. iuis\iRR(((RR(((R!RRRR(RXRRtlatexR((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytback_latex_name_matchess       cBseZdZdZeededdZeddddedd Zede dedd Z dddedd Z d Z d ZdZdZdZdZdZdZdZdZdZdZdZddddZdZRS(s?Extension of the completer class with IPython-specific featurescCsG|rt|j_n t|j_|jrC|jj|jjndS(s>update the splitter and readline delims when greedy is changedN(t GREEDY_DELIMStsplitterR5RGtreadlinetset_completer_delims(R6Rtoldtnew((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt_greedy_changeds   RJRKsWhether to merge completion results into a single list If False, only the completion results from the first non-empty completer will be returned. iiit default_valuesQInstruct the completer to omit private method names Specifically, when completing on ``object.``. When 2 [default]: all names that start with '_' will be excluded. When 1: all 'magic' names (``__foo__``) will be excluded. When 0: nothing will be excluded. sInstruct the completer to use __all__ for the completion Specifically, when completing on ``object.``. When True: only those names in obj.__all__ will be included. When False [default]: the __all__ attribute is ignored c Ks1t|_t|_|r9ddljj}||_n d|_t j |d|d|d||g|_ ||_ t jd|_tj|_tjjdd}|dk|_tjd kr|j|_n |j|_t jd |_t jd |_|j|j|j|j|j g|_!dS(smIPCompleter() -> completer Return a completer object suitable for use by the readline library via readline.set_completer(). Inputs: - shell: a pointer to the ipython shell itself. This is needed because this completer knows about magic functions, and those can only be accessed via the ipython instance. - namespace: an optional dict where completions are performed. - global_namespace: secondary optional dict for completions, to handle cases (such as IPython embedded inside functions) where both Python scopes are visible. use_readline : bool, optional If true, use the readline library. This completer can still function without readline, though in that case callers must provide some extra information on each call about the current line.iNRMRNRJs([^\\] )tTERMtxtermtdumbtemacsRs^[\w|\s.]+\(([^)]*)\).*s[\s|\[]*(\w+)(?:\s*=\s*.*)(RR("Rt magic_escapeR2RtIPython.utils.rlineimpltutilst rlineimplRR3RR7RUtshellR<R=t space_name_retglobR"tenvirontgett dumb_terminalRtplatformt_clean_glob_win32t clean_globt _clean_globtdocstring_sig_retdocstring_kwd_retpython_matchest file_matchest magic_matchestpython_func_kw_matchestdict_key_matchestmatchers( R6RRMRNt use_readlineRJRPRtterm((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyR7Es0         cCs|j|dS(s_ Wrapper around the complete method for the benefit of emacs and pydb. i(RZ(R6RX((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytall_completionsscCs|jd|S(Ns%s*(R(R6RX((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRscCs0g|jd|D]}|jdd^qS(Ns%s*s\t/(RR*(R6RXtf((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRsc Cs|jdr"|d}d}nd}|j}t|}d|ksUd|kr^|}n^yt|d}WnGtk r|r|j|d}qgSntk rd}nX| r|t|krt}||}}nt }t j j |}|dkr9g|j dD]}|t|^qS|j|jdd} |rt|} g| D]}||t|| ^qm} n2|r| } n#g| D]}|t|^q} g| D](} t j j| r| d n| ^q} | S( sMatch filenames, expanding ~USER type strings. Most of the seemingly convoluted logic in this completer is an attempt to handle filenames with spaces in them. And yet it's not quite perfect, because Python's readline doesn't expose all of the GNU readline details needed for this to be done correctly. For a filename with a space in it, the printed completions will be only the parts after what's already been typed (instead of the full completions, as is normally done). I don't think with the current (as of Python 2.3) Python readline it's possible to do better.t!iRt(R8it*s\R(Rttext_until_cursorRR t ValueErrorRARWRR RR"R#R$RRR*R!tisdir( R6RXt text_prefixRt open_quotestlsplitthas_protectablesttext0Rtm0t len_lsplitRUtx((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRsD         * +  5c Cs|jjj}|d}|d}|j}||}|j|}g|D]}|j|rO||^qO} |j|s| g|D]}|j|r||^q7} n| S(s Match magicsRBtcell(Rtmagics_managertlsmagicRtlstripR( R6RXtlsmt line_magicst cell_magicstpretpre2t bare_textRntcomp((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRs    ,3cCsd|krya|j|}|jdrl|jrl|jdkrQd}n d}t||}nWqtk rg}qXn|j|}|S(s'Match attributes or global python namesRQicSstjd|dkS(Ns .*\.__.*?__(R<RdR3(ttxt((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytscSs#tjd||jddkS(Ns\._.*?RQ(R<RdtrindexR3(R((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRs(RTtendswitht omit__namestfiltert NameErrorRV(R6RXRUtno__name((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRs     cCs|dkrgS|jjd}|jj|}|dkrHgS|jdjd}g}x$|D]}||jj|7}qnW|S(sParse the first line of docstring for call signature. Docstring should be of the form 'min(iterable[, key=func]) '. It can also parse cython docstring of the form 'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)'. it,N( R3Rt splitlinesRR|tgroupsRARtfindall(R6tdocRBtsigtretR((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt!_default_arguments_from_docstrings   cCs/|}g}tj|rntj|p9tj|stj|r||jt|dd7}t|ddpt|dd}qt|dr|j }qn||jt|dd7}y=tj |\}}}}|r ||t | 7}nWnt k rnXt t|S(s_Return the list of default arguments of obj if it is callable, or empty list otherwise.RFRR7t__new__t__call__N(tinspectt isbuiltint isfunctiontismethodtisclassRRuR3RjRt getargspecR!Rtlisttset(R6Rqtcall_objRtargst_t_1tdefaults((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt_default_arguments7s*   cCs&d|krgSy |j}Wn4tk rStjdtjtjB}|_nX|j|j}|jt |}d}xT|D]H}|dkr|d8}q|dkr|d7}|dkrPqqqWgSg}tjdj }xjt r]yK|j t |||ds.|jPnt |dksDPnWqtk rYPqXqWt|dkr|j|d} n%|jdj|d d d} g} xn| D]f} y|jt| |j} Wn qnXx1| D])} | j|r| j d | qqWqW| S( s9Match named parameters (kwargs) of the last open functionRQs '.*?(? η Works only on valid python 3 identifier, or on combining characters that will combine to form a valid identifier. Used on Python 3 only. s\iitau(trfindRtlookupt isidentifierR(R6RXtslashposRRR((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytunicode_name_matchess  cCs|jd}|dkrw||}|tkrB|t|gfSgtD]}|j|rI|^qI}||fSndgfS(uMatch Latex syntax for unicode characters. This does both \alp -> \alpha and \alpha -> α Used on Python 3 only. s\iu(R1RR(R6RXR4RRRU((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt latex_matchess   ( c Csf|j}|jsdSt}||_||_|jddd}||_|j|_|j |j s|j j |j |}ng}xt j|j j |||j j|jD]}y||}|rIg|D]}|j |r|^q} | r| S|j} g|D]!}|jj | r$|^q$SWqtk r]qXqWdS(Nii(RgtstripR3R/RBtsymbolRAtcommandRRRtcustom_completerst s_matchest itertoolstchaint flat_matchestlowerR( R6RXRBteventtcmdt try_magicR:Rttrtwithcasettext_low((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pytdispatch_custom_completer*s6         ( 0 c Cs|dkr3|dkr$t|n t|}ntr|sE|n|| }|j|\}}|rt||fSd}g}x?|jttfD](} | |\}}|r||fSqWn|s|jj||}n|dkr|}n||_ |j | |_ g|j (|j |} | dk r?| |_ n|j rg|_ x{|jD]=} y|j j| |Wq[tjtjq[Xq[Wn0x-|jD]"} | ||_ |j rPqqWtt|j dt|_ ||j fS(s6Find completions for the given text and line context. Note that both the text and the line_buffer are optional, but at least one of them must be given. Parameters ---------- text : string, optional Text to perform the completion on. If not given, the line buffer is split using the instance's CompletionSplitter object. line_buffer : string, optional If not given, the completer attempts to obtain the current line buffer via readline. This keyword allows clients which are requesting for text completions in non-readline contexts to inform the completer of the entire text. cursor_pos : int, optional Index of the cursor in the full line buffer. Should be provided by remote frontends where kernel has no access to frontend state. Returns ------- text : str Text that was actually used in the completion. matches : list A list of completion matches. RRN(R3R!R R6R5RRRRERgRRURFtmerge_completionsRtextendRt excepthooktexc_infotsortedRR.( R6RXRgRCt base_textt latex_textR6t name_textt name_matchestmetht custom_restmatcher((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRZUsH" '          cCs|dkr|jj|_}|jj}|jpC|jsg|jjdtjj dSt }|ry|j |||Wqddl }|jqXq|j |||ny|j|SWntk rdSXdS(spReturn the state-th possible completion for 'text'. This is called successively with state == 0, 1, 2, ... until it returns None. The completion should begin with 'text'. Parameters ---------- text : string Text to perform the completion on. state : int Counter used by readline. is iN(Rtget_line_bufferRgt get_endidxRR7t insert_textRtstdouttflushR3RRZt tracebackt print_excRURW(R6RXRYRgRCtDEBUGRX((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt rlcompletes&    (iiiN(R0R1RFRR R RGRRRRiR3R7RRRRRRRRRRR5R6RFRZR[(((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyRs2     G    S    > f   +a(8RFRRRRR<R]R"R<RRRttraitlets.config.configurableRtIPython.core.errorRtIPython.core.inputsplitterRtIPython.core.latex_symbolsRRt IPython.utilsRRtIPython.utils.decoratorsRtIPython.utils.dir2RtIPython.utils.processR tIPython.utils.py3compatR R R t traitletsR RRcRRRRR)R+R.tobjectR/RGRR2RRkRRRRR(((sN/data/av2000/mvv/env_mvv/lib/python2.7/site-packages/IPython/core/completer.pyt0sT               ( %3 3