ipython-postfix-completion 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

ipython_postfix_completion/__init__.py

@@ -7,8 +7,8 @@ import io
 import re
 import string
 import tokenize
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable
 
 from IPython.core.completer import (
     CompletionContext,
@@ -17,15 +17,12 @@ from IPython.core.completer import (
 )
 from IPython.core.error import UsageError
 from IPython.terminal.ptutils import IPythonPTCompleter
+from traitlets import Bool, Unicode
 from traitlets import Dict as TraitletsDict
 from traitlets import List as TraitletsList
-from traitlets import Unicode
 from traitlets.config.configurable import Configurable
 
-
-_POSTFIX_RE = re.compile(
-    r"^(?P<indent>[ \t]*)(?P<body>.*)\.(?P<prefix>[A-Za-z_]*)$"
-)
+_POSTFIX_RE = re.compile(r"^(?P<indent>[ \t]*)(?P<body>.*)\.(?P<prefix>[A-Za-z_]*)$")
 _PREFIX_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 _STATE_NAME = "postfix_completion"
 _STYLE = "bg:#44475a #f8f8f2"
@@ -35,7 +32,13 @@ _ALLOWED_TEMPLATE_FIELDS = {"expr", "indent"}
 _MAGIC_NAME = "postfix_template"
 _NO_MAGIC = object()
 _NO_MAGIC_ATTR = object()
-_ACTIVE_STATE: "PostfixState | None" = None
+_ACTIVE_STATE: PostfixState | None = None
+_VAR_TEMPLATE = "key = {expr}"
+_VAR_PLACEHOLDER = "key"
+_PLACEHOLDER_ATTR = "_postfix_completion_placeholder"
+_OPENING_BRACKETS = {"(": ")", "[": "]", "{": "}"}
+_CLOSING_BRACKETS = {closer: opener for opener, closer in _OPENING_BRACKETS.items()}
+_STRING_START_RE = re.compile(r"(?i)^(?P<prefix>[rubf]*)(?P<quote>'''|\"\"\"|'|\")")
 
 
 class _TemplateFormatter(string.Formatter):
@@ -53,7 +56,7 @@ DEFAULT_TEMPLATES: dict[str, str] = {
     "len": "len({expr})",
     "not": "not {expr}",
     "par": "({expr})",
-    "var": "{expr} = ",
+    "var": _VAR_TEMPLATE,
     "await": "await {expr}",
     "return": "return {expr}",
     "if": "if {expr}:\n{indent}    ",
@@ -88,22 +91,35 @@ class PostfixCompletionConfig(Configurable):
         _SELECTED_STYLE,
         help="Prompt-toolkit selected style for postfix completion menu entries.",
     ).tag(config=True)
+    smart_tab_jump = Bool(
+        True,
+        help="Move Tab over adjacent Python string and bracket closing tokens.",
+    ).tag(config=True)
 
 
 def _validate_template_name(name: str) -> None:
     if not _TEMPLATE_NAME_RE.match(name):
         raise UsageError(
-            f"Invalid postfix template name {name!r}: expected "
-            "[A-Za-z_][A-Za-z0-9_]*"
+            f"Invalid postfix template name {name!r}: expected [A-Za-z_][A-Za-z0-9_]*"
         )
 
 
 def _validate_template(template: str) -> None:
-    fields = {
-        field_name
-        for _, field_name, _, _ in _FORMATTER.parse(template)
-        if field_name is not None
-    }
+    try:
+        parsed = list(_FORMATTER.parse(template))
+    except ValueError as error:
+        raise UsageError(f"Invalid postfix template: {error}") from error
+
+    fields = set()
+    for _, field_name, format_spec, conversion in parsed:
+        if field_name is None:
+            continue
+        if format_spec or conversion is not None:
+            raise UsageError(
+                "Postfix template fields must use plain {expr} or {indent}."
+            )
+        fields.add(field_name)
+
     unknown = fields - _ALLOWED_TEMPLATE_FIELDS
     if unknown:
         names = ", ".join(sorted(f"{{{name}}}" for name in unknown))
@@ -286,8 +302,320 @@ def _expand_buffer(buffer) -> bool:
     matched_fragment, candidates = _postfix_candidates(line, exact=True)
     if len(candidates) != 1:
         return False
+    parsed = _line_prefix(line)
     buffer.delete_before_cursor(len(matched_fragment))
+    expansion_start = buffer.cursor_position
     buffer.insert_text(candidates[0])
+    if (
+        parsed is not None
+        and parsed[2] == "var"
+        and _effective_templates().get("var") == _VAR_TEMPLATE
+    ):
+        _select_placeholder(
+            buffer,
+            expansion_start,
+            expansion_start + len(_VAR_PLACEHOLDER),
+            buffer.cursor_position,
+        )
+    return True
+
+
+def _select_placeholder(buffer, start: int, end: int, final_cursor: int) -> None:
+    from prompt_toolkit.selection import SelectionState, SelectionType
+
+    buffer.cursor_position = end
+    buffer.selection_state = SelectionState(start, SelectionType.CHARACTERS)
+    buffer.selection_state.enter_shift_mode()
+    setattr(buffer, _PLACEHOLDER_ATTR, (start, end, final_cursor))
+
+
+def _has_active_placeholder(buffer) -> bool:
+    placeholder = getattr(buffer, _PLACEHOLDER_ATTR, None)
+    selection = buffer.selection_state
+    if placeholder is None or selection is None:
+        return False
+    start, end, _ = placeholder
+    return (
+        selection.shift_mode
+        and selection.original_cursor_position == start
+        and buffer.cursor_position == end
+        and buffer.text[start:end] == _VAR_PLACEHOLDER
+    )
+
+
+def _accept_placeholder(buffer) -> bool:
+    if not _has_active_placeholder(buffer):
+        return False
+    _, _, final_cursor = getattr(buffer, _PLACEHOLDER_ATTR)
+    buffer.exit_selection()
+    buffer.cursor_position = final_cursor
+    delattr(buffer, _PLACEHOLDER_ATTR)
+    return True
+
+
+def _line_offsets(source: str) -> list[int]:
+    offsets = [0]
+    offsets.extend(match.end() for match in re.finditer("\n", source))
+    return offsets
+
+
+def _absolute_token_position(
+    position: tuple[int, int], line_offsets: list[int], source_length: int
+) -> int:
+    row, column = position
+    if 0 < row <= len(line_offsets):
+        return min(line_offsets[row - 1] + column, source_length)
+    return source_length
+
+
+def _python_tokens(source: str) -> list[tuple[tokenize.TokenInfo, int, int]]:
+    line_offsets = _line_offsets(source)
+    tokens: list[tuple[tokenize.TokenInfo, int, int]] = []
+    generator = tokenize.generate_tokens(io.StringIO(source).readline)
+    try:
+        for token in generator:
+            start = _absolute_token_position(token.start, line_offsets, len(source))
+            end = _absolute_token_position(token.end, line_offsets, len(source))
+            tokens.append((token, start, end))
+    except (IndentationError, SyntaxError, tokenize.TokenError):
+        # Incomplete interactive input is normal. Tokens emitted before the
+        # error still describe whether the adjacent closer is syntactic.
+        pass
+    return tokens
+
+
+def _string_parts(value: str) -> tuple[str, str] | None:
+    match = _STRING_START_RE.match(value)
+    if match is None:
+        return None
+    return match.group("prefix"), match.group("quote")
+
+
+def _quoted_string_end(value: str, quote_start: int) -> int:
+    quote = value[quote_start : quote_start + 3]
+    delimiter = quote if quote in {"'''", '"""'} else value[quote_start]
+    index = quote_start + len(delimiter)
+    while index < len(value):
+        if value.startswith(delimiter, index):
+            backslashes = 0
+            before = index - 1
+            while before >= quote_start and value[before] == "\\":
+                backslashes += 1
+                before -= 1
+            if backslashes % 2 == 0:
+                return index + len(delimiter)
+        index += 1
+    return len(value)
+
+
+def _fstring_brace_is_closing(value: str, cursor: int) -> bool:
+    parts = _string_parts(value)
+    if parts is None:
+        return False
+    prefix, quote = parts
+    if "f" not in prefix.lower() or not value.endswith(quote):
+        return False
+
+    content_start = len(prefix) + len(quote)
+    content_end = len(value) - len(quote)
+    if not (content_start <= cursor < content_end) or value[cursor] != "}":
+        return False
+
+    # Each context is [kind, is_format_spec, bracket_stack]. Literal f-string
+    # text and Python replacement expressions follow different brace rules.
+    contexts: list[list[object]] = [["literal", False, []]]
+    index = content_start
+    while index <= cursor and contexts:
+        kind, is_format_spec, bracket_stack = contexts[-1]
+        character = value[index]
+
+        if kind == "literal":
+            if character == "{" and value.startswith("{{", index):
+                index += 2
+                continue
+            if character == "{":
+                contexts.append(["expression", False, []])
+                index += 1
+                continue
+            if character == "}" and is_format_spec:
+                if index == cursor:
+                    return True
+                contexts.pop()
+                index += 1
+                continue
+            if character == "}" and value.startswith("}}", index):
+                index += 2
+                continue
+            if character == "}":
+                return False
+            index += 1
+            continue
+
+        assert isinstance(bracket_stack, list)
+        if character in {"'", '"'}:
+            string_end = _quoted_string_end(value, index)
+            if index < cursor < string_end:
+                # A nested f-string can contain the candidate brace.
+                prefix_start = index
+                while prefix_start > content_start and value[prefix_start - 1] in (
+                    "rRuUbBfF"
+                ):
+                    prefix_start -= 1
+                nested = value[prefix_start:string_end]
+                if "f" in value[prefix_start:index].lower():
+                    return _fstring_brace_is_closing(nested, cursor - prefix_start)
+                return False
+            index = string_end
+            continue
+        if character == "#":
+            newline = value.find("\n", index)
+            if newline == -1 or cursor < newline:
+                return False
+            index = newline + 1
+            continue
+        if character in _OPENING_BRACKETS:
+            bracket_stack.append(character)
+            index += 1
+            continue
+        if character in _CLOSING_BRACKETS:
+            if bracket_stack:
+                if bracket_stack[-1] != _CLOSING_BRACKETS[character]:
+                    return False
+                bracket_stack.pop()
+                index += 1
+                continue
+            if character == "}":
+                if index == cursor:
+                    return True
+                contexts.pop()
+                index += 1
+                continue
+            return False
+        if character == ":" and not bracket_stack:
+            contexts[-1] = ["literal", True, []]
+            index += 1
+            continue
+        index += 1
+    return False
+
+
+def _string_closer_width(
+    source: str,
+    cursor: int,
+    tokens: list[tuple[tokenize.TokenInfo, int, int]],
+) -> int:
+    fstring_end_types = {
+        token_type
+        for token_type in (
+            getattr(tokenize, "FSTRING_END", None),
+            getattr(tokenize, "TSTRING_END", None),
+        )
+        if token_type is not None
+    }
+    for token, start, end in tokens:
+        if (
+            token.type in fstring_end_types
+            and start == cursor
+            and token.string in {"'", '"', "'''", '"""'}
+        ):
+            return len(token.string)
+        if token.type != tokenize.STRING:
+            continue
+        parts = _string_parts(token.string)
+        if parts is None:
+            continue
+        _, quote = parts
+        if end - len(quote) == cursor and source.startswith(quote, cursor):
+            return len(quote)
+    return 0
+
+
+def _bracket_closer_is_syntactic(
+    source: str,
+    cursor: int,
+    tokens: list[tuple[tokenize.TokenInfo, int, int]],
+) -> bool:
+    closer = source[cursor]
+    stack: list[str] = []
+    for token, start, _ in tokens:
+        if start > cursor:
+            break
+        if token.type != tokenize.OP or token.string not in (
+            _OPENING_BRACKETS | _CLOSING_BRACKETS
+        ):
+            continue
+        if start == cursor:
+            return (
+                token.string == closer
+                and bool(stack)
+                and (stack[-1] == _CLOSING_BRACKETS[closer])
+            )
+        if token.string in _OPENING_BRACKETS:
+            stack.append(token.string)
+        elif not stack or stack[-1] != _CLOSING_BRACKETS[token.string]:
+            return False
+        else:
+            stack.pop()
+    return False
+
+
+def _fstring_brace_fallback(
+    source: str,
+    cursor: int,
+    tokens: list[tuple[tokenize.TokenInfo, int, int]],
+) -> bool:
+    for token, start, end in tokens:
+        if token.type == tokenize.STRING and start < cursor < end:
+            return _fstring_brace_is_closing(token.string, cursor - start)
+    return False
+
+
+def _smart_tab_jump_width(source: str, cursor: int) -> int:
+    if cursor >= len(source):
+        return 0
+
+    tokens = _python_tokens(source)
+    quote_width = _string_closer_width(source, cursor, tokens)
+    if quote_width:
+        return quote_width
+
+    if source[cursor] not in _CLOSING_BRACKETS:
+        return 0
+    line_start = source.rfind("\n", 0, cursor) + 1
+    if not source[line_start:cursor].strip():
+        return 0
+    if _bracket_closer_is_syntactic(source, cursor, tokens):
+        return 1
+    if source[cursor] == "}" and _fstring_brace_fallback(source, cursor, tokens):
+        return 1
+    return 0
+
+
+def _smart_tab_jump_enabled(state: PostfixState | None = None) -> bool:
+    state = _state_or_default(state)
+    return state is None or state.config.smart_tab_jump
+
+
+def _can_smart_tab_jump(buffer, state: PostfixState | None = None) -> bool:
+    if not _smart_tab_jump_enabled(state) or _has_active_placeholder(buffer):
+        return False
+    if _postfix_candidates(
+        buffer.document.current_line_before_cursor, exact=True, state=state
+    )[1]:
+        return False
+    return bool(_smart_tab_jump_width(buffer.text, buffer.cursor_position))
+
+
+def _jump_over_closer(buffer) -> bool:
+    width = _smart_tab_jump_width(buffer.text, buffer.cursor_position)
+    if not width:
+        return False
+    if buffer.complete_state is not None:
+        buffer.cancel_completion()
+        width = _smart_tab_jump_width(buffer.text, buffer.cursor_position)
+        if not width:
+            return False
+    buffer.cursor_position += width
     return True
 
 
@@ -299,7 +627,7 @@ def _insert_trigger_and_maybe_complete(buffer) -> bool:
     return True
 
 
-def _make_key_bindings():
+def _make_key_bindings(state: PostfixState | None = None):
     from prompt_toolkit.application.current import get_app
     from prompt_toolkit.filters import Condition
     from prompt_toolkit.key_binding import KeyBindings
@@ -311,14 +639,36 @@ def _make_key_bindings():
         buffer = get_app().current_buffer
         return bool(
             _postfix_candidates(
-                buffer.document.current_line_before_cursor, exact=True
+                buffer.document.current_line_before_cursor,
+                exact=True,
+                state=state,
             )[1]
         )
 
+    @Condition
+    def has_active_placeholder() -> bool:
+        return _has_active_placeholder(get_app().current_buffer)
+
+    @Condition
+    def can_smart_tab_jump() -> bool:
+        return _can_smart_tab_jump(get_app().current_buffer, state)
+
+    @key_bindings.add("tab", filter=has_active_placeholder)
+    def accept_placeholder(event) -> None:
+        _accept_placeholder(event.current_buffer)
+
+    @key_bindings.add("enter", filter=has_active_placeholder)
+    def accept_placeholder_with_enter(event) -> None:
+        _accept_placeholder(event.current_buffer)
+
     @key_bindings.add("tab", filter=has_exact_postfix)
     def expand_postfix(event) -> None:
         _expand_buffer(event.current_buffer)
 
+    @key_bindings.add("tab", filter=can_smart_tab_jump)
+    def smart_tab_jump(event) -> None:
+        _jump_over_closer(event.current_buffer)
+
     @key_bindings.add(".")
     def insert_trigger(event) -> None:
         _insert_trigger_and_maybe_complete(event.current_buffer)
@@ -400,10 +750,12 @@ def _postfix_template_magic(line: str) -> None:
 
 def _list_postfix_templates(state: PostfixState) -> None:
     effective = state.effective_templates()
-    names = set(DEFAULT_TEMPLATES) | set(state.config.templates) | set(
-        state.runtime_templates or {}
-    ) | set(state.config.disabled_templates) | set(
-        state.runtime_disabled_templates or set()
+    names = (
+        set(DEFAULT_TEMPLATES)
+        | set(state.config.templates)
+        | set(state.runtime_templates or {})
+        | set(state.config.disabled_templates)
+        | set(state.runtime_disabled_templates or set())
     )
     for name in sorted(names):
         origin = state.template_origin(name)
@@ -435,7 +787,7 @@ class PostfixPTCompleter(IPythonPTCompleter):
 
             fragment = body[completion.start : completion.end]
             line_start = body.rfind("\n", 0, completion.start) + 1
-            indent = body[line_start:completion.start]
+            indent = body[line_start : completion.start]
             state = _state_or_default()
             key = _template_name(fragment, completion.text, indent, state) or "postfix"
             display = f".{key} -> {completion.text}"
@@ -484,7 +836,9 @@ def _install_key_binding(ip, state: PostfixState) -> None:
     from prompt_toolkit.key_binding import merge_key_bindings
 
     state.original_key_bindings = original
-    pt_app.key_bindings = merge_key_bindings([_make_key_bindings(), original])
+    # prompt-toolkit resolves the last active binding. Keep extension bindings
+    # last so their filtered Tab cases win while native bindings remain fallback.
+    pt_app.key_bindings = merge_key_bindings([original, _make_key_bindings(state)])
 
 
 def load_ipython_extension(ip) -> None:

{ipython_postfix_completion-0.1.1.dist-info → ipython_postfix_completion-0.2.0.dist-info}/METADATA

@@ -1,9 +1,13 @@
 Metadata-Version: 2.4
 Name: ipython-postfix-completion
-Version: 0.1.1
+Version: 0.2.0
 Summary: Configurable postfix completion extension for IPython.
 Author: IPython Postfix Completion Contributors
 License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/fishandsheep/ipython-postfix-completion
+Project-URL: Repository, https://github.com/fishandsheep/ipython-postfix-completion
+Project-URL: Issues, https://github.com/fishandsheep/ipython-postfix-completion/issues
+Project-URL: Changelog, https://github.com/fishandsheep/ipython-postfix-completion/blob/main/CHANGELOG.md
 Keywords: ipython,completion,postfix,extension
 Classifier: Framework :: IPython
 Classifier: Intended Audience :: Developers
@@ -12,16 +16,19 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: ipython>=9.0
+Requires-Dist: ipython<10,>=9.0
 Requires-Dist: traitlets>=5.13
 Provides-Extra: test
 Requires-Dist: pytest>=7; extra == "test"
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
+Requires-Dist: pip-audit>=2.7; extra == "dev"
+Requires-Dist: ruff>=0.8; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: ipython-postfix-completion[test]; extra == "dev"
 Dynamic: license-file
@@ -60,6 +67,10 @@ To load it automatically, add this to `ipython_config.py`:
 c.InteractiveShellApp.extensions = ["ipython_postfix_completion"]
 ```
 
+Smart Tab key bindings are supported in terminal IPython. Postfix matcher
+completion can also work in other IPython frontends, but this package does not
+promise frontend-specific Tab behavior outside the terminal.
+
 ## Quick Example: Add a `for` Template
 
 Add a template for the current IPython session:
@@ -130,11 +141,59 @@ c.PostfixCompletionConfig.templates = {
 c.PostfixCompletionConfig.disabled_templates = ["tuple"]
 ```
 
+Smart Tab jump is enabled by default. Disable it while keeping postfix
+completion with:
+
+```python
+c.PostfixCompletionConfig.smart_tab_jump = False
+```
+
 Template names must match `[A-Za-z_][A-Za-z0-9_]*`.
 
 Templates must include `{expr}` and may also use `{indent}`. No other template
 fields are allowed.
 
+## `.var` Placeholder
+
+The built-in `.var` template creates an assignment and selects `key` as an
+editable placeholder:
+
+```text
+"hello".var<Tab>  ->  key = "hello"
+                       ^^^ selected
+```
+
+While `key` remains selected:
+
+- Tab accepts `key` and moves cursor to the end of the assignment.
+- Enter behaves like Tab for this selection only; press Enter again to submit.
+- Any other typed text replaces `key` with a custom variable name.
+
+In 0.1.x, `.var` produced `expr = ` with the cursor after the assignment
+target. Version 0.2.0 changes this to `key = expr` with an editable
+placeholder; use a custom template if you need the old behavior.
+
+## Smart Tab Jump
+
+When cursor is immediately before a valid Python closing token, Tab moves over
+it without changing source text. Repeated Tab presses exit nested constructs:
+
+```text
+"hello|"                 -> "hello"|
+print("hello|")          -> print("hello"|) -> print("hello")|
+print(f"{name|}")        -> print(f"{name}|") -> print(f"{name}"|) -> print(f"{name}")|
+items[index|]            -> items[index]|
+list[dict[str, int|]]    -> list[dict[str, int]|] -> list[dict[str, int]]|
+{"name": value|}         -> {"name": value}|
+```
+
+`|` marks cursor and is not typed. Supported closers are single and triple
+quotes plus `)`, `]`, and `}`. Detection follows Python tokens, including
+multiline input, string prefixes, and f-string expressions. Tab still accepts
+the `.var` name selection or an exact postfix template first; otherwise it
+falls back to IPython completion or indentation. Ambiguous `< >`, colon, and
+comma are intentionally excluded.
+
 ## Built-in Templates
 
 Default templates:
@@ -145,7 +204,7 @@ Default templates:
 | `len` | `len({expr})` |
 | `not` | `not {expr}` |
 | `par` | `({expr})` |
-| `var` | `{expr} = ` |
+| `var` | `key = {expr}`; selects `key`; Tab or Enter accepts it |
 | `await` | `await {expr}` |
 | `return` | `return {expr}` |
 | `if` | `if {expr}:\n{indent}    ` |
@@ -167,6 +226,9 @@ Run tests:
 
 ```bash
 uv run --extra test pytest -q
+uv run --extra dev ruff check .
+uv run --extra dev ruff format --check .
+uv run --isolated --no-project --with "ipython>=9,<10" --with "traitlets>=5.13" --with "pip-audit>=2.7" pip-audit --strict --local
 ```
 
 Build and check release artifacts:
@@ -205,14 +267,16 @@ existing PyPI project once under **Manage > Publishing > Add a new publisher**:
 | Environment | `pypi` |
 
 For each release, update `project.version` in `pyproject.toml`, commit and push
-the change, then create a matching `v` tag. For example, after changing the
-version to `0.1.1`:
+the change, then create a matching `v` tag. For this release:
 
 ```bash
-git tag v0.1.1
-git push origin v0.1.1
+git tag v0.2.0
+git push origin v0.2.0
 ```
 
 The workflow verifies the tag against `project.version`, runs tests, builds and
 checks both distributions, then publishes them to PyPI using a short-lived OIDC
-credential. The already-published `0.1.0` release cannot be uploaded again.
+credential. PyPI versions are immutable: never reuse a published version or tag;
+fixes require the next version.
+
+See [CHANGELOG.md](CHANGELOG.md) for release notes and migration guidance.

ipython_postfix_completion-0.2.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+ipython_postfix_completion/__init__.py,sha256=K9fMAo6kLY3JeUe9SfEp83Om-KsYTcDrC6Fyhhy3VUQ,30361
+ipython_postfix_completion-0.2.0.dist-info/licenses/LICENSE,sha256=omLR-7QW1K3l6AG7ih1N5L8Z58UY-ROrQL82ANN9PnM,1547
+ipython_postfix_completion-0.2.0.dist-info/METADATA,sha256=CwKUKdYbwrxPvVFLnTEJ3n-_sD_E4CRvBoiM1pHb_ds,7767
+ipython_postfix_completion-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ipython_postfix_completion-0.2.0.dist-info/top_level.txt,sha256=W2sJCvsBheoCB2nbzJeD7-p5PR6lVDNicVLxNxmeraY,27
+ipython_postfix_completion-0.2.0.dist-info/RECORD,,

{ipython_postfix_completion-0.1.1.dist-info → ipython_postfix_completion-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (83.0.0)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ipython_postfix_completion-0.1.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-ipython_postfix_completion/__init__.py,sha256=Ihs9zrkmwcmDydHIxRn4KU7yeRR_NWxHpB9WaidvyXs,18145
-ipython_postfix_completion-0.1.1.dist-info/licenses/LICENSE,sha256=omLR-7QW1K3l6AG7ih1N5L8Z58UY-ROrQL82ANN9PnM,1547
-ipython_postfix_completion-0.1.1.dist-info/METADATA,sha256=10PHgmlDTJQVOwdahbiqMKFEdkxQvdCEvWyO1jo3uQk,4960
-ipython_postfix_completion-0.1.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-ipython_postfix_completion-0.1.1.dist-info/top_level.txt,sha256=W2sJCvsBheoCB2nbzJeD7-p5PR6lVDNicVLxNxmeraY,27
-ipython_postfix_completion-0.1.1.dist-info/RECORD,,