MhUdZddlmZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddl mZddlmZddlmZddlmZddlmZmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,m-Z-dd l.m/Z/dd l0m1Z1ddl2m3Z3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:ddl;mZ>m?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZImJZKmLZLmMZNmOZOm#ZPmQZQddlRmSZSddlTmUZUddlVZVddl mWZWejXdkrddlYmZZZm[Z[m\Z\m]Z]m^Z^nddl mZZZm[Z[m\Z\m]Z]m^Z^dZ_ ddl`Z`de`ja_bddlcZ`ddldZ`dZen #ef$rdZeYnwxYwdd gZgd!d"gZhejid#krd$Zjnd%Zjd&Zkd'ZlemZnGd(d)eoZpejqd*ep+e6edd-Zrdd2Zsejfdd4Ztdd7Zudd;Zvd<ZwGd=d>Zxe#d?exfZyGd@dAZzGdBdCZ{GdDdEeZZ|e α 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 :kbd:`Tab` to expand it to its latex form. .. code:: \α \alpha Both forward and backward completions can be deactivated by setting the :std:configtrait:`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 almost any code unlike the deprecated :any:`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. Matchers ======== All completions routines are implemented using unified *Matchers* API. The matchers API is provisional and subject to change without notice. The built-in matchers include: - :any:`IPCompleter.dict_key_matcher`: dictionary key completions, - :any:`IPCompleter.magic_matcher`: completions for magics, - :any:`IPCompleter.unicode_name_matcher`, :any:`IPCompleter.fwd_unicode_matcher` and :any:`IPCompleter.latex_name_matcher`: see `Forward latex/unicode completion`_, - :any:`back_unicode_name_matcher` and :any:`back_latex_name_matcher`: see `Backward latex completion`_, - :any:`IPCompleter.file_matcher`: paths to files and directories, - :any:`IPCompleter.python_func_kw_matcher` - function keywords, - :any:`IPCompleter.python_matches` - globals and attributes (v1 API), - ``IPCompleter.jedi_matcher`` - static analysis with Jedi, - :any:`IPCompleter.custom_completer_matcher` - pluggable completer with a default implementation in :any:`InteractiveShell` which uses IPython hooks system (`complete_command`) with string dispatch (including regular expressions). Differently to other matchers, ``custom_completer_matcher`` will not suppress Jedi results to match behaviour in earlier IPython versions. Custom matchers can be added by appending to ``IPCompleter.custom_matchers`` list. Matcher API ----------- Simplifying some details, the ``Matcher`` interface can described as .. code-block:: MatcherAPIv1 = Callable[[str], list[str]] MatcherAPIv2 = Callable[[CompletionContext], SimpleMatcherResult] Matcher = MatcherAPIv1 | MatcherAPIv2 The ``MatcherAPIv1`` reflects the matcher API as available prior to IPython 8.6.0 and remains supported as a simplest way for generating completions. This is also currently the only API supported by the IPython hooks system `complete_command`. To distinguish between matcher versions ``matcher_api_version`` attribute is used. More precisely, the API allows to omit ``matcher_api_version`` for v1 Matchers, and requires a literal ``2`` for v2 Matchers. Once the API stabilises future versions may relax the requirement for specifying ``matcher_api_version`` by switching to :any:`functools.singledispatch`, therefore please do not rely on the presence of ``matcher_api_version`` for any purposes. Suppression of competing matchers --------------------------------- By default results from all matchers are combined, in the order determined by their priority. Matchers can request to suppress results from subsequent matchers by setting ``suppress`` to ``True`` in the ``MatcherResult``. When multiple matchers simultaneously request suppression, the results from of the matcher with higher priority will be returned. Sometimes it is desirable to suppress most but not all other matchers; this can be achieved by adding a set of identifiers of matchers which should not be suppressed to ``MatcherResult`` under ``do_not_suppress`` key. The suppression behaviour can is user-configurable via :std:configtrait:`IPCompleter.suppress_competing_matchers`. ) annotationsN) literal_eval) defaultdict)contextmanager) dataclass)cached_propertypartial)SimpleNamespace) IterableIteratorUnionAnySequenceOptional TYPE_CHECKINGSizedTypeVarLiteral) guarded_evalEvaluationContext)TryNext) ESC_MAGIC) latex_symbolsreverse_latex_symbol) skip_doctest)generics) theme_table)sphinx_options)dir2get_real_method)GENERATING_DOCUMENTATION)ensure_dir_exists) arg_split) BoolEnumIntListUnicodeDictDottedObjectNamer observe) Configurable) import_item)cast) ) TypedDict NotRequiredProtocol TypeAlias TypeGuardTF) i#)ii Completer IPCompleterwin32 z ()[]{}?=\|;:'#*"^&iz ceZdZdZdS)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__V/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/IPython/core/completer.pyr<r<(s  DrBr<errorcategoryignorec#Ktj5tj|tdVddddS#1swxYwYdS)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! rEN)warningscatch_warningsfilterwarningsr<)actions rCprovisionalcompleterrM4s2  " "1LMMMM s AA AsstrreturnUnion[str, bool]cn|ddzrdS|ddzrdSdS)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)count)rNs rChas_open_quotesrWRsA wws||as  surB protectablesct|tzr9tjdkrd|zdzSdfd|DS|S)z.Escape a string to protect certain characters.r9rSc3.K|]}|vrd|zn|VdS\NrA).0crXs rC z#protect_filename..ms5MMa\(9(9D1HHqMMMMMMrB)setsysplatformjoin)rNrXs `rCprotect_filenameregse 1vvL!!! <7 " "7S= 77MMMM1MMMMM MrBpathtuple[str, bool, str]cd}d}|}|drCd}t|dz }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. FrZ~TN) startswithlenosrf expanduser)rf tilde_expand tilde_valnewpathrests rC expand_userrsrs{0LIG s  4yy{'$$T**  $III L) ++rBroboolrpc6|r||dS|S)z8Does the opposite of expand_user, with its outputs. rireplace)rfrorps rC compress_userrxs%||Is+++ rBcXd\}}|drd}n|drd}|drd}|drd |dd vr |dd }d}n-|d rd |dd vr |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__rT_rj=z%%%N)rkendswith)wordprio1prio2s rCcompletions_sorting_keyrsLE5 t    }}S t d122h  8DE    d122h  8DE $ rBceZdZdZdZdZdS)_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 ch||_||_d|_||_d|_d|_d|_dS)NcrashedrZfake)namecompletetypename_with_symbols signature_origintext)selfrs rC__init__z_FakeJediCompletion.__init__s8   !%  rBcdS)Nz)rArs rC__repr__z_FakeJediCompletion.__repr__s::rBN)r=r>r?r@rrrArBrCrrs<;;;;;rBrzjedi.api.Completionc@eZdZdZgdZddddddZdZddZdZdS) Completionao Completion object used and returned 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``...). startendrrrrNrZrrrrintrrrOr Optional[str]rPNonectjdtd||_||_||_||_||_||_dS)Nz~``Completion`` is a provisional API (as of IPython 6.0). It may change without warnings. Use in corresponding context manager.rTrF stacklevel) rIwarnr<rrrrrr)rrrrrrrs rCrzCompletion.__init__sZ   41        " rBc `d|jd|jd|jd|jpdd|jpdd S)Nz)rrrrrrs rCrzCompletion.__repr__sHTXXXtyyy$)2Bs2B2BDNDYVYDYDY[ [rBrtcb|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. )rrr)rothers rC__eq__zCompletion.__eq__s7zU[($ H !$ I # $rBcDt|j|j|jfSN)hashrrrrs rC__hash__zCompletion.__hash__#sTZ495666rB) rrrrrrOrrrPr)rPrt) r=r>r?r@ __slots__rrrrrArBrCrrs0IHHI#2[[[ $ $ $ $77777rBrc.eZdZdZddgZddd dZd ZdS) SimpleCompletionaCompletion item to be included in the dictionary returned by new-style Matcher (API v2). .. warning:: Provisional This class is used to describe the currently supported attributes of simple completion items, and any additional implementation details should not be relied on. Additional attributes may be included in future versions, and meaning of text disambiguated from the current dual meaning of "text to insert" and "text to used as a label". rrNrrOrc"||_||_dSrrr)rrrs rCrzSimpleCompletion.__init__7s  rBc(d|jd|jdS)Nzrrs rCrzSimpleCompletion.__repr__;sJJJDIJJJJrB)rrOrr)r=r>r?r@rrrrArBrCrr's_   I;?KKKKKrBrc<eZdZUdZded<ded<ded<ded <d S) _MatcherResultBasezFDefinition of dictionary to be returned by new-style Matcher (API v2).zNotRequired[str]matched_fragmentz"NotRequired[Union[bool, set[str]]]suppresszNotRequired[set[str]]do_not_suppresszNotRequired[bool]orderedNr=r>r?r@__annotations__rArBrCrr?sPPP'&&&1000+***rBrdict)show_inherited_membersexclude_inherited_fromceZdZUdZded<dS)SimpleMatcherResultz'Result of new-style completion matcher.z7Sequence[SimpleCompletion] | Iterator[SimpleCompletion] completionsNrrArBrCrrQs'11 IHHHHHrBrceZdZUdZded<dS)_JediMatcherResultz@Matching result returned by Jedi (will be processed differently)Iterator[_JediCompletionLike]rNrrArBrCrr\s&JJ/.....rBr AnyCompletioncveZdZUdZded<ded<ded<ded<ded <edd Zedd Zd S)CompletionContextzMCompletion context provided as an argument to matchers in the Matcher API v2.rOtoken full_textrcursor_position cursor_linez Optional[int]limitrPc*|jd|jSr)line_with_cursorrrs rCtext_until_cursorz#CompletionContext.text_until_cursors$%;t';%;<r?r@rrrrrArBrCrrgsWWJJJNNN ===_=<<<_<<r?rrrArBrCrrs4    rBrc"eZdZUded<d dZdS) _MatcherAPIv1TotalzOptional[Literal[1]]matcher_api_versionrrOrPrcdSrrArs rCrz_MatcherAPIv1Total.__call__rrBNr)r=r>r?rrrArBrCrrs6----      rBrr4 MatcherAPIv1c4eZdZUdZdZded<d d Zd ed <d S) MatcherAPIv2z#Protocol describing Matcher API v2.rTz Literal[2]rcontextrrP MatcherResultcdSrrA)rrs rCrzMatcherAPIv2.__call__rrBrOr?N)rrrPr)r=r>r?r@rrrrArBrCrrsN--'(''''    rBrMatchermatcherTypeGuard[MatcherAPIv1]c,t|}|dkS)Nrj_get_matcher_api_versionr api_versions rC_is_matcher_v1r*733K ! rBTypeGuard[MatcherAPIv2]c,t|}|dkS)NrTrrs rC_is_matcher_v2rrrBvaluerTypeGuard[Sized]c"t|dS)%Determines whether objects is sizable__len__hasattrrs rC _is_sizablers 5) $ $$rBTypeGuard[Iterator]c"t|dS)r__next__rrs rC _is_iteratorrs 5* % %%rBresultrcJ|d}t|rt|dkSt|r\ |}t|}t t t tj|g||d<dS#t$rYdSwxYwtd)z-Check if any result includes any completions.rrTFzCCompletions returned by matcher need to be an Iterator or a Sizable) rrlrnextr.r r itertoolschain StopIteration ValueError)rr old_iteratorfirsts rChas_any_completionsr s'K;%;1$$K   &L&&E$()*66%%F= !4   55  M  sAB BBrj)priority identifierrr Optional[float]r rrrCallable[[Matcher], Matcher]cdfd }|S)aWAdds attributes describing the matcher. Parameters ---------- priority : Optional[float] The priority of the matcher, determines the order of execution of matchers. Higher priority means that the matcher will be executed first. Defaults to 0. identifier : Optional[str] identifier of the matcher allowing users to modify the behaviour via traitlets, and also used to for debugging (will be passed as ``origin`` with the completions). Defaults to matcher function's ``__qualname__`` (for example, ``IPCompleter.file_matcher`` for the built-in matched defined as a ``file_matcher`` method of the ``IPCompleter`` class). api_version: Optional[int] version of the Matcher API used by this matcher. Currently supported values are 1 and 2. Defaults to 1. funcrcpd|_p|j|_|_tr7dkrt t |}ndkrt t|}|S)NrrjrT)matcher_priorityr?matcher_identifierrrr.rr)rrr r s rCwrapperz#completion_matcher..wrappersj ( A","A0A#.  0aL$//!!L$// rB)rrrA)r r rrs``` rCcompletion_matcherrs44         NrBc$t|ddS)Nrrgetattrrs rC_get_matcher_priorityr s 7. 2 22rBc.t|d|jS)Nr)rr?rs rC_get_matcher_idrs 70'2F G GGrBc$t|ddS)Nrrjrrs rCrrs 711 5 55rBrTrrr_ICc#BKt|}|sdStd|D}td|D}t}|D]F}|||j|jz||j|z}||vr|V||GdS)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. Nc3$K|] }|jV dSrrr^r_s rCr`z+_deduplicate_completions..;s$11AG111111rBc3$K|] }|jV dSrrr#s rCr`z+_deduplicate_completions..<s$--A!%------rB)listminmaxrarrradd)rr new_startnew_endseenr_new_texts rC_deduplicate_completionsr.s6{##K 11[11111I-------G 55D  !')*QV3d15=6II 4  GGG HHX    rB)_debugr/c #Ktjdtdt|}|sdSd|D}d|D}t |}t |}t }t }|D]} ||| j| jz|| j |z} | j dkr| | n | j dkr| | t||| | j | j | j V||} | r|rt!d | 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.rTrNc3$K|] }|jV dSrr"r#s rCr`z&rectify_completions..ms$ + +!ag + + + + + +rBc3$K|] }|jV dSrr%r#s rCr`z&rectify_completions..ns$ ' 'aAE ' ' ' ' ' 'rBjedizIPCompleter.python_matcherrz#IPython.python matches have extras:)rIrr<r&r'r(rarrrrr)rrr differenceprint) rrr/startsendsr*r+ seen_jediseen_python_matchesr_r-diffs rCrectify_completionsr;Fs> M971FFFF {##K  + +{ + + +F ' '; ' ' 'DF I$iiGI%% nn !')*QV3d15=6II 9   MM( # # # # Y6 6 6  # #H - - -GXAFAIabalmmmmmmm  ) )) 4 4D ;; 3T:::::;;;;rBz `!@#$^&*()=+[{]}|;'",<>?z `!@#$^&*()=+[{]}\|;:'",<>?z = cdeZdZdZeZdZdZddZe dZ e j dZ ddZ 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)Nc4| tjn|}||_dSr)r=_delimsdelims)rr@s rCrzCompletionSplitter.__init__s/5~#++6 rBc|jS)z*Return the string of delimiter characters.)r?rs rCr@zCompletionSplitter.delimss |rBcddd|Dzdz}tj||_||_||_dS)z&Set the delimiters for line splitting.[rZc3 K|] }d|zV dSr\rAr#s rCr`z,CompletionSplitter.delims..s&55T1W555555rB]N)rdrecompile _delim_rer? _delim_expr)rr@exprs rCr@zCompletionSplitter.delimssTRWW55f555555;D)) rBc^||n |d|}|j|dS)zBSplit a line of text with a cursor at the given position. Nr})rHr)rline cursor_poscut_lines rC split_linezCompletionSplitter.split_lines6&-444  3D~##H--b11rBr) r=r>r?r@DELIMSr?rIrHrpropertyr@setterrOrArBrCr=r=s > > G KIX ]  ] 222222rBr=ceZdZedddZeddd dZeed dZ e d d dZ edd dZ edddZ edddZeieddZeddddZd'fd ZdZdZdZejdZd(dZ d)d*d#Zd(d$Zd%Zed&Z xZ!S)+r7FalActivate greedy completion. .. deprecated:: 8.8 Use :std:configtrait:`Completer.evaluation` and :std:configtrait:`Completer.auto_close_dict_keys` instead. When enabled in IPython 8.8 or newer, changes configuration as follows: - ``Completer.evaluation = 'unsafe'`` - ``Completer.auto_close_dict_keys = True`` helpTconfig) forbiddenminimallimitedunsafe dangerousrZa#Policy for code evaluation under completion. Successive options allow to enable more eager evaluation for better completion suggestions, including for nested dictionaries, nested lists, or even results of function calls. Setting ``unsafe`` or higher can lead to evaluation of arbitrary user code on :kbd:`Tab` with potentially unwanted or dangerous side effects. Allowed values are: - ``forbidden``: no evaluation of code is permitted, - ``minimal``: evaluation of literals and access to built-in namespace; no item/attribute evaluation, no access to locals/globals, no evaluation of any operations or comparisons. - ``limited``: access to all namespaces, evaluation of hard-coded methods (for example: :any:`dict.keys`, :any:`object.__getattr__`, :any:`object.__getitem__`) on allow-listed objects (for example: :any:`dict`, :any:`list`, :any:`tuple`, ``pandas.Series``), - ``unsafe``: evaluation of all methods and function calls but not of syntax with side-effects like `del x`, - ``dangerous``: completely arbitrary evaluation; does not support auto-import. To override specific elements of the policy, you can use ``policy_overrides`` trait.  default_valuerUzYExperimental: Use Jedi to generate autocompletions. Default to True if jedi is installed.izExperimental: 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.a. Enable auto-closing dictionary keys. When enabled string keys will be suffixed with a final quote (matching the opening quote), tuple keys will also receive a separating comma if needed, and keys which are final will receive a closing bracket (``]``). zOverrides for policy evaluation. For example, to enable auto-import on completion specify: .. code-block:: ipython --Completer.policy_overrides='{"allow_auto_import": True}' --Completer.use_jedi=False )r^ key_traitrUzimportlib.import_modulea Provisional: This is a provisional API in IPython 9.3, it may change without warnings. A fully qualified path to an auto-import method for use by completer. The function should take a single string and return `ModuleType` and can raise `ImportError` exception if module is not found. The default auto-import implementation does not populate the user namespace with the imported module. )r^ allow_nonerUNc |d|_nd|_||_|i|_n||_g|_t t |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. NTFrA) use_main_ns namespaceglobal_namespacecustom_matcherssuperr7r)rrcrdkwargs __class__s rCrzCompleter.__init__'sq"  #D  $D &DN  #$&D ! !$4D !!'i'11&11111rBc|jrtj|_|dkr9d|vr|||_n|||_ |j|S#t$rYdSwxYw)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)rb__main____dict__rc attr_matchesmatchesglobal_matches IndexError)rrstates rCrzCompleter.completeHs   /%.DN A::d{{#0066 #22488  <& &   44 s A&& A43A4cg}|j}t|}tjtjt|jt|j fD]&}|D]!}|d||kr|dkr ||"'tj dt|jt|j fD]L}fd|D}|D]'}|d||kr|dkr|||(M|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[^_]+(_[^_]+)+?\Zci|]J}|dd|dD|KS)r{cg|] }|d S)rrA)r^subs rC z7Completer.global_matches...ss<<z,Completer.global_matches..rsd &&t,,<(> L&&& ' #788 ,,..//d6K6P6P6R6R1S1ST 2 2CI "(( 2 28t##(>(> L4111 2rBc8||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. r) _attr_matchesrs rCrmzCompleter.attr_matches|s!!$''**rBz (.+)\.(\w*)$coderOrPc hd}hd} ttjt|j}n#tj$rz||} ttjt|j}|}n#tj$r|cYcYSwxYwYnwxYwt|}d}g}d} |D]g} | j tj kr4| j |vr| dz } n%| j |vr| dz} n| j dkr | dkrd}g}K|r| | j h|rd |S|S) N>{(rC>})rEFrrjrjTrZ)r&tokenizegenerate_tokensiter splitlinesr TokenError _trim_expr _parse_tokensrOPstringr{rd) rro_parensc_parensr{ trimmed_codetokensencountered_operatorafter_operator nesting_levelts rC_strip_code_before_operatorz%Completer._strip_code_before_operators"??"?? X-d4??3D3D.E.E.NOOPPAA"   ??400L ,T,2I2I2K2K-L-L-UVV$&      t$$$  0 0Av$$8x''!Q&MMX))!Q&MMX__!););+/(%'N# 0%%ah///  77>** *Ks7AA$C5AB=<C=CCCCCrinclude_prefixrttuple[Sequence[str], str]c |j|}|sgdfS|dd\} ||}n#tj$rYnwxYw||}|turgdfS|jr t|drt|}nt|} tj ||}n%#t$rYnt$rt $rYnwxYwt# |rt%|}t'|}tjtjh} d} g} |D]} | j| vr | jtjkr| r| | jd} @| jtjkr*| jdkr| s| | jd} dt'| nd fd|Dd zfS) NrZrjrT__all__TFrjc:g|]}|dkd|S)NrjrA)r^wattrrprefix_after_spaces rCrwz+Completer._attr_matches..s4 O O O12A2$***AA .rB)_ATTR_MATCH_RErxgrouprrr_evaluate_expr not_foundlimit_to__all__rget__all__entriesrrcomplete_objectrAssertionError Exceptionrlrreversed ENDMARKERNEWLINErNAMEr{rrrd)rrrm2rJobjwordsr rev_tokens skip_over name_turnpartsrrrrs @@@rCrzCompleter._attr_matchesso & &t , , r6MXXa^^ d 33D99DD"    D !!$'' )  r6M   GC$;$; %c**EEIIE ,S%88EE    D        D  II  $"4((F!&))J!+X-=>IIE#  :**:..9.LL... %IIJ(+--%,#2E2Ei2ELL... $II!#%!9!9  !#  P O O O O O O O O $J  s)AA&%A&C C:$C:9C:c|r|dd} tj|}n#t$rY.wxYw|Jt|jdkrO|jdj}t |tjr |ddks|SdS)z Trim the code until it is a valid expression and not a tuple; return the trimmed expression for guarded_eval. rjNrr}rrZ)astparse SyntaxErrorrlbodyr isinstanceTuple)rrresrJs rCrzCompleter._trim_exprs  8D ioo    ???38}}!!8A;$D$ ** 48s??Krs # 00c ,t}d}|s|r t|t|j|j|j|j|j}d}nC#t$r6}|j rtd|| |}Yd}~nd}~wwxYw|s||S)NF)globalslocals evaluation auto_importpolicy_overridesTzEvaluation exception) rrrrdrcr _auto_importrrdebugr5r)rrJrdonees rCrzCompleter._evaluate_exprs -4 - -"% $ 5#~#'?$($5)-)>    - - -:50!444 t,, - -4 -* s=A B ,BB ct|jdSt|dst|j|_|jS)N_auto_import_func)auto_import_methodrr-rrs rCrzCompleter._auto_import.s@  " *4t011 J%01H%I%ID "%%rB)NN)rrOrPrO)T)rrOrrtrPr)"r=r>r?r$taggreedyr%rJEDI_INSTALLEDuse_jedir&jedi_compute_type_timeoutrbackslash_combining_completionsauto_close_dict_keys DictTraitr(rr*rrrrormrFrGrrrrrrQr __classcell__rhs@rCr7r7s T       cc B 6 cc7:t.<====@SS=M=M !$# ! ! ! SS    DuG H H Hs$s'' '+d4:';';';.=s' 3 3 3! 1c 2 2 3A 3 3 3rB)rr)rrs rCrr6sRY''   4 3u 3 3 33s  ""cpeZdZdZdZejZejZejZ dS) _DictKeyStatea Represent state of the key match in context of other possible matches. - given `d1 = {'a': 1}` completion on `d1['` will yield `{'a': END_OF_ITEM}` as there is no tuple. - given `d2 = {('a', 'b'): 1}`: `d2['a', '` will yield `{'b': END_OF_TUPLE}` as there is no tuple members to add beyond `'b'`. - given `d3 = {('a', 'b'): 1}`: `d3['` will yield `{'a': IN_TUPLE}` as `'a'` can be added. - given `d4 = {'a': 1, ('a', 'b'): 2}`: `d4['` will yield `{'a': END_OF_ITEM & END_OF_TUPLE}` rN) r=r>r?r@BASELINEenumauto END_OF_ITEM END_OF_TUPLEIN_TUPLErArBrCrr@sFH$)++K49;;Lty{{HHHrBrc g}tjt|j} |t |n$#tj$r|cYSt$r|cYSwxYwI)z'Parse tokens even if there is an error.) rrrrrr{rrr)r_rtoken_generators rCrrOs F.tALLNN/C/C/LMMO  MM$// 0 0 0 0"   MMM   MMM  s"A B3 BBprefixUnion[str, None]c|drdSt|}t|}tjtjh}d}|D]f}|j|vr | |jtjkr|j}+dS|jtj kr!|jdkrn|jdvr |j|z}ddS|S)zMatch any valid Python numeric literal in a prefix of dictionary keys. References: - https://docs.python.org/3/reference/lexical_analysis.html#numeric-literals - https://docs.python.org/3/library/tokenize.html r}N,>+-) isspacerrrrrrNUMBERrr)rrrrnumberrs rC _match_number_in_dict_key_prefixr\sbzt 6 " "F&!!J#X%56I F : " "  >zX_,,tt : $ $|s""|z)).44 MrB)0b0o0xr6list[Union[str, bytes, tuple[Union[str, bytes], ...]]]r@ extra_prefix'Optional[tuple[Union[str, bytes], ...]])tuple[str, int, dict[str, _DictKeyState]]c|r|ndtdDttttt ffd}t d}|D]}t|trP||rD|}||xxt|dzkr tj n tj zcc<gdkrnt|r||xxtj zcc<|}|s!ddd|DfSt!jd |} d } | r?| } || z} t'| } n1#t($rddifcYSwxYwt+|}|ddifS|} d } d} d dd|Dzdz}t!j||t j}|J|}|}i}|D][}t|ttfre| s"t|}t|tr=| d d}|t4vrt4|}||}n| r|} || sn#t8t:t<f$rYwxYw|t| d }t|trt?|dznt?|dz}|d| dzd}| dkr|!dd}||}||||<]| ||fS)amUsed 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 dictionary of replacement/completion keys on keys and values indicating whether the state. rAc:g|]}t|t SrA)rslice)r^ks rCrwz#match_dict_keys..s7   1e$$ $   rBct|krdS|D]}t|sdSt|D]#\}}||krt|tsdS$dS)NFT)rlrzipr)keyrpt prefix_tupleprefix_tuple_sizetext_serializable_typess rCfilter_prefix_tuplez,match_dict_keys..filter_prefix_tuples s88( ( (5  Aa!899 uu l++  EArBwwz"e44wuutrBctjSr)rrrArBrCz!match_dict_keys..s M2rBrjrrZc4i|]\}}t||SrA)repr)r^rvs rCrzz#match_dict_keys..s$LLLdatAwwLLLrBz(?:"|')FNTz[^c3 K|] }d|zV dSr\rAr#s rCr`z"match_dict_keys..s&66!TAX666666rBz]*$rTrS"rUz\")"sumrObytesrfloatrrrtuplerlrrrrritemsrFsearchrrrrrdUNICODErlower _INT_FORMATSrkAttributeError TypeError UnicodeErrorrindexrw)rrr@rrfiltered_key_is_finalr key_fragment filtered_keys quote_matchis_user_prefix_numericquote valid_prefix prefix_str number_matchpattern token_match token_start token_prefixmatchedrstr_keyint_base int_formatremrem_reprrxrrrs @@@rCmatch_dict_keysr*s^8$07<G)GVRZ88K  " " "##%%K$$&&L(*G&4&4 cC< ( ( ) #hhG#s## .%bqb>//11|++!-h!7J(jooG& G %%j11   <8    H  c*oo''(&0c&:&:P4c ???S4Z@P@PAs 3 33B67 C<< ''U33H',1.s3 +w &&s$E//FFJ66KKrLcolumnc $|d}|t|ksEJdt|tt|t d|d|D|zS)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 rz{} <= {}c3:K|]}t|dzVdS)rjNrl)r^rLs rCr`z%cursor_to_position..As,66s4yy1}666666rBN)rrlformatrOr )rrLr+liness rCcursor_to_positionr1's. JJt  E 3u::   z00TCE OOLL    66uu666 6 6 ??rBoffsettuple[int, int]cd|cxkrt|ksnJd|dt||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 rz0 <= z <= Nrr})rlrrV)rr2beforeblinesrLcols rCposition_to_cursorr8Ds2  # # # ##d)) # # # # # ##d)))&L # # # '6']F \\$  F <<  D fRj//C 9rBc|tjvr:tj|}|g|D]}t||}t||SdS)z@Checks if obj is an instance of module.class_name if loaded N)rbmodulesrr)rmodule class_nameattrsmrs rC_safe_isinstancer?fs] K (%( ! !D4  AA#q!!! rBrcVt|j\}}t|d|dS)zMatch Unicode characters back to Unicode name Same as :any:`back_unicode_name_matches`, but adopted to new Matcher API. unicodeTrfragmentsuppress_if_matches)back_unicode_name_matchesr _convert_matcher_v1_result_to_v2)rrCrns rCback_unicode_name_matcherrGps9 2'2KLLHg +i(   rBtuple[str, Sequence[str]]ct|dkrdS|d}|dkrdS|d}|tjvs|dvrdS tj|}d|zd|zffS#t $rYnwxYwdS)uMatch 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 ... .. deprecated:: 8.6 You can use :meth:`back_unicode_name_matcher` instead. 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. rTrZrAr r]r}rSrU)rlr ascii_letters unicodedatarKeyError)r maybe_slashcharunics rCrErE|s. 4yy{{vr(Kdv 8D v###ty'8'8v %%Dy$t)%%      6sA"" A/.A/c|j}gdd}t|dkr|S|d}|dkr|S|d}|tjvs|dvr|S t|}t |d gd d|zd S#t $rYnwxYw|S) uVMatch latex characters back to unicode name This does ``\ℵ`` -> ``\aleph`` FrrrTr r]r}rKlatexrTrrr)rrlrrLrrrN)rrno_matchrOrPrTs rCback_latex_name_matcherrWs  $DH  4yy{{r(Kd 8D v###ty'8'8  $T*-%gFFFG $t          Os%A55 BBcr|j}|dstd|z|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) descriptionrkr) parameterrZs rC_formatparamchildrenr\sT 'K  ! !( + +K<>IJKK K qrr?rBcft|drd|}|sdS|d}d|dddzSddd d |DDzS) 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(?)rrrj)maxsplitz(%s), cg|]}||SrArAr^fs rCrwz#_make_signature..s3TTTAQRTaTTTrBc3bK|]*}|D]}t|V+dSr) defined_namesr\)r^rps rCr`z"_make_signature..si*N*Ni3<3J3J3L3L*N*N./+?q*A*A*N*N*N*N*N*N*NrB)rr^ to_stringrrd) completion signaturesc0s rC_make_signaturerks$z+,,<..00  E  & & ( ( +2<<>>''a'88;;; 499TT*N*NS]SlSlSnSn*N*N*NTTTUU UUrBa(?x) ( # match dict-referring - or any get item object - expression .+ ) \[ # open bracket \s* # and optional whitespace # Capture any number of serializable objects (e.g. "a", "b", 'c') # and slices ((?:(?: (?: # closed string [uUbB]? # string prefix (r not handled) (?: '(?:[^']|(?tfd|DdS)zlsame as _convert_matcher_v1_result_to_v2 but fragment=None, and suppress_if_matches is False by constructionc2g|]}t|Srrr^rxrs rCrwz:_convert_matcher_v1_result_to_v2_no_no..9s'RRR%5t<<<RRRrBFrS)r)rnrs `rC&_convert_matcher_v1_result_to_v2_no_norr3s6 RRRR'RRR   rBrCrDcnfd|D|r|rdndndd}|||d<tt|S)zUtility to help with transitionc2g|]}t|Srorprqs rCrwz4_convert_matcher_v1_result_to_v2..Fs'UUUE(e$???UUUrBTFrSNr)r.r)rnrrCrDrs ` rCrFrF>sbVUUUWUUU4GRW/TT%%UF%-!" #V , ,,rBc eZdZdZeddZeddZeede ed dgd d  d Z edd  d Z e ed d Zeddd  d Zedd d Zedd  d Zedd  d ZeddZ ddfd ZededZdfdZdgd Zdgd!Zedhd%Zedhd&Zedhd'Zdfd(Z edhd)Z!ed*+did-Z"djd2Z#Gd3d4e$jZ%d5Z&d6Z'edhd7Z(e)d89dkd;Z*d<Z+d=Z,edhd>Z-d?Z.e/dldCZ0edhdDZ1dfdEZ2edhdFZ3edmdGZ4dndIZ5edJZ6dKZ7dodNZ8dpdPZ9 dqdrdQZ:dsdXZ;d d d dYdtd[ZedmdaZ?dndbZ@edwdcZAxZBS)xr8z?Extension of the completer class with IPython-specific featuresrc|dr!d|_d|_t|j_dSd|_d|_t |j_dS)z>update the splitter and readline delims when greedy is changednewr[TrZFN)rr GREEDY_DELIMSsplitterr@rPrchanges rC_greedy_changedzIPCompleter._greedy_changedQsN %= *&DO(,D %#0DM 'DO(-D %#)DM rBFz Whether to show dict key matches only. (disables all matchers except for `IPCompleter.dict_key_matcher`). rTT)r`Nag Whether to suppress completions from other *Matchers*. When set to ``None`` (default) the matchers will attempt to auto-detect whether suppression of other matchers is desirable. For example, at the beginning of a line followed by `%` we expect a magic completion to be the only applicable option, and after ``my_dict['`` we usually expect a completion with an existing dictionary key. If you want to disable this heuristic and see completions from all matchers, set ``IPCompleter.suppress_competing_matchers = False``. To disable the heuristic for specific matchers provide a dictionary mapping: ``IPCompleter.suppress_competing_matchers = {'IPCompleter.dict_key_matcher': False}``. Set ``IPCompleter.suppress_competing_matchers = True`` to limit completions to the set of matchers with the highest priority; this is equivalent to ``IPCompleter.merge_completions`` and can be beneficial for performance, but will sometimes omit relevant candidates from matchers further down the priority list. r]rVa6Whether to merge completion results into a single list If False, only the completion results from the first non-empty completer will be returned. As of version 8.6.0, setting the value to ``False`` is an alias for: ``IPCompleter.suppress_competing_matchers = True.``. z{List of matchers to disable. The list should contain matcher identifiers (see :any:`completion_matcher`). )rrjrTrTa1Instruct 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. a3 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.rc:tjdtdS)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.)rIr UserWarningrzs rC_limit_to_all_changedz!IPCompleter._limit_to_all_changeds+ H      rBc t|_t|_t jd |||d|g|_||_tj d|_ tj |_ tj dd}|dv|_t jdkr |j|_n |j|_tj d|_tj d|_|j|jg|_d |_d |_|j|jt<t>|j g|_!|j"s1|j!D])}|j#$tK|*|j&s d |_'d Sd 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. )rcrdrWz([^\\] )TERMxterm)dumbemacsr9z^[\w|\s.]+\(([^)]*)\).*z[\s|\[]*(\w+)(?:\s*=\s*.*)NTrA)(r magic_escaper=ryrfrrnshellrFrG space_name_reglobrmenvironget dumb_terminalrbrc_clean_glob_win32 clean_glob _clean_globdocstring_sig_redocstring_kwd_remagic_config_matchermagic_color_matchermagic_arg_matcherscustom_completers_unicode_nameslatex_name_matcherunicode_name_matcherrWrGfwd_unicode_matcher_backslash_combining_matchersrdisable_matchersr{rmerge_completionssuppress_competing_matchers) rrrcrdrWrgtermrrhs rCrzIPCompleter.__init__s2&*,,   -        Z 44I z~~fW--!%55 <7 " ""4DOO".DO!# +E F F " +H I I  %  $#  "& #  #  % # %  $ . *3 G= G G%,,_W-E-EFFFF% 4/3D , , , 4 4rBrP list[Matcher]c$|jr|jgS|jr:g|j|j|j|j|j|j|j|j Sg|j|j|j|j|j|j|j |j |j S)z*All active matcher routines for completion) dict_keys_onlydict_key_matcherrrerrcustom_completer_matcher magic_matcher _jedi_matcher file_matcherpython_matcherpython_func_kw_matcherrs rCmatcherszIPCompleter.matcherss   +)* * =  % 3 ( -  "  " % !   % 3 ( -  %  " # ! +  rBrrOrc|ddt5fd|t|DcdddS#1swxYwY|dS)zQ Wrapper around the completion methods for the benefit of emacs. rjrchg|].}r#jrd|jgn|j/S)rj)rrdr)r^r_rrs rCrwz/IPCompleter.all_completions..>sW@@@39VT]VCHHfaf-...PQPV@@@rBNrj) rpartitionrMrrlr)rrrs` @rCall_completionszIPCompleter.all_completions8s%%a( ! # # @ @@@@@@!--dCII>>@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @}}T""1%%s0A))A-0A-c2|d|zS)N%s*rrs rCrzIPCompleter._clean_globCsyy&&&rBcFd|d|zDS)Nc:g|]}|ddS)r]/rvrbs rCrwz1IPCompleter._clean_glob_win32..Gs6222 $s##222rBrrrs rCrzIPCompleter._clean_glob_win32Fs32254<00222 2rBrrrc |j}|dr |dd}d nd |j}t| d|vsd|vr|}nY t |d}nB#t $r( r| d}ngdd cYSYnt$rd}YnwxYw s|t|krd }||c }n!d}tj |}|dkr$ fd | d Ddd Stjd kr||}n)||dd}|r t#| fd|D}n1 r!tjd kr|n fd|D}n fd|D}d|Ddd S)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. !rjNrZrrCr}FrSTcRg|]#}tt|zd$S)rfr)rrer^rc text_prefixs rCrwz,IPCompleter.file_matcher..sM   %(+;A+>+>>V   rB*r9r]cJg|]}zt|dz Srre)r^rc len_lsplittext0rs rCrwz,IPCompleter.file_matcher..sLEEE<=#U*'*++778EEErBc0g|]}t|SrAr)r^rc open_quotess rCrwz,IPCompleter.file_matcher..s$BBB!%a55BBBrBc4g|]}t|zSrArrs rCrwz,IPCompleter.file_matcher..s9<<<34'+A../<<.sP!q1A1A&Ha#ggqvVVVrB)rrkrrWr#rrrprermrfrnrrbrcrrwrl) rrrrlsplithas_protectablesm0rnrrrrs @@@@rCrzIPCompleter.file_matcherJs$} ??3   8DKKK 2%&788 # # #s.?'?'?FF "#455b9   .44[AA"EFF(*$)F      ,v)9&)A)AAA# fJE$$$ 7%%d++D 2::    "YYs^^     "  <7 " "&&BBdB!7!788B  <VJEEEEEEACEEEGG <!$  7 7""BBBBrBBB<<<<8:<<<      sA((-B' B'&B'c |j}|jj}|d}|d}|j z | }|  |  |s fd n fd fd|D}| s| fd|Dz }t|dko |ddk}d |D|ot|dkd S) z Match magics.rLcellc6|o|vS)z Filter magics, in particular remove magics that match a name present in global namespace. rk)magic bare_textros rCrnz*IPCompleter.magic_matcher..matchess( )))445n47rBc.|Srr)rrs rCrnz*IPCompleter.magic_matcher..matchess'' 222rBc0g|]}| |zSrArA)r^r>rnpre2s rCrwz-IPCompleter.magic_matcher..s*CCCA CtaxCCCrBc0g|]}| |zSrArA)r^r>rnpres rCrwz-IPCompleter.magic_matcher..s*GGGGGAJJGC!GGGGrBrr~c0g|]}t|dS)rrrp)r^comps rCrwz-IPCompleter.magic_matcher..s3>B d999rBrS) rrmagics_managerlsmagicrrklstriprorl)rrrlsm line_magics cell_magicsexplicit_magicris_magic_prefixrrornrrs @@@@@rCrzIPCompleter.magic_matchersx }j'//11&k &k 3w--KK$$ ,,Y77 3 7 7 7 7 7 7 7 3 3 3 3 3DCCCCCCC t$$ H GGGGG[GGG GKd))a-:DGsNFQ(@C ,<,.s?"%"%"%&'k&>&>d&>&K&K"%1"%"%"%rBc|jjSrrhr=rs rCrz2IPCompleter.magic_config_matches..s Q[5IrBrc&g|]}|jjSrArr#s rCrwz4IPCompleter.magic_config_matches..sBBBA1;/BBBrBrjrjc>g|]}||SrAr)r^r_ classnames rCrwz4IPCompleter.magic_config_matches.. s9!?!?!?%&\\)%<%<!?!!?!?!?rBz^--rZc|g|]8}|d|dd9S)rjr|r)rkr)r^rtextss rCrwz4IPCompleter.magic_config_matches.. sM888! OOE!H558C+888rB)striprrlsortedrar configurablesfindrrhclass_get_helprFrvrG MULTILINEr) rrclasses classnamesclassname_textsclassname_matchesclsrUrrs @@rCrz IPCompleter.magic_config_matchess  ""$$ u::>>uQx833uQx97L7LS"%"%dj.F"%"%"%&&+I+IKKKGCBBBBJ5zzQ!!$AhnnS11O'*I!?!?!?!?Z!?!?!? Qx}}S!!A%%((&''1,,-a0I==j..y99:D))++vbj>>DII8888%)ZZ\\%<%<%>%>8888 rBcr|j}|}|dr|dt |dkrN|ddks |ddkr6|dt fdt jDd St gd S) z&Match color schemes for %colors magic.r:rZrTrcolorsz%colorsrjc\g|](}|t|d)S)rr)rkr)r^colorrs rCrwz3IPCompleter.magic_color_matcher.." sJ''//$U999rBFrS)rrrr{rlrrr)rrrrrs @rCrzIPCompleter.magic_color_matcher s'  ==    LL    u::??aH 4 4aI8M8M1XF&!,!1!3!3   #    rBzIPCompleter.jedi_matcher)r rcZ||j|j|j}|ddS)N) cursor_columnrrFrS) _jedi_matchesrrrrs rCrzIPCompleter._jedi_matcher. sE$$!1+"%   #   rBrrrrc|jg}|j||jd}t|||}|re||dz }|dkrT|jdkrd}nE|jdkrd}n6|jdkrd }n't d |jtj|d||}d } d } td | j j D} t| jdko| jddv} n#t$rYnwxYw| } n/#t $r"} |jrt%d| dYd} ~ nd} ~ wwxYw| st'gS t)||||dzS#t $rE} |jr%t't-d| zgcYd} ~ St'gcYd} ~ Sd} ~ wwxYw)a Return a list of :any:`jedi.api.Completion`\s 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. .. deprecated:: 8.6 You can use :meth:`_jedi_matcher` instead. Nc|SrrArs rCrz+IPCompleter._jedi_matches..W sQrBrjrjrTc8|jd S)Nr{)rrkr_s rCrz+IPCompleter._jedi_matches..^ sQV5F5Fs5K5K1KrBcl|jdo|jd S)Nrz)rrkrrs rCrz+IPCompleter._jedi_matches..` s1af6G6G6M6M6gRSRXRaRabfRgRg1hrBrc|SrrArs rCrz+IPCompleter._jedi_matches..b srBz'Don't understand self.omit__names == {}TFc3:K|]}t|d|VdS)rNrr#s rCr`z,IPCompleter._jedi_matches..m s4"r"r^efgip^q^q"r1"r"r"r"r"r"rrB>rSrUz5Error detecting if completing a non-finished string :|)r+rLzJOops Jedi has crashed, please report a bug with the following: """ %s s""")rcrdr{r1 omit__namesrr/r3 Interpreterr _get_module tree_nodechildrenrlrrrrr5rfilterrr) rrrr namespacescompletion_filterr2r interpretertry_jedicompleting_string first_childrs rCrzIPCompleter._jedi_matches; s0n%  ,   d3 4 4 4&J#D+}EE  ivax.Cczz#q(((K(K%%%**(h(h%%%**(2 %%$%N%U%UVZVf%g%ghhh&tGVG}jAA  W %  f""r"rk.E.E.G.G.Q.Z"r"r"rrr %( (9$:$:Q$>$e;CTUVCW[eCe!! !    -,HH W W Wz WMqRUVVV W  88O +[-A-A]hkl]l-A-m-mnn n z +k "Bxx sfD95D%=(D9% D2/D91D22D99 E%E  E%:'F"" G1,&G,G1G,&G1,G1ceZdZdZdZdS)"IPCompleter._CompletionContextType attributeglobalN)r=r>r? ATTRIBUTEGLOBALrArBrC_CompletionContextTyper s rBrct||\}}|r|s |jjS|r?|r=|d}|dkr"||dzd}||St jd|r |jjSt jd|}|r |jjS|jjS)z_ Determine whether the cursor is in an attribute or global completion context. rrrjNz)(?',>( ,> ( ,>&*"Q1us4yy  QUOu,,+-,-,<';$+3-2*FAQUOu,,+-,-,<';$+3-2*FAAw$1q53t99#4#4Q" q53t99$$a!a%iD)@)@FA7c>>).].?OST?T?T(, (A-(FA7c>>$)$'1,,(- +,(FA.B2BOAw#~~o~o~&5"5&//).&aC&5"5&//).&Aw#~~#26E#{ FAq#d))mmv  V V2B VFV   C,B]1B  2.2  rBc|j}||}||jjkr ||d\}}|dr)|jr"|jdkrd}nd}t||}t|d|S#t$rtgd cYSwxYw| |j }td |Dd S) z'Match attributes or global python namesF)rrjrjc0tjd|duSNz .*\.__.*?__rFrxtxts rCrz,IPCompleter.python_matcher..1 srx/L/LPT/TrBcftjd||ddduSNz\._.*?rjrFrxrindexr/s rCrz,IPCompleter.python_matcher..5 s/C 3@Q@Q.C s3FK$%jAAArB) rrrrrrrr rF NameErrorrror)rrrcompletion_typernrCno__names rCrzIPCompleter.python_matcher& sP(<.U s$&H^C$@$@D$HrBcftjd||ddduSr2r3r/s rCrz,IPCompleter.python_matches..Y s1$&HYs3::c??;K;K7L$M$MQU$UrB)rmrrr r7ro)rrrnr9s rCpython_matcheszIPCompleter.python_matchesI s $;; ++D11==%% 8$*: 8'1,,%I%I%V%V$Xw77G    ))$//GsAA A)(A)cD|gS|d}|j|}|gS|dd}g}|D]}||j|z } |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)'. Nrr)rrrrgroupsrrfindall)rdocrLsigretrNs rC!_default_arguments_from_docstringz-IPCompleter._default_arguments_from_docstringc s ;Izz||&&((+#**400 ;Ijjll1o##C(( 4 4A 4(0033 3CC rBc|}g}tj|rntj|stj|sutj|rJ||t |ddz }t |ddpt |dd}nt|dr|j}||t |ddz }tj j tj j f tj |}| fd|jDn#t $rYnwxYwt#t%|S)z_Return the list of default arguments of obj if it is callable, or empty list otherwise.r@rZrN__new__rc34K|]\}}|jv|VdSr)kind)r^rr_keepss rCr`z1IPCompleter._default_arguments.. s?))TQv''''''))rB)inspect isbuiltin isfunctionismethodisclassrErrr Parameter KEYWORD_ONLYPOSITIONAL_OR_KEYWORDrextend parametersrrr&ra)rrcall_objrDrCrJs @rC_default_argumentszIPCompleter._default_arguments} s  S ! ! ( $S)) (W-=c-B-B (s## (t==#CB77999$CT::5sIt44j)) (< t559b1133 3#0#9; #C((C JJ))))S^%9%9%;%;))) ) ) ) )    D CHH~~sA E EEcX||j}t|dS)z:Match named parameters (kwargs) of the last open function.rr)python_func_kw_matchesrrrrs rCrz"IPCompleter.python_func_kw_matcher s,--gm<<5gGLLLLrBcVd|vrgS|j}nC#t$r6tjdtjtjzx}|_YnwxYw||j}t|}d}|D]!}|dkr|dz}|dkr |dz }|dkrn"gSg}tjdj } | t|||d s| n&t|dksnn#t$rYnwxYwot} d } t||dd D]?\}} |dkr| dz } n |dkr| dz} | dkr#| d kr*| |@g} d|d d d } |t'| |j}t|| z D]/}||r| d |z0n#YnxYw| S) zMatch named parameters (kwargs) of the last open function. .. deprecated:: 8.6 You can use :meth:`python_func_kw_matcher` instead. rjz '.*?(?.v s111AGaK111rBr`)!rrrDICT_MATCHER_REGEXrr@rrryrrrdrcrrrr*ryr@rlrr line_bufferrkrrrrrrrrr{)rrrxrJprior_tuple_keys key_prefixrr tuple_prefix closing_quote token_offsetrn text_start key_startcompletion_startcan_close_quotecan_close_bracket continuationhas_known_tuple_handlingcan_close_tuple_itemresultsend_of_tuple_or_itemr state_flagrrs @rCr|zIPCompleter.dict_key_matches ss  ! ' ' ) ) 2 23 7 7 I"))$*@AA =I-2\\^^* !!$'' )  I~~c"" K#  -~?! -!%!6       0? *dm20 0 0 , |W I /003t99<  7 AI(<7  +099;; 6I(  ! !GG:&667G  !'D,B(C(C(E(EFLLNN  " "= 1 1 #'M(:(:(<(<=LL"O#))++ $.c4#8#8 '',, , J1J '',, , *( *)  *Gd.G 2'8 2] 21111111 1,9M ``η`` Works only on valid python 3 identifier, or on combining characters that will combine to form a valid identifier. r]r}rjNarArTrUFrS)rrrMlookup isidentifierrrN)rrrslashposrNrQs rCrz IPCompleter.unicode_name_matcher s(::d## b==XaZ[[!A ")!,,H**,,(8d(S(S(S'T$(,01H        sAA66 BBcb||j\}}t|d|dS)u{Match Latex syntax for unicode characters. This does both ``\alp`` -> ``\alpha`` and ``\alpha`` -> ``α`` rTTrB) latex_matchesrrFrrrCrns rCrzIPCompleter.latex_name_matcher s? !..w/HII'/ 'H$    rBrHc|d}|dkr<||dtvrtgfSfdtD}|r|fSdS)uMatch Latex syntax for unicode characters. This does both ``\alp`` -> ``\alpha`` and ``\alpha`` -> ``α`` .. deprecated:: 8.6 You can use :meth:`latex_name_matcher` instead. r]r}Nc>g|]}||SrAr)r^rrNs rCrwz-IPCompleter.latex_matches.. s(GGGq||AG1GGGrBrJ)rr)rrrrnrNs @rCrzIPCompleter.latex_matches s::d## b==XYYAM!!=+,,,HGGGmGGG&g:%vrBc||jpg}t|td}d|d<t |jh|d<|S)zpDispatch custom completer. If a match is found, suppresses all other matchers except for Jedi. Tr{rr)dispatch_custom_completerrrF _UNKNOWN_TYPErr)rrrnrs rCrz$IPCompleter.custom_completer_matcher sc 00??E21 -T   !y%4T5G%H%H$I ! rBc |jsdS|j}|sdSt}||_|_|ddd}||_|j|_| |j s#|j |j |z}ng}tj |j |||j|jD]e} ||}|r8fd|D}|r|cS fd|DcSI#t $rYUt"$r YnwxYwdS)zg .. deprecated:: 8.6 You can use :meth:`custom_completer_matcher` instead. Nrjrc>g|]}||SrAr)r^rrs rCrwz9IPCompleter.dispatch_custom_completer.. s*EEEa!,,t2D2DEEEErBcbg|]+}|)|,SrA)rrk)r^rtext_lows rCrwz9IPCompleter.dispatch_custom_completer.. s4MMM!aggii.B.B8.L.LMAMMMrB)rrrr rLsymbolrcommandrrkr s_matchesrr flat_matchesrrKeyboardInterrupt) rrrLeventcmd try_magicr_rwithcasers ` @rCrz%IPCompleter.dispatch_custom_completer s %  Fzz|| 4 !!  jja  # "&"8~~d/00 .88!C'))III!7!A!A#!F!F'44T5KLLNN  A ahhNEEEE3EEEH('#zz||HMMMMsMMMMMMN   $     tsE"!E E! E! E!r2Iterator[Completion]c #Ktjdtdt} |jr-ddl}|}|nd}||||j dz D]"}|r||vr |V| |#n#t$r YnwxYw|| t|jtj|jt%t'j}t+d|||dSdS#|| t|jtj|jt%t'j}t+d|||wwxYw) 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.rTrrNi)_timeoutzWriting profiler output to)rIrr<raprofile_completionscProfileProfileenable _completionsrr)rdisabler"profiler_output_dirrmrfrdrOuuiduuid4r5 dump_stats)rrr2r,rprofilerr_ output_paths rCrzIPCompleter.completions s\  > ;q J J J J uu 1' #++--!!!!&&tVd>\]a>a&bb  !t))   !    . D  #  """!$":;;; gll4+CSEVEVWW 2K@@@##K00000 $#x#  """!$":;;; gll4+CSEVEVWW 2K@@@##K0000 $s+A9B('E( B63E5B66EBG$rc #\Ktj|z}|d|}t||\}}t|jdfd |||| }fd |D} |vr!tt|d nd } t| } |r| D]} | j } n)#t$r|j rtd | d} YnwxYwt| jt| jz }| dkrt#| }nd}t%||z || j| |dVtj|krn| D]O} t| jt| jz }t%||z || jt&ddVP| rg| re|j r^|t+t| d}t%||ddddVg}g}| D]\}}|d}||}|dd}|r|n|}||sJ|d D]=}t%|||j|d|j pt&}||>t7||||zdt<Ed{VdS)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. Nrrr rOrPTypeGuard[SimpleMatcherResult]c|kSrrA)rr jedi_matcher_ids rCis_non_jedi_resultz4IPCompleter._completions..is_non_jedi_result s0 0rB)rrrMc4i|]\}}||||SrArA)r^r rrs rCrzz,IPCompleter._completions.. sB< < < " F!!&*55< < < < rBrrAzError in Jedi getting type of functionrZr3r)rrrrrrrz--jedi/ipython--rnone)rrrrrrrF)rrrrrr)rrr rOrPr)time monotonicr8rr _completerr.rrrrrr5rlrrrkrrrrvaluesrrrr{r& _deduplicate_sort MATCHES_LIMIT)rrr2rdeadliner5rrrnon_jedi_results jedi_matchesiter_jmjmtype_deltarsome_start_offsetrsortableoriginr matched_text start_offset is_ordered containersimple_completionrhrrs @@rCrzIPCompleter._completions` s@4>##h.7F7#%7 6%J%J" ])$*<== 1 1 1 1 1 1 ..[]!  < < < < &-mmoo< < < ')) #W_%= > >} M M  |$$    !GEE !!!zD>CCC EEE!B011C 4D4DDJ&& / 3 3II "I v~%+&(&:&++4)/ 111111>##h..E/  B,--BK0@0@@Eun)"       ,   & T*113344556HI!! ''    %'%'.4466 - -NFF!"45L!<< 55LIu55J#-;8I??<00 0 0 0%+M%: - -!'&*/" */@=    ,,,, -))'DJJx4H4H*HIIJJ ]N          sC#C54C5ctjdt||||d}t |j}|||hdS)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)rrMrrT skip_matchersabort_if_offset_changes)rIrPendingDeprecationWarningrrr_arrange_and_extract)rrrrMrrs rCrzIPCompleter.complete sH  O/ 1 1 1..# ST!  *$*<==(( *+$( )   rBrdict[str, MatcherResult]rset[str]rrtcg}g}d}|D]z\}}||vr |ds|s|d}|r|d|krnN|ddr||d_||d{|sd}|d||||zDfS)NrrrFrZcg|] }|j SrA)r)r^r>s rCrwz4IPCompleter._arrange_and_extract..; s'& & & AF& & & rB)rrrSrr) rrrrrrmost_recent_fragmentr rs rCrz IPCompleter._arrange_and_extract s" 02.0#")--// 7 7 J]**-( ' B'-.@'A$' -.2FFFzz)U++ 7vm45555} 56666# &#% #& &  --g 88L8L.LMM& & &   rB)rrr_CompleteResultcX| |t|nt|}|jrtj|_|s|r|d|}|s|r|j||nd}||}||_|jd||_ |s|}t||||t}i}t|j }t} dt|jt"dD} | D]\} } t| } | |jvr| |vrt)jd| d | | vr@ t-| r t/| |t0 } n. s2    G $ $g   rBT)rreversezDuplicate matcher ID: rjrzUnsupported API version rrFrr))rlrbrkrlrcrryrOrrrrrrrarrrrrrIrrrrrrrr BaseExceptionrb excepthookexc_inforrrrrr r rrn)rrrMrrrrrrsuppressed_matchersr matcher_idrrrsuppression_recommendedsuppression_configshould_suppresssuppression_exceptions to_suppress new_resultsprevious_matcher_idprevious_resultr{rns rCrzIPCompleter._complete? s N  -1\[)))s4yyJ   /%.DN = =#//$//  $#I#&#    -/)$*<==(+  ! #8$   $,>>#3#3? )? ) J(11JT222W$$ DzDDDEEE000 !'**OC MFF$G,,O$WW--FF":7"C"CK$%M %M%MNNN     //  *04F )V)VF% && *AGBB' "$"BDII:D488TJJJ9# (4/W/U5Gu5T#2*&11 #*7=zz)35588*""98DD4&)*A&B&B &)(mm *58N*N'"$K@G OO<+_.6III?NK(;<)G"(GJ  .. ++$) /  7 sA+G)G.-G.rnSequence[AnyCompletion]Iterable[AnyCompletion]ci}|D](}|j}||vs||jtkr|||<)|Sr)rrrr)rnfiltered_matchesrxrs rCrzIPCompleter._deduplicate s]68 / /E:D,,,#D).-??). &&&(((rBc&t|dS)Nc*t|jSr)rrrs rCrz#IPCompleter._sort.. s-DQV-L-LrBr)r)rns rCrzIPCompleter._sort sg#L#LMMMMrBcb||j\}}t|d|dS)zASame as :any:`fwd_unicode_match`, but adopted to new Matcher API.rATrB)fwd_unicode_matchrrFrs rCrzIPCompleter.fwd_unicode_matcher s? !2273LMM'/ )hD    rBcF|d}|dkr||dzd}|fd|jD}|r||fSfd|jD}|r||fSdfd|jD}|r||fSd Sd S) a Forward match a string starting with a backslash with a list of potential Unicode completions. Will compute list of Unicode character names on first call and cache it. .. deprecated:: 8.6 You can use :meth:`fwd_unicode_matcher` instead. Returns ------- At tuple with: - matched text (empty if no matches) - list of potential completions, empty tuple otherwise) r]r}rjNc>g|]}||SrArr^rsups rCrwz1IPCompleter.fwd_unicode_match..+s*MMM1<<;L;LM!MMMrBcg|]}|v| SrArArs rCrwz1IPCompleter.fwd_unicode_match...sDDD3!88!888rBr:cLg|]tfdD S)c3 K|]}|vV dSrrA)r^urs rCr`z;IPCompleter.fwd_unicode_match...3s'4N4NQ!V4N4N4N4N4N4NrB)all)r^rsplitsups @rCrwz1IPCompleter.fwd_unicode_match..2sL4N4N4N4NX4N4N4N1N1NrBrJ)rupper unicode_namesr)rrrrN candidatesrrs @@rCrzIPCompleter.fwd_unicode_matchs@::d## b== X\^^$A''))CMMMMT%7MMMJ %*}$DDDDT%7DDDJ %*}$yy~~H-J %*}$66rBc|jsg}tddD]G} |tjt |8#t $rYDwxYwtt|_|jS)z}List of names of unicode code points that can be completed. The list is lazily initialized on first access. Nri) rranger{rMrchrr_unicode_name_compute_UNICODE_RANGES)rrwr_s rCr zIPCompleter.unicode_names>s   &E1\**  LL!1#a&&!9!9::::!D"7"H"HD ""s4A AA)NNNN)rPrr)rrOrrrPr)rrrPr)rrrrrrOrPr)rrOrPr:)rrrPrkrrrrOrPrH)rrOr2rrPr)rrOr2rrPr)NNN)rPrH)rrrrrrt)rPr)rnrrPr)rnr)rPr)Cr=r>r?r@r+r|r$r UnionTraitrrrr ListTraitr(rr%rrrrrrrQrrrrcontext_matcherrrrrrrrrrrrrrr>rErVrrX staticmethodryrr|rrrrrrrrrrrrrrr rrs@rCr8r8NsII WX * * *T  N#-*     $$t*E*E*E F FG ###. cc/ 2      cc!y    cc $      ccd5      cc$ T cc "', Q cc  W  IMX4X4X4X4X4X4tX: & & & &''''2222_f f f f P_1 1 1 1 f_MMMM %%%%N_    0_ :;;;    <;  R R R R h222>r r r h_    DA&&&'&24   D_MMMM PPPd\._    uuuun_    >_    ._   222hL1L1L1L1\B B B B J7;8 8 8 8 8 t    BAE4 bbbbbbH ) ) )\ )NNN\N_    ;;;;z###X#####rBrangeslist[tuple[int, int]]rc g}|D]]\}}t||D]G} |tjt |8#t $rYDwxYw^|Sr)r r{rMrrr)rrwrstopr_s rCrrPs E dud##  A  [-c!ff556666      Ls4A AA)rG)rNrOrPrQ)rNrOrXrOrPrO)rfrOrPrg)rfrOrortrprOrPrO)rrrPr)rrrPr)rrrPr)rrrPr)rrrPrt)r r r rrrrPr)rr)rrOrrrPr)rrOrrr/rtrPr)rrOrPrr) rrrrOr@rOrrrPr)rrOrLrr+rrPr)rrOr2rrPr3rrrr)rnrlrrOrPr)NF) rnrlrrOrCrrDrtrPr)rrrPr)r@ __future__rbuiltinsr~rrrKrr|rrmrFrrbrrrMrrIr collectionsr contextlibr dataclassesr functoolsrr typesr typingr r r rrrrrrrIPython.core.guarded_evalrrIPython.core.errorrIPython.core.inputtransformer2rIPython.core.latex_symbolsrrIPython.testing.skipdoctestr IPython.utilsrIPython.utils.PyColorizerIPython.utils.decoratorsrIPython.utils.dir2rr IPython.utils.docsr!IPython.utils.pathr"IPython.utils.processr# traitletsr$r%r&r'rr(r)rr*rr+traitlets.config.configurabler,traitlets.utils.importstringr-rkr. version_infotyping_extensionsr1r2r3r4r5__skip_doctest__r3settingscase_insensitive_completionjedi.api.helpersjedi.api.classesr ImportErrorrrrc PROTECTABLESrrobjectr FutureWarningr<rKrMrWrersrxrr_JediCompletionLikerrrrrAnyMatcherCompletionrrrrrrrrrrrrrr rrrrrrr.r;rPrxr=r7rFlagrrrbinocthexrr*r1r8r?rGrErWr\rkrrOrrGrrrrFr8rrArBrCrDsn jjjf#"""""    ######%%%%%%!!!!!!........!!!!!!                        FEEEEEEE&&&&&&444444JJJJJJJJ444444""""""00000033333344444444777777000000++++++                      766666444444gXXXXXXXXXXXXXXXMMMMMMMMMMMMMMKKK05DM-NNNNN!"45  &<7LL*L   FHH      -   *EFFFF8*2>%,%,%,%,P@;;;;;;;;.13FFGG7G7G7G7G7G7G7G7TKKKKKKKK0$tVHMMMIIIII,iIINMI/////+///02BBC)=zJJ  #<#<#<#<#<#<#< #      *H    13E EF FFFF     8   <566666  %%%% &&&& .!% $ %%%%%%P3333HHHH666',!<<<z''''THM8;8;8;8;8;8;v<7 -FF 0F 0202020202020202hw&w&w&w&w& w&w&w&r 444     DI          H   =A ^'^'^'^'^'B@@@@:D"""''''T""""H,UUUU<sM)* RZ,..b# % - - - - - #####)###D8s-EEE