ipython-postfix-completion 0.1.1__py3-none-any.whl → 0.2.1__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,26 @@ _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"
+_FOR_TEMPLATE = "for item in {expr}:\n{indent}    pass"
+_FORI_TEMPLATE = "for i, value in enumerate({expr}):\n{indent}    pass"
+_IF_TEMPLATE = "if {expr}:\n{indent}    pass"
+_EF_TEMPLATE = (
+    "if {expr}:\n{indent}    pass\n{indent}elif cond:\n{indent}    pass"
+    "\n{indent}else:\n{indent}    pass"
+)
+_TEMPLATE_PLACEHOLDERS = {
+    "for": (_FOR_TEMPLATE, ("item", "pass")),
+    "fori": (_FORI_TEMPLATE, ("i", "value", "pass")),
+    "if": (_IF_TEMPLATE, ("pass",)),
+    "ef": (_EF_TEMPLATE, ("pass", "cond", "pass", "pass")),
+}
+_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,11 +69,14 @@ 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}    ",
+    "if": _IF_TEMPLATE,
     "while": "while {expr}:\n{indent}    ",
+    "for": _FOR_TEMPLATE,
+    "fori": _FORI_TEMPLATE,
+    "ef": _EF_TEMPLATE,
     "raise": "raise {expr}",
     "yield": "yield {expr}",
     "str": "str({expr})",
@@ -65,6 +84,8 @@ DEFAULT_TEMPLATES: dict[str, str] = {
     "set": "set({expr})",
     "dict": "dict({expr})",
     "tuple": "tuple({expr})",
+    "type": "type({expr})",
+    "range": "range({expr})",
 }
 
 
@@ -88,22 +109,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))
@@ -127,6 +161,30 @@ def _render_template(template: str, expr: str, indent: str = "") -> str:
     return _FORMATTER.format(template, expr=expr, indent=indent)
 
 
+def _is_integer_literal(expr: str) -> bool:
+    try:
+        node = ast.parse(expr, mode="eval").body
+    except SyntaxError:
+        return False
+    if isinstance(node, ast.Constant):
+        return type(node.value) is int
+    return (
+        isinstance(node, ast.UnaryOp)
+        and isinstance(node.op, (ast.UAdd, ast.USub))
+        and _is_integer_literal(ast.unparse(node.operand))
+    )
+
+
+def _render_candidate(name: str, template: str, expr: str, indent: str = "") -> str:
+    wraps_integer = _is_integer_literal(expr) and (
+        (name == "for" and template == _FOR_TEMPLATE)
+        or (name == "fori" and template == _FORI_TEMPLATE)
+    )
+    if wraps_integer:
+        expr = f"range({expr})"
+    return _render_template(template, expr, indent)
+
+
 @dataclass
 class PostfixState:
     matcher: Callable[[CompletionContext], dict]
@@ -228,7 +286,7 @@ def _effective_templates(state: PostfixState | None = None) -> dict[str, str]:
 def _apply_template(
     name: str, expr: str, indent: str = "", state: PostfixState | None = None
 ) -> str:
-    return _render_template(_effective_templates(state)[name], expr, indent)
+    return _render_candidate(name, _effective_templates(state)[name], expr, indent)
 
 
 def _postfix_candidates(
@@ -248,7 +306,7 @@ def _postfix_candidates(
         if (name == prefix if exact else name.startswith(prefix))
     ]
     return f"{expr}.{prefix}", [
-        _render_template(templates[name], expr, indent) for name in names
+        _render_candidate(name, templates[name], expr, indent) for name in names
     ]
 
 
@@ -262,7 +320,7 @@ def _template_name(
     for name, template in _effective_templates(state).items():
         if not name.startswith(prefix):
             continue
-        if _render_template(template, expr, indent) == expansion:
+        if _render_candidate(name, template, expr, indent) == expansion:
             return name
     return None
 
@@ -286,8 +344,399 @@ 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])
+    placeholder_config = (
+        _TEMPLATE_PLACEHOLDERS.get(parsed[2]) if parsed is not None else None
+    )
+    if (
+        parsed is not None
+        and placeholder_config is not None
+        and _effective_templates().get(parsed[2]) == placeholder_config[0]
+    ):
+        search_from = 0
+        ranges = []
+        for placeholder_text in placeholder_config[1]:
+            start = candidates[0].index(placeholder_text, search_from)
+            end = start + len(placeholder_text)
+            ranges.append((start, end))
+            search_from = end
+        _select_placeholders(
+            buffer,
+            expansion_start,
+            ranges,
+            buffer.cursor_position,
+        )
+    elif (
+        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:
+    _select_placeholders(buffer, start, [(start, end)], final_cursor, absolute=True)
+
+
+def _select_placeholders(
+    buffer,
+    start: int,
+    ranges: list[tuple[int, int]],
+    final_cursor: int,
+    *,
+    absolute: bool = False,
+    index: int = 0,
+) -> None:
+    from prompt_toolkit.selection import SelectionState, SelectionType
+
+    if not absolute:
+        ranges = [(start + left, start + right) for left, right in ranges]
+    setattr(buffer, _PLACEHOLDER_ATTR, (ranges, index, final_cursor))
+    left, right = ranges[index]
+    buffer.cursor_position = right
+    buffer.selection_state = SelectionState(left, SelectionType.CHARACTERS)
+    buffer.selection_state.enter_shift_mode()
+
+
+def _has_active_placeholder(buffer) -> bool:
+    placeholder = getattr(buffer, _PLACEHOLDER_ATTR, None)
+    selection = buffer.selection_state
+    if placeholder is None:
+        return False
+    ranges, index, _ = placeholder
+    start, end = ranges[index]
+    return (selection is None and len(ranges) > 1) or (
+        selection is not None
+        and selection.shift_mode
+        and selection.original_cursor_position == start
+        and buffer.cursor_position == end
+        and (len(ranges) > 1 or buffer.text[start:end] == _VAR_PLACEHOLDER)
+    )
+
+
+def _accept_placeholder(buffer) -> bool:
+    if not _has_active_placeholder(buffer):
+        return False
+    ranges, index, final_cursor = _update_placeholder_after_edit(buffer)
+    if buffer.selection_state is not None:
+        buffer.exit_selection()
+    if index + 1 < len(ranges):
+        _select_placeholders(
+            buffer, 0, ranges, final_cursor, absolute=True, index=index + 1
+        )
+    else:
+        delattr(buffer, _PLACEHOLDER_ATTR)
+        buffer.cursor_position = final_cursor
+    return True
+
+
+def _update_placeholder_after_edit(buffer):
+    ranges, index, final_cursor = getattr(buffer, _PLACEHOLDER_ATTR)
+    if buffer.selection_state is None:
+        start, old_end = ranges[index]
+        new_end = buffer.cursor_position
+        delta = new_end - old_end
+        final_cursor += delta
+        ranges = [
+            (start, new_end)
+            if stop == index
+            else (left + delta, right + delta)
+            if stop > index
+            else (left, right)
+            for stop, (left, right) in enumerate(ranges)
+        ]
+        setattr(buffer, _PLACEHOLDER_ATTR, (ranges, index, final_cursor))
+    return ranges, index, final_cursor
+
+
+def _reverse_placeholder(buffer) -> bool:
+    if not _has_active_placeholder(buffer):
+        return False
+    ranges, index, final_cursor = _update_placeholder_after_edit(buffer)
+    previous_index = max(0, index - 1)
+    _select_placeholders(
+        buffer,
+        0,
+        ranges,
+        final_cursor,
+        absolute=True,
+        index=previous_index,
+    )
+    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 +748,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 +760,40 @@ 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("s-tab", filter=has_active_placeholder)
+    def reverse_placeholder(event) -> None:
+        _reverse_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 +875,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 +912,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 +961,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.2.1.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: ipython-postfix-completion
+Version: 0.2.1
+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
+Classifier: Programming Language :: Python :: 3
+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<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
+
+# IPython Postfix Completion
+
+Complete Python expressions with postfix templates in IPython: type an
+expression, a dot, and a template name, then press Tab.
+
+## Install
+
+```bash
+uv tool install ipython --with ipython-postfix-completion
+```
+
+Start IPython and load the extension:
+
+```python
+%load_ext ipython_postfix_completion
+```
+
+## Common Templates
+
+`items.for<Tab>` creates a loop. Tab selects `item`, then `pass`; type to
+replace a selection.
+
+```python
+for item in items:
+    pass
+```
+
+An integer literal is wrapped in `range(...)`, so `10.for<Tab>` produces
+`for item in range(10):`.
+
+`items.fori<Tab>` creates an indexed loop. Tab selects `i`, `value`, then
+`pass`. For an integer literal, it uses `enumerate(range(n))`.
+
+`condition.if<Tab>` creates an `if` block with a selected `pass`:
+
+```python
+if condition:
+    pass
+```
+
+`condition.ef<Tab>` creates `if`/`elif`/`else` branches. Tab selects each
+placeholder in order: `pass`, `cond`, `pass`, `pass`. The `cond` selection
+does not include its colon.
+
+Other built-ins: `print`, `len`, `not`, `par`, `var`, `await`, `return`,
+`while`, `raise`, `yield`, `str`, `list`, `set`, `dict`, `tuple`, `type`, and
+`range`. Use `%postfix_template list` to see their expansions.
+
+Shift+Tab moves back to the previous placeholder. Custom Tab navigation is
+supported in terminal IPython.
+
+## Load Automatically
+
+The default configuration file is:
+
+```text
+~/.ipython/profile_default/ipython_config.py
+```
+
+Create it with:
+
+```bash
+ipython profile create
+```
+
+Add the extension and any persistent templates there:
+
+```python
+c.InteractiveShellApp.extensions = ["ipython_postfix_completion"]
+c.PostfixCompletionConfig.templates = {
+    "debug": "print({expr}=)",
+}
+```
+
+`IPYTHONDIR` and `--ipython-dir` can change the configuration directory. Use
+`ipython locate profile default` to find the active profile. See the [official
+IPython configuration guide](https://ipython.readthedocs.io/en/stable/development/config.html).
+
+For runtime template commands, detailed behavior, and contributor or release
+steps, see [the extended guide](docs/REFERENCE.md).

ipython_postfix_completion-0.2.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+ipython_postfix_completion/__init__.py,sha256=OeNt29f_YF-MT01GxZu233B28Il7xUuWLOVLiSdWEPk,34444
+ipython_postfix_completion-0.2.1.dist-info/licenses/LICENSE,sha256=omLR-7QW1K3l6AG7ih1N5L8Z58UY-ROrQL82ANN9PnM,1547
+ipython_postfix_completion-0.2.1.dist-info/METADATA,sha256=uLGeW00R_fljuKcFU9TGUX8UUaC6B9EreQvi_qmfVnE,3655
+ipython_postfix_completion-0.2.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ipython_postfix_completion-0.2.1.dist-info/top_level.txt,sha256=W2sJCvsBheoCB2nbzJeD7-p5PR6lVDNicVLxNxmeraY,27
+ipython_postfix_completion-0.2.1.dist-info/RECORD,,

{ipython_postfix_completion-0.1.1.dist-info → ipython_postfix_completion-0.2.1.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/METADATA

@@ -1,218 +0,0 @@
-Metadata-Version: 2.4
-Name: ipython-postfix-completion
-Version: 0.1.1
-Summary: Configurable postfix completion extension for IPython.
-Author: IPython Postfix Completion Contributors
-License-Expression: BSD-3-Clause
-Keywords: ipython,completion,postfix,extension
-Classifier: Framework :: IPython
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-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: 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: traitlets>=5.13
-Provides-Extra: test
-Requires-Dist: pytest>=7; extra == "test"
-Provides-Extra: dev
-Requires-Dist: build; extra == "dev"
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: ipython-postfix-completion[test]; extra == "dev"
-Dynamic: license-file
-
-# IPython Postfix Completion
-
-Configurable postfix completion extension for IPython.
-
-Package on PyPI: `ipython-postfix-completion`
-
-## Install
-
-Install into the current Python environment with `uv`:
-
-```bash
-uvx --with ipython-postfix-completion ipython
-```
-
-Install into the current ipython environment with `uv`:
-
-```bash
-uv tool install ipython --with ipython-postfix-completion
-```
-
-## Load
-
-Inside IPython:
-
-```python
-%load_ext ipython_postfix_completion
-```
-
-To load it automatically, add this to `ipython_config.py`:
-
-```python
-c.InteractiveShellApp.extensions = ["ipython_postfix_completion"]
-```
-
-## Quick Example: Add a `for` Template
-
-Add a template for the current IPython session:
-
-```python
-%postfix_template add for "for item in {expr}:\n{indent}    "
-```
-
-Use it:
-
-```python
-items.for<Tab>
-```
-
-It expands to:
-
-```python
-for item in items:
-    
-```
-
-Runtime templates only affect the current IPython session. Put templates in
-`ipython_config.py` if you want them to persist.
-
-## Runtime Magic
-
-List effective templates:
-
-```python
-%postfix_template list
-```
-
-Add or override a template for the current session:
-
-```python
-%postfix_template add debug "print({expr}=)"
-%postfix_template add forin "for item in {expr}:\n{indent}    "
-```
-
-Disable a template for the current session:
-
-```python
-%postfix_template remove tuple
-```
-
-Reset one runtime change:
-
-```python
-%postfix_template reset forin
-```
-
-Reset all runtime changes:
-
-```python
-%postfix_template reset --all
-```
-
-## Persistent Config
-
-Add persistent templates in `ipython_config.py`:
-
-```python
-c.PostfixCompletionConfig.templates = {
-    "debug": "print({expr}=)",
-    "forin": "for item in {expr}:\n{indent}    ",
-}
-
-c.PostfixCompletionConfig.disabled_templates = ["tuple"]
-```
-
-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.
-
-## Built-in Templates
-
-Default templates:
-
-| Name | Expansion |
-| --- | --- |
-| `print` | `print({expr})` |
-| `len` | `len({expr})` |
-| `not` | `not {expr}` |
-| `par` | `({expr})` |
-| `var` | `{expr} = ` |
-| `await` | `await {expr}` |
-| `return` | `return {expr}` |
-| `if` | `if {expr}:\n{indent}    ` |
-| `while` | `while {expr}:\n{indent}    ` |
-| `raise` | `raise {expr}` |
-| `yield` | `yield {expr}` |
-| `str` | `str({expr})` |
-| `list` | `list({expr})` |
-| `set` | `set({expr})` |
-| `dict` | `dict({expr})` |
-| `tuple` | `tuple({expr})` |
-
-Use `%postfix_template list` in IPython to see the exact effective set, including
-custom and disabled templates.
-
-## Local Validation
-
-Run tests:
-
-```bash
-uv run --extra test pytest -q
-```
-
-Build and check release artifacts:
-
-```bash
-uv run --extra dev python -m build
-uv run --extra dev python -m twine check dist/*
-```
-
-Validate the wheel in a clean local virtual environment:
-
-```bash
-uv venv .venv-check
-uv pip install --python .venv-check/bin/python dist/*.whl
-.venv-check/bin/ipython
-```
-
-Then inside IPython:
-
-```python
-%load_ext ipython_postfix_completion
-%postfix_template add for "for item in {expr}:\n{indent}    "
-%postfix_template list
-```
-
-## Publish
-
-Publishing uses GitHub Actions and PyPI Trusted Publishing. Configure the
-existing PyPI project once under **Manage > Publishing > Add a new publisher**:
-
-| Setting | Value |
-| --- | --- |
-| Owner | `fishandsheep` |
-| Repository | `ipython-postfix-completion` |
-| Workflow | `publish.yml` |
-| 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`:
-
-```bash
-git tag v0.1.1
-git push origin v0.1.1
-```
-
-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.

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,,