o ˷e);@s.dZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZm Z ddl!m"Z"ddl#m$Z$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-dd l.m/Z/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6m7Z7m8Z8mZ9m:Z:m;Z;mZ>ddl?Z?dZ@zddlAZAdeAjB_CddlDZAddlEZAdZFWn eGydZFYnwddgZHddgZIe jJdkrdZKndZKdZLGdddeMZNejOdeNde+edbd!d"ZPd#d$ZQeKfd%d&ZRd'eSd(eeSeTeSffd)d*ZUd'eSd+eTd,eSd(eSfd-d.ZVd/d0ZWGd1d2d2ZXGd3d4d4ZYeeYZZd5eSd6eZd(eZfd7d8Z[dd9d5eSd6eZd:eTd(eZfd;d<Z\e jJdkred=Z]nd>Z]d?Z^Gd@dAdAe_Z`GdBdde>ZadCdDZb dcdEeeeSeceeeSecffdFeSdGeSdHe eeSecfd(eeSedeeSff dIdJZed5eSdKeddLedd(edfdMdNZfd5eSdOedd(eededffdPdQZgdRdSZhd5eSd(eeSeeSffdTdUZid5eSd(eeSeeSffdVdWZjd(eSfdXdYZkd(eSfdZd[ZlGd\d]d]eZmGd^ddeaZnd_eeededfd(eeSfd`daZodS)du Completion for IPython. This module started as 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, This module now support a wide variety of completion mechanism both available for normal classic Python code, as well as completer for IPython specific Syntax like magics. Latex and Unicode completion ============================ IPython and compatible frontends not only can complete your code, but can help you to input a wide range of characters. In particular we allow you to insert a unicode character using the tab completion mechanism. Forward latex/unicode completion -------------------------------- Forward completion allows you to easily type a unicode character using its latex name, or unicode long description. To do so type a backslash follow by the relevant name and press tab: Using latex completion: .. code:: \alpha α or using unicode completion: .. code:: \GREEK SMALL LETTER ALPHA α Only valid Python identifiers will complete. Combining characters (like arrow or dots) are also available, unlike latex they need to be put after the their counterpart that is to say, ``F\\vec`` is correct, not ``\\vecF``. Some browsers are known to display combining characters incorrectly. Backward latex completion ------------------------- It is sometime challenging to know how to type a character, if you are using IPython, or any compatible frontend you can prepend backslash to the character and press ```` to expand it to its latex form. .. code:: \α \alpha Both forward and backward completions can be deactivated by setting the ``Completer.backslash_combining_completions`` option to ``False``. Experimental ============ Starting with IPython 6.0, this module can make use of the Jedi library to generate completions both using static analysis of the code, and dynamically inspecting multiple namespaces. Jedi is an autocompletion and static analysis for Python. The APIs attached to this new mechanism is unstable and will raise unless use in an :any:`provisionalcompleter` context manager. You will find that the following are experimental: - :any:`provisionalcompleter` - :any:`IPCompleter.completions` - :any:`Completion` - :any:`rectify_completions` .. note:: better name for :any:`rectify_completions` ? We welcome any feedback on these new API, and we also encourage you to try this module in debug mode (start IPython with ``--Completer.debug=True``) in order to have extra logging information if :any:`jedi` is crashing, or if current IPython completer pending deprecations are returning results not yet handled by :any:`jedi` Using Jedi for tab completion allow snippets like the following to work without having to execute any code: >>> myvar = ['hello', 42] ... myvar[1].bi Tab completion will be able to infer that ``myvar[1]`` is a real number without executing any code unlike the previously available ``IPCompleter.greedy`` option. Be sure to update :any:`jedi` to the latest stable version or to try the current development version to get better completions. N)contextmanager) import_module)SimpleNamespace) IterableIteratorListTupleUnionAnySequenceDict NamedTuplePatternOptional)TryNext) ESC_MAGIC) latex_symbolsreverse_latex_symbol) InspectColors) skip_doctest)generics)dir2get_real_method)ensure_dir_exists) arg_split)BoolEnumIntrUnicodedefaultobserve) ConfigurableTF) iK)ii Completer IPCompleterwin32 z ()[]{}?=\|;:'#*"^&ic@seZdZdZdS)ProvisionalCompleterWarningz Exception raise by an experimental feature in this module. Wrap code in :any:`provisionalcompleter` context manager if you are certain you want to use an unstable feature. N)__name__ __module__ __qualname____doc__r,r,M/var/www/ideatree/venv/lib/python3.10/site-packages/IPython/core/completer.pyr'sr'errorcategoryignoreccsDttj|tddVWddS1swYdS)a This context manager has to be used in any place where unstable completer behavior and API may be called. >>> with provisionalcompleter(): ... completer.do_experimental_things() # works >>> completer.do_experimental_things() # raises. .. note:: Unstable By using this context manager you agree that the API in use may change without warning, and that you won't complain if they do so. You also understand that, if the API is not to your liking, you should report a bug to explain your use case upstream. We'll be happy to get your feedback, feature requests, and improvements on any of the unstable APIs! r/N)warningscatch_warningsfilterwarningsr')actionr,r,r-provisionalcompleters  "r6cCs(|ddr dS|ddrdSdS)aReturn 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. "'F)countsr,r,r-has_open_quotess  r=csBt|t@rtjdkrd|dSdfdd|DS|S)z.Escape a string to protect certain characters.r%r7c3s$|] }|vr d|n|VqdS\Nr,.0c protectablesr,r- s"z#protect_filename..)setsysplatformjoin)r<rEr,rDr-protect_filenames   rKpathreturncCsTd}d}|}|dr%d}t|d}tj|}|r#|d| }n|}|||fS)aExpand ``~``-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. Fr>~TN) startswithlenosrL expanduser)rL tilde_expand tilde_valnewpathrestr,r,r- expand_users    rXrTrUcCs|r||dS|S)z8Does the opposite of expand_user, with its outputs. rNreplace)rLrTrUr,r,r- compress_user's r[cCsd\}}|dr d}n|drd}|drd}|dr0d |dd vr/|dd }d}n|d rEd |dd vrE|dd }d}|||fS) zkey for sorting completions This does several things: - Demote any completions starting with underscores to the end - Insert any %magic and %%cellmagic completions in the alphabetical order by their name )rr__r8_rO=z%%%N)rPendswith)wordprio1prio2r,r,r-completions_sorting_key0s"        rec@s eZdZdZddZddZdS)_FakeJediCompletionz This is a workaround to communicate to the UI that Jedi has crashed and to report a bug. Will be used only id :any:`IPCompleter.debug` is set to true. Added in IPython 6.0 so should likely be removed for 7.0 cCs(||_||_d|_||_d|_d|_dS)Ncrashedr>fake)namecompletetypename_with_symbols signature_origin)selfrir,r,r-__init__Ys  z_FakeJediCompletion.__init__cCsdS)Nz)r,ror,r,r-__repr__bsz_FakeJediCompletion.__repr__N)r(r)r*r+rprrr,r,r,r-rfPs rfc @s^eZdZdZgdZdddddededed ed df d d Zd dZd e fddZ ddZ dS) Completionam Completion object used and return by IPython completers. .. warning:: Unstable This function is unstable, API may change without warning. It will also raise unless use in proper context manager. This act as a middle ground :any:`Completion` object between the :any:`jedi.api.classes.Completion` object and the Prompt Toolkit completion object. While Jedi need a lot of information about evaluator and how the code should be ran/inspected, PromptToolkit (and other frontend) mostly need user facing information. - Which range should be replaced replaced by what. - Some metadata (like completion type), or meta information to displayed to the use user. For debugging purpose we can also store the origin of the completion (``jedi``, ``IPython.python_matches``, ``IPython.magics_matches``...). startendtextrkrmrnNr>rkrnrmrurvrwrkrMcCs8tjdtdd||_||_||_||_||_||_dS)Nz~``Completion`` is a provisional API (as of IPython 6.0). It may change without warnings. Use in corresponding context manager.r8r0 stacklevel) r2warnr'rurvrwrkrmrn)rorurvrwrkrnrmr,r,r-rps zCompletion.__init__cCs$d|j|j|j|jp d|jpdfS)Nz;?)rurvrwrkrmrqr,r,r-rrszCompletion.__repr__cCs$|j|jko|j|jko|j|jkS)a] Equality and hash do not hash the type (as some completer may not be able to infer the type), but are use to (partially) de-duplicate completion. Completely de-duplicating completion is a bit tricker that just comparing as it depends on surrounding text, which Completions are not aware of. )rurvrw)rootherr,r,r-__eq__s  zCompletion.__eq__cCst|j|j|jfSN)hashrurvrwrqr,r,r-__hash__szCompletion.__hash__) r(r)r*r+ __slots__intstrrprrrr~rr,r,r,r-rsfs(  rsrw completionsccst|}|s dStdd|D}tdd|D}t}|D]}|||j|j||j|}||vr?|V||q dS)a  Deduplicate a set of completions. .. warning:: Unstable This function is unstable, API may change without warning. Parameters ---------- text : str text that should be completed. completions : Iterator[Completion] iterator over the completions to deduplicate Yields ------ `Completions` objects Completions coming from multiple sources, may be different but end up having the same effect when applied to ``text``. If this is the case, this will consider completions as equal and only emit the first encountered. Not folded in `completions()` yet for debugging purpose, and to detect when the IPython completer does return things that Jedi does not, but should be at some point. Ncs|]}|jVqdSrrurAr,r,r-rFz+_deduplicate_completions..csrrrvrAr,r,r-rFr)listminmaxrGrurwrvadd)rwr new_startnew_endseenrCnew_textr,r,r-_deduplicate_completionss" r)_debugrc cstjdtddt|}|sdSdd|D}dd|D}t|}t|}t}t}|D]6} ||| j| j|| j |} | j dkrM| | n | j d krW| | t ||| | j | j | jd Vq/||} | rv|rxtd | dSdSdS) a Rectify a set of completions to all have the same ``start`` and ``end`` .. warning:: Unstable This function is unstable, API may change without warning. It will also raise unless use in proper context manager. Parameters ---------- text : str text that should be completed. completions : Iterator[Completion] iterator over the completions to rectify _debug : bool Log failed completion Notes ----- :any:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though the Jupyter Protocol requires them to behave like so. This will readjust the completion to have the same ``start`` and ``end`` by padding both extremities with surrounding text. During stabilisation should support a ``_debug`` option to log which completion are return by the IPython completer and not found in Jedi in order to make upstream bug report. z`rectify_completions` is a provisional API (as of IPython 6.0). It may change without warnings. Use in corresponding context manager.r8ryNcsrrrrAr,r,r-rFrz&rectify_completions..csrrrrAr,r,r-rFrjediIPCompleter.python_matchesrxz#IPython.python matches have extras:)r2r{r'rrrrGrurwrvrnrrsrkrm differenceprint) rwrrstartsendsrr seen_jediseen_python_matchesrCrdiffr,r,r-rectify_completionss0"     rz `!@#$^&*()=+[{]}|;'",<>?z `!@#$^&*()=+[{]}\|;:'",<>?z = c@sJeZdZdZeZdZdZd ddZe ddZ e j ddZ d dd Z dS) CompletionSplitteraWAn 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)NcCs|durtjn|}||_dSr)r_delimsdelims)rorr,r,r-rp/s zCompletionSplitter.__init__cCs|jS)z*Return the string of delimiter characters.)rrqr,r,r-r3szCompletionSplitter.delimscCs8dddd|Dd}t||_||_||_dS)z&Set the delimiters for line splitting.[r>cs|]}d|VqdSr?r,rAr,r,r-rF;z,CompletionSplitter.delims..]N)rJrecompile _delim_rer _delim_expr)rorexprr,r,r-r8s  cCs(|dur|n|d|}|j|dS)zBSplit a line of text with a cursor at the given position. Nr_)rsplit)roline cursor_poslr,r,r- split_line@szCompletionSplitter.split_liner) r(r)r*r+DELIMSrrrrppropertyrsetterrr,r,r,r-rs   rcseZdZedddjddZeeddjddZedd djddZ edd djddZ edd djddZ dfd d Z ddZ ddZddZZS)r#FaActivate greedy completion PENDING DEPRECATION. this is now mostly taken care of with Jedi. 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. helpTconfigzYExperimental: Use Jedi to generate autocompletions. Default to True if jedi is installed. default_valuerizExperimental: restrict time (in milliseconds) during which Jedi can compute types. Set to 0 to stop computing types. Non-zero value lower than 100ms may hurt performance by preventing jedi to build its cache. zaEnable debug for the Completer. Mostly print extra information for experimental jedi integration.zEnable unicode completions, e.g. \alpha . Includes completion of latex commands, unicode names, and expanding unicode characters back to latex commands.Nc sR|durd|_nd|_||_|duri|_n||_g|_tt|jdi|dS)aCreate 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. NTFr,) use_main_ns namespaceglobal_namespacecustom_matcherssuperr#rp)rorrkwargs __class__r,r-rpgszCompleter.__init__cCsZ|jrtj|_|dkrd|vr|||_n|||_z|j|WSty,YdSw)zReturn 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'. r.N)r__main____dict__r attr_matchesmatchesglobal_matches IndexError)rorwstater,r,r-rjs   zCompleter.completecsg}|j}t|}tjtj|j|jfD]}|D]}|d||kr/|dkr/||qqt d|j|jfD]$}fdd|D}|D]}|d||krc|dkrc|||qOq@|S)zCompute 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. N __builtins__z[^_]+(_[^_]+)+?\Zcs2i|]}|rddd|dD|qS)r]cSg|]}|dqSrr,)rBsubr,r,r- z7Completer.global_matches...)matchrJr)rBrb snake_case_rer,r- s "z,Completer.global_matches..) appendrQkeywordkwlist builtin_modrkeysrrrr)rorwr match_appendnlstrb shortenedr,rr-rs4    zCompleter.global_matchesc std|}|r|dd\n|jr(td|j}|sgS|dd\ngSzt|j}Wnzt|j}Wn gYYSY|jrVt |drVt |}nt |}zt ||}WntykYntyrtyzYnwtfdd|DS) aCompute 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 also considered.) WARNING: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated. z(\S+(\.\w+)*)\.(\w*)$rOz (.+)\.(\w*)$r8__all__cs(g|]}|dkrd|fqS)Nz%s.%sr,rBwattrrrr,r-rs(z*Completer.attr_matches..)rrgroupgreedy line_bufferevalrrlimit_to__all__hasattrget__all__entriesrrcomplete_objectrAssertionError ExceptionrQ)rorwmm2objwordsr,rr-rs>      zCompleter.attr_matches)NN)r(r)r*rtagrJEDI_INSTALLEDuse_jedirjedi_compute_type_timeoutdebugbackslash_combining_completionsrprjrr __classcell__r,r,rr-r#Hs< !cCs,zt|d}WngYSdd|DS)z,returns the strings in the __all__ attributercSsg|] }t|tr|qSr,) isinstancerrr,r,r-rz%get__all__entries..)getattr)rrr,r,r-rs rrprefixr extra_prefixc s|r|ndtfdd}gfdd}|D]}t|tr-||r,||q||q|s>dddd DfStd |}|d usJJ|}z t||i} WntyeddgfYSwd dd d|Dd} t| |tj } | d usJ| } | } g}D]O}z | | sWqWn t t tfyYqw|t| d }t|trt|dnt|d}|d|dd}|dkr|dd}|d| |fq|| |fS)a*Used by dict_key_matches, matching the prefix to a list of keys Parameters ---------- keys list of keys in dictionary currently being completed. prefix Part of the text already typed by the user. E.g. `mydict[b'fo` delims String of delimiters to consider when finding the current key. extra_prefix : optional Part of the text already typed in multi-key index cases. E.g. for `mydict['foo', "bar", 'b`, this would be `('foo', 'bar')`. Returns ------- A tuple of three elements: ``quote``, ``token_start``, ``matched``, with ``quote`` being the quote that need to be used to close current string. ``token_start`` the position where the replacement should start occurring, ``matches`` a list of replacement/completion r,csTt|krdS|D] }t|ttfsdSq t|D] \}}||kr'dSqdS)NFT)rQrrbyteszip)keykpt)Nprefix prefix_tupler,r-filter_prefix_tuples z,match_dict_keys..filter_prefix_tuplecs t|ttfr|dSdSr)rrrrr) filtered_keysr,r-_add_to_filtered_keys#sz.match_dict_keys.._add_to_filtered_keysr>rcSsg|]}t|qSr,)reprrBrr,r,r-r/rz#match_dict_keys..z["']Nz[^csrr?r,rAr,r,r-rF8rz"match_dict_keys..z]*$r7"rOr9z\"z%s%s)rQrtuplersearchrrrrJUNICODErurPAttributeError TypeError UnicodeErrorrrindexrZr)rrrrrrr quote_matchquote prefix_strpattern token_match token_start token_prefixmatchedrremrem_reprr,)rrrr-match_dict_keyssT          "  rrcolumncCsP|d}|t|ksJdt|tt|tdd|d|D|S)a Convert the (line,column) position of the cursor in text to an offset in a string. Parameters ---------- text : str The text in which to calculate the cursor offset line : int Line of the cursor; 0-indexed column : int Column of the cursor 0-indexed Returns ------- Position of the cursor in ``text``, 0-indexed. See Also -------- position_to_cursor : reciprocal of this function  z{} <= {}css|] }t|dVqdS)rON)rQ)rBrr,r,r-rFqsz%cursor_to_position..N)rrQformatrsum)rwrrlinesr,r,r-cursor_to_positionWs (r!offsetcCsbd|kr t|ksnJd|t|f|d|}|d}|d}t|d}||fS)a: Convert the position of the cursor in text (0 indexed) to a line number(0-indexed) and a column number (0-indexed) pair Position should be a valid position in ``text``. Parameters ---------- text : str The text in which to calculate the cursor offset offset : int Position of the cursor in ``text``, 0-indexed. Returns ------- (line, column) : (int, int) Line of the cursor; 0-indexed, column of the cursor 0-indexed See Also -------- cursor_to_position : reciprocal of this function rz 0 <= %s <= %sNrr_)rQrr:)rwr"beforeblinesrcolr,r,r-position_to_cursorss .    r&cCs|tjvot|tt||S)z@Checks if obj is an instance of module.class_name if loaded )rHmodulesrrr)rmodule class_namer,r,r-_safe_isinstances r*cCsvt|dkrdS|d}|dkrdS|d}|tjvs|dvr!dSzt|}d|d|ffWSty:YdSw)uvMatch 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 ... Returns ======= Return a tuple with two elements: - The Unicode character that was matched (preceded with a backslash), or empty string, - a sequence (of 1), name for the match Unicode character, preceded by backslash, or empty if no match. r8r>r,r r@r_r7r9)rQstring ascii_letters unicodedatariKeyError)rw maybe_slashcharunicr,r,r-back_unicode_name_matchess   r4cCspt|dkrdS|d}|dkrdS|d}|tjvs|dvr!dSz t|}d||gfWSty7YdSw)uWMatch latex characters back to unicode name This does ``\ℵ`` -> ``\aleph`` r8r+r r@r_r,)rQr-r.rr0)rwr1r2latexr,r,r-back_latex_name_matchess  r6cCs(|j}|dstd||ddS)a Get parameter name and value from Jedi Private API Jedi does not expose a simple way to get `param=value` from its API. Parameters ---------- parameter Jedi's function `Param` Returns ------- A string like 'a', 'b=1', '*args', '**kwargs' zparam zWJedi function parameter description have change format.Expected "param ...", found %r".N) descriptionrP ValueError) parameterr8r,r,r-_formatparamchildrens   r;cCsft|dr |}|s dS|d}d|jddddSddd d d d |DDS) aR Make the signature from a jedi completion Parameters ---------- completion : jedi.Completion object does not complete a function type Returns ------- a string consisting of the function signature, with the parenthesis but without the function name. example: `(a, *args, b=1, **kwargs)` get_signaturesz(?)r(rO)maxsplitz(%s)z, cSsg|]}|r|qSr,r,rBfr,r,r-r s z#_make_signature..css&|]}|D]}t|VqqdSr) defined_namesr;)rBrmpr,r,r-rF s z"_make_signature..)rr< to_stringrrJ) completion signaturesc0r,r,r-_make_signatures  &rGc@s6eZdZUeed<eeed<eeed<eed<dS)_CompleteResult matched_textrmatches_origin jedi_matchesN)r(r)r*r__annotations__r r r,r,r,r-rHs    rHc seZdZUdZdZeeeefe d<e dddZ e ddd Z e d d d jd d Zed dddjd d Ze ddd jd d Ze dddjd d Zedddjd d Ze dddZ dRfdd ZedeefddZdedeefddZdefd d!Zdefd"d#Zdedeefd$d%Z defd&d'Z!dedeefd(d)Z"dedeefd*d+Z#d,e$d-e$dede%efd.d/Z&dedeefd0d1Z'd2d3Z(d4d5Z)d6d7Z*e+d8edeefd9d:Z,dedeefd;d<Z-e+dede.eeeffd=d>Z/dede.ee0effd?d@Z1dAdBZ2dedCe$de3e4fdDdEZ5dFedCe$de3e4fdGdHZ6dSde.ee0effdIdJZ7ddddKde8fdLdMZ9dede.ee0effdNdOZ:edeefdPdQZ;Zupdate the splitter and readline delims when greedy is changednewN) GREEDY_DELIMSsplitterrrrochanger,r,r-_greedy_changeds  zIPCompleter._greedy_changedFz%Whether to show dict key matches onlyrTzWhether to merge completion results into a single list If False, only the completion results from the first non-empty completer will be returned. r)rrOr8r8a1Instruct 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. ra3 DEPRECATED as of version 5.0. Instruct 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 zEIf True, emit profiling data for completion subsystem using cProfile.z.completion_profileszBTemplate for path at which to output profile data for completions.rcCstdtdS)Nz`IPython.core.IPCompleter.limit_to__all__` configuration value has been deprecated since IPython 5.0, will be made to have no effects and then removed in future version of IPython.)r2r{ UserWarningrQr,r,r-_limit_to_all_changedSsz!IPCompleter._limit_to_all_changedc st|_t|_tjd |||d|g|_||_t d|_ t j |_ t j dd}|dv|_tjdkr:|j|_n|j|_t d|_t d|_|j|jg|_d |_d |_d S) aIPCompleter() -> completer Return a completer object. Parameters ---------- 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 : dict, optional an optional dict where completions are performed. global_namespace : dict, optional secondary optional dict for completions, to handle cases (such as IPython embedded inside functions) where both Python scopes are visible. config : Config traitlet's config object **kwargs passed to super class unmodified. )rrrz([^\\] )TERMxterm)dumbemacsr%z^[\w|\s.]+\(([^)]*)\).*z[\s|\[]*(\w+)(?:\s*=\s*.*)Nr,)r magic_escaperrPrrprshellrr space_name_reglobrRenvironget dumb_terminalrHrI_clean_glob_win32 clean_glob _clean_globdocstring_sig_redocstring_kwd_remagic_config_matchesmagic_color_matchesmagic_arg_matcherscustom_completers_unicode_names)ror[rrrrtermrr,r-rpZs2       zIPCompleter.__init__rMcCsX|jr|jgS|jrg|j|j|j|jSg|j|j|j|j|j|jS)z*All active matcher routines for completion)dict_keys_onlydict_key_matchesrr file_matches magic_matchespython_matchespython_func_kw_matchesrqr,r,r-matcherss2zIPCompleter.matchersrwcsb|ddtfdd|t|DWdS1s%wY|dS)zQ Wrapper around the completion methods for the benefit of emacs. rrcs,g|]}rjrd|jgn|jqS)r)rrJrwrArror,r-rs$z/IPCompleter.all_completions..NrO) rpartitionr6rrQrjrorwr,rsr-all_completionss  zIPCompleter.all_completionscCs|d|S)N%s*r]rur,r,r-rcszIPCompleter._clean_globcCsdd|d|DS)NcSsg|]}|ddqS)r@/rYr?r,r,r-rsz1IPCompleter._clean_glob_win32..rwrxrur,r,r-ras zIPCompleter._clean_glob_win32csz|dr|dd}dnd|j}t|d|vsd|vr"|}n*zt|d}Wn!tyAr;|d}ngYSYn tyKd}Ynws\|t|kr\d}||}nd }tj |}|dkrtfd d | d DSt j d kr||}n ||dd}|rt|fdd |D}nrt j d kr|nfdd |D}n fdd |D}dd |DS)aMatch 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.!rONr>r=rr_TFcg|]}t|qSr,rKr? text_prefixr,r-rz,IPCompleter.file_matches..*r%r@cs$g|]}t|dqSrr|r?) len_lsplittext0r~r,r-rs csg|]}t|qSr,r|r?) open_quotesr,r-rscr{r,r|r?r}r,r-rs cSs$g|]}tj|r|dn|qS)ry)rRrLisdirrBxr,r,r-rs$)rPtext_until_cursorr=rr9rrrKrRrLrSr]rHrIrbrZrQ)rorwrlsplithas_protectablesm0rr,)rrrr~r-rnsR         zIPCompleter.file_matchescs|jj}|d}|d}|j|}|||s.fddnfddfdd|D}|sO|fdd|D7}|S) z Match magicsrcellcs|o|vS)z Filter magics, in particular remove magics that match a name present in global namespace. rPmagic) bare_textrr,r-r9s z*IPCompleter.magic_matches..matchescs |Srrr)rr,r-rAs cg|] }|r|qSr,r,rBr)rpre2r,r-rDz-IPCompleter.magic_matches..crr,r,r)rprer,r-rFr)r[magics_managerlsmagicrZrPlstripr)rorwlsm line_magics cell_magicsexplicit_magiccompr,)rrrrrr-ro s     zIPCompleter.magic_matchescs|tdkrddksddkrttdd|jjDddd}d d|D}td kr8|Sd d }|dfd d|D}d d dkrW|St|d kr|dkr||j }| }t t d t jd|}fdd|DSgS)z4 Match class names and attributes for %config magic rrz%configcSsg|] }|jjddr|qS)Tr)r class_traitsrAr,r,r-rPs  z4IPCompleter.magic_config_matches..cSs|jjSrrr(rr,r,r-Rsz2IPCompleter.magic_config_matches..rcSsg|]}|jjqSr,rrAr,r,r-rSrrOrcg|] }|r|qSr,rrA) classnamer,r-r\ z^--r>cs(g|]}|dr|ddqS)rOr^r)rPr)rBr)textsr,r-rhs )striprrQsortedrGr[ configurablesfindrrclass_get_helprrr MULTILINE splitlines)rorwclasses classnamesclassname_textsclassname_matchesclsrr,)rrr-rfJs, $     z IPCompleter.magic_config_matchescsb|}|dr|dt|dkr/|ddks |ddkr/|dfdd tDSgS) z& Match color schemes for %colors magicr&r>r8rcolorsz%colorsrOcrr,r)rBcolorrr,r-rwrz3IPCompleter.magic_color_matches..)rrarrQrr)rorwrr,rr-rgms  $zIPCompleter.magic_color_matches cursor_column cursor_linec Cs|jg}|jdur||jdd}t|||}|rK||d}|dkrK|jdkr/dd}n|jdkr9dd}n|jd krCd d}ntd |jt|d||}d } z.d } zt dd| j j D} Wn t yrYnwt| jd ko| jd dv} | } Wnty} z|jrtd| dWYd} ~ nd} ~ ww| sgSz t||j||ddWSty} z|jrtd| gWYd} ~ SgWYd} ~ Sd} ~ ww)a? Return a list of :any:`jedi.api.Completions` object from a ``text`` and cursor position. Parameters ---------- cursor_column : int column position of the cursor in ``text``, 0-indexed. cursor_line : int line position of the cursor in ``text``, 0-indexed text : str text to complete Notes ----- If ``IPCompleter.debug`` is ``True`` may return a :any:`_FakeJediCompletion` object containing a string with the Jedi debug information attached. NcS|Srr,rr,r,r-rz+IPCompleter._jedi_matches..rOrr8cSs|jd S)Nr])rirPrCr,r,r-rscSs|jdo |jd S)Nr\)rirPrarr,r,r-rrrcSrrr,rr,r,r-rrz'Don't understand self.omit__names == {}TFcss|] }t|dr|VqdS)valueN)rrAr,r,r-rFsz,IPCompleter._jedi_matches..>r7r9z5Error detecting if completing a non-finished string :|)rrzJOops Jedi has crashed, please report a bug with the following: """ %s s""")rrrr! omit__namesr9rr Interpreternext _get_module tree_nodechildren StopIterationrQrrrrfilterrjrf) rorrrw namespacescompletion_filterr"r interpretertry_jedicompleting_string first_childer,r,r- _jedi_matches{sR             zIPCompleter._jedi_matchescCsd|vr:z)||}|dr(|jr+|jdkrdd}ndd}t||}W|SW|SW|Sty9g}Y|Sw||}|S)z'Match attributes or global python namesrrOcSstd|duS)Nz .*\.__.*?__)rrtxtr,r,r-rsz,IPCompleter.python_matches..cSstd||ddduS)Nz\._.*?r)rrrindexrr,r,r-rs)rrarr NameErrorr)rorwrno__namer,r,r-rps&      rcCsh|durgS|d}|j|}|durgS|dd}g}|D] }||j|7}q'|S)aParse 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)'. Nr,)rrrdr groupsrrefindall)rodocrsigretr<r,r,r-!_default_arguments_from_docstrings z-IPCompleter._default_arguments_from_docstringcs|}g}t|r n/t|s9t|s9t|r1||t|dd7}t|ddp/t|dd}nt|dr9|j}||t|dd7}tj j tj j fzt |}| fdd|jDWn tykYnwtt|S) z_Return the list of default arguments of obj if it is callable, or empty list otherwise.r+r>rpN__new____call__c3s"|] \}}|jvr|VqdSr)kind)rBrv_keepsr,r-rFs  z1IPCompleter._default_arguments..)inspect isbuiltin isfunctionismethodisclassrrrr Parameter KEYWORD_ONLYPOSITIONAL_OR_KEYWORDrmextend parametersitemsr9rrG)rorcall_objrrr,rr-_default_argumentss6        "  zIPCompleter._default_argumentscCsd|vrgSz|j}Wnty!tdtjtjB}|_Ynw||j}t|}d}|D]}|dkr;|d8}q0|dkrI|d7}|dkrInq0gSg}tdj } z| t |||d si| Wnt |dksqWn Wn t y{YnwqUt} d } t||dd D]$\}} |dkr| d7} n|dkr| d8} | dkrq| d krq| |qg} z+d|d d d } |t| |j}t|| D]}||r| d |qW| SY| S) z9Match named parameters (kwargs) of the last open functionrz '.*?(?)rrrOrcsg|]}|qSr,r,rleadingsufr,r-rrz0IPCompleter.dict_key_matches..)rMrrrr rrrrrrrrrPrrQrurvrrP)rorwregexpsdict_key_re_fmtrrprefix0rrrr closing_quote token_offsetr text_start key_startcompletion_start bracket_idx continuationr,r r-rmus\                 zIPCompleter.dict_key_matchescCst|d}|dkr6||dd}zt|}d|r%d||gfWSWdgfSty5YdgfSwdgfS)uMatch Latex-like syntax for unicode characters base on the name of the character. This does ``\GREEK SMALL LETTER ETA`` -> ``η`` Works only on valid python 3 identifier, or on combining characters that will combine to form a valid identifier. r@r_rONar>)rfindr/lookup isidentifierr0)rwslashposr<r3r,r,r-unicode_name_matchess    z IPCompleter.unicode_name_matchescsV|d}|dkr)||dtvrtgfSfddtD}|r)|fSdS)u{Match Latex syntax for unicode characters. This does both ``\alp`` -> ``\alpha`` and ``\alpha`` -> ``α`` r@r_Ncrr,rrr;r,r-rrz-IPCompleter.latex_matches..r+)rr)rorwrrr,r;r- latex_matchess  zIPCompleter.latex_matchesc s|jsdS|j}|sdSt}||_|_|ddd}||_|j|_| |j s6|j |j |}ng}t |j |||j|jD]>}z(||}|rqfdd|D}|ra|WSfdd|DWSWqHty{YqHty YdSwdS)NrOrcrr,rrBr)rwr,r-r'rz9IPCompleter.dispatch_custom_completer..csg|] }|r|qSr,)lowerrPr)text_lowr,r-r,s)rirrrrsymbolrcommandrrPrZ s_matches itertoolschain flat_matchesrrKeyboardInterrupt) rorwreventcmd try_magicrCreswithcaser,)rwr r-dispatch_custom_completersJ     z%IPCompleter.dispatch_custom_completerr"c cs,tjdtddt}zdz1|jrddl}|}|nd}|j|||j ddD]}|r4||vr4q+|V| |q+Wn t yH YnwW|duro| t |jtj|jtt}td|||dSdS|dur| t |jtj|jtt}td|||ww) a Returns an iterator over the possible completions .. warning:: Unstable This function is unstable, API may change without warning. It will also raise unless use in proper context manager. Parameters ---------- text : str Full text of the current input, multi line string. offset : int Integer representing the position of the cursor in ``text``. Offset is 0-based indexed. Yields ------ Completion Notes ----- The cursor on a text can either be seen as being "in between" characters or "On" a character depending on the interface visible to the user. For consistency the cursor being on "in between" characters X and Y is equivalent to the cursor being "on" character Y, that is to say the character the cursor is on is considered as being after the cursor. Combining characters may span more that one position in the text. .. note:: If ``IPCompleter.debug`` is :any:`True` will yield a ``--jedi/ipython--`` fake Completion token to distinguish completion returned by Jedi and usual IPython completion. .. note:: Completions are not completely deduplicated yet. If identical completions are coming from different sources this function does not ensure that each completion object will only be present once. zy_complete is a provisional API (as of IPython 6.0). It may change without warnings. Use in corresponding context manager.r8ryrNi)_timeoutzWriting profiler output to)r2r{r'rGprofile_completionscProfileProfileenable _completionsrrr'disablerprofiler_output_dirrRrLrJruuiduuid4r dump_stats)rorwr"rr0profilerrC output_pathr,r,r-r8sF.          zIPCompleter.completions full_textc cst|}|d|}t||\}}|j|||d\}} } } t| } |ro| D]F} z| j}WntyB|jr>td| d}Ynwt | j t | j }|dkrVt | }nd}t |||| j ||ddVt|krnnq(| D]} t | j t | j }t |||| j dddd Vqq||}| r| r|jrt ||d d d dd V||sJt| | D]\}}t ||||dddVqdS)ax Core completion module.Same signature as :any:`completions`, with the extra `timeout` parameter (in seconds). Computing jedi's completion ``.type`` can be quite expensive (it is a lazy property) and can require some warm-up, more warm up than just computing the ``name`` of a completion. The warm-up can be : - Long warm-up the first time a module is encountered after install/update: actually build parse/inference tree. - first time the module is encountered in a session: load tree from disk. We don't want to block completions for tens of seconds so we give the completer a "budget" of ``_timeout`` seconds per invocation to compute completions types, the completions that have not yet been computed will be marked as "unknown" an will have a chance to be computed next round are things get cached. Keep in mind that Jedi is not the only thing treating the completion so keep the timeout short-ish as if we take more than 0.3 second we still have lots of processing to do. N)r;rrzError in Jedi getting type of functionr>rrtz )rurvrwrkrnrmz--jedi/ipython--rnone)rurvrwrnrkrm)rurvrwrnrmrk)time monotonicr& _completeiterrkrrrrQrlrjrGrsrrar)ror;r"r.deadliner#rrrIrrJrKiter_jmjmtype_deltarm start_offsetrtr,r,r-r3sb        zIPCompleter._completionscCs&tdt|j|||ddddS)aFind 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 ------- Tuple of two items: text : str Text that was actually used in the completion. matches : list A list of completion matches. Notes ----- This API is likely to be deprecated and replaced by :any:`IPCompleter.completions` in the future. zn`Completer.complete` is pending deprecation since IPython 6.0 and will be replaced by `Completer.completions`.r)rrrwrNr8)r2r{PendingDeprecationWarningr@)rorwrrr,r,r-rjs"zIPCompleter.complete)rrwr;cs|dur|dur t|nt|}|jrtj|_|s"|r"|d|}|s/|r-|j||nd}|jrg|s6|n|d|}|j |j t t |j fD] }||\}} |rft|| dt|jgtt| tdSqF|durm|}||_|jd||_|jD]t|dt} | rjgt| } t|| | dSq{g} t|dko|ddk} g} |jr| s|s|}||||} |jrg} |jD]z| fdd|DWqtjtYqn|jD]fd d|D} | rnqt}t}| D]}|\}}||vr||||qt |d d d }d d|!|p)gD}|p0|}|dt}dd|D}dd|D} ||_"t||| | S)aQ Like complete but can also returns raw jedi completions as well as the origin of the completion text. This could (and should) be made much cleaner but that will be simpler once we drop the old (and stateful) :any:`complete` API. With current provisional API, cursor_pos act both (depending on the caller) as the offset in the ``text`` or ``line_buffer``, or as the ``column`` when passing multiline strings this could/should be renamed but would add extra noise. Parameters ---------- cursor_line Index of the line the cursor is on. 0 indexed. cursor_pos Position of the cursor in the current line/line_buffer/text. 0 indexed. line_buffer : optional, str The current line the cursor is in, this is mostly due to legacy reason that readline could only give a us the single current line. Prefer `full_text`. text : str The current "token" the cursor is in, mostly also for historical reasons. as the completer would trigger only after the current line was parsed. full_text : str Full text of the current cell. Returns ------- A tuple of N elements which are (likely): matched_text: ? the text that the complete matched matches: list of completions ? matches_origin: ? list same length as matches, and where each completion came from jedi_matches: list of Jedi matches, have it's own structure. Nrr>r,rr`cg|]}|jfqSr,r*rmatcherr,r-rjz)IPCompleter._complete..crJr,rKrrLr,r-rrrNcSs t|dS)Nr)rerr,r,r-rs z'IPCompleter._complete..rcSsg|]}|dfqS)customr,rr,r,r-rrcSrrr,rr,r,r-rrcSr)rOr,rr,r,r-rr)#rQrrrrrrPrrrrr6r4fwd_unicode_matchrH MATCHES_LIMITr*rrrrhrrrmerge_completionsrrrrH excepthookexc_inforGrrr-r)rorrrrwr; base_textmeth name_text name_matchesroriginsis_magic_prefixrrfiltered_matchesrrHrC_filtered_matches custom_res_matchesr,rLr-r@s+           zIPCompleter._completecs|d}|dkrL||dd}|fdd|jD}|r%||fSfdd|jD}|r5||fSdfd d|jD}|rJ||fSd Sd S) a} Forward match a string starting with a backslash with a list of potential Unicode completions. Will compute list list of Unicode character names on first call and cache it. Returns ------- At tuple with: - matched text (empty if no matches) - list of potential completions, empty tuple otherwise) r@r_rONcrr,rrsupr,r-rrz1IPCompleter.fwd_unicode_match..csg|]}|vr|qSr,r,rr_r,r-rrr&cs&g|]tfddDrqS)c3s|]}|vVqdSrr,)rBurr,r-rFrz;IPCompleter.fwd_unicode_match...)all)rB)splitsuprr-rs r+)rupper unicode_namesr)rorwrr< candidatesr,)rcr`r-rPs$   zIPCompleter.fwd_unicode_matchc CsX|jdur)g}tddD]}z |tt|Wq ty#Yq wtt|_|jS)z}List of names of unicode code points that can be completed. The list is lazily initialized on first access. Nri) rjrangerr/richrr9_unicode_name_compute_UNICODE_RANGES)rorrCr,r,r-res   zIPCompleter.unicode_names)NNNN)NNN)=r(r)r*r+rMrr boolrrLr rSrrlrrRrrrr/rr5rUrprrr rrrrvrcrarnrorfrgrrrrprrrq staticmethodrrmrrr rr-rrsrr3rjrHr@rPrerr,r,rr-r$s      K R*#H"Lh 0NT)  :rangesc CsPg}|D]!\}}t||D]}z |tt|Wq ty$Yq wq|Sr)rgrr/rirhr9)rmrrustoprCr,r,r-ris  ri)r1r)pr+builtinsrr]rr$rrRrr-rHr>r/r6r2 contextlibr importlibrtypesrtypingrrrrr r r r r rrIPython.core.errorrIPython.core.inputtransformer2rIPython.core.latex_symbolsrrIPython.core.oinspectrIPython.testing.skipdoctestr IPython.utilsrIPython.utils.dir2rrIPython.utils.pathrIPython.utils.processr traitletsrrr ListTraitrrr traitlets.config.configurabler!r__skip_doctest__rsettingscase_insensitive_completionjedi.api.helpersjedi.api.classesr ImportErrorrjrrI PROTECTABLESrQ FutureWarningr'r4r6r=rKrrkrXr[rerfrs_ICrrrrOobjectrr#rrrrr!r&r*r4r6r;rGrHr$rir,r,r,r-sp   4       $       (  > * ;4( * ^"'&I