rp 0.1.1359__tar.gz → 0.1.1360__tar.gz

{rp-0.1.1359 → rp-0.1.1360}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: rp
-Version: 0.1.1359
+Version: 0.1.1360
 Summary: Ryan's Python: IDE + Library + Tools
 Home-page: https://github.com/RyannDaGreat/rp
 Author: Ryan Burgert

{rp-0.1.1359 → rp-0.1.1360}/rp/prompt_toolkit/buffer.py

@@ -684,15 +684,16 @@ class Buffer(object):
 
     def save_to_undo_stack(self, clear_redo_stack=False):
         """
-        Safe current state (input text and cursor position), so that we can
+        Safe current state (input text, cursor position, selection), so that we can
         restore it by calling undo.
         """
         # Safe if the text is different from the text at the top of the stack
-        # is different. If the text is the same, just update the cursor position.
+        # is different. If the text is the same, just update the cursor position and selection.
+        selection = self.selection_state  # Use selection_state, not document.selection
         if self._undo_stack and self._undo_stack[-1][0] == self.text:
-            self._undo_stack[-1] = (self._undo_stack[-1][0], self.cursor_position)
+            self._undo_stack[-1] = (self._undo_stack[-1][0], self.cursor_position, selection)
         else:
-            self._undo_stack.append((self.text, self.cursor_position))
+            self._undo_stack.append((self.text, self.cursor_position, selection))
 
         # Saving anything to the undo stack, clears the redo stack.
         if clear_redo_stack:
@@ -1346,15 +1347,20 @@ class Buffer(object):
         # cause that the top of the undo stack is usually the same as the
         # current text, so in that case we have to pop twice.)
         while self._undo_stack:
-            text, pos = self._undo_stack.pop()
+            item = self._undo_stack.pop()
+            # Handle both old (text, pos) and new (text, pos, selection) formats
+            text, pos = item[0], item[1]
+            selection = item[2] if len(item) > 2 else None
 
             if text != self.text:
                 # Push current text to redo stack.
                 # ring_terminal_bell()
-                self._redo_stack.append((self.text, self.cursor_position))
+                self._redo_stack.append((self.text, self.cursor_position, self.selection_state))
                 # print(self._redo_stack)
-                # Set new text/cursor_position.
+                # Set new text/cursor_position, then restore selection_state
+                # (document setter triggers _text_changed which clears selection_state)
                 self.document = Document(text, cursor_position=pos)
+                self.selection_state = selection
                 break
 
     def redo(self):
@@ -1365,8 +1371,14 @@ class Buffer(object):
             self.save_to_undo_stack(clear_redo_stack=False)
 
             # Pop state from redo stack.
-            text, pos = self._redo_stack.pop()
+            item = self._redo_stack.pop()
+            # Handle both old (text, pos) and new (text, pos, selection) formats
+            text, pos = item[0], item[1]
+            selection = item[2] if len(item) > 2 else None
+            # Set text/cursor first, then restore selection_state
+            # (document setter triggers _text_changed which clears selection_state)
             self.document = Document(text, cursor_position=pos)
+            self.selection_state = selection
         # else:
         #     text_to_speech("FAILED")
 

rp-0.1.1360/rp/rp_ptpython/ast_selection.py

@@ -0,0 +1,85 @@
+"""
+AST-based smart selection for Python code.
+
+Fallback for when tree-sitter is not available. Only works with valid syntax.
+"""
+from typing import List, Tuple, Optional, Set
+import ast
+
+from .selection_utils import (
+    get_word_spans,
+    get_string_content_spans,
+    get_bracket_spans,
+    get_line_spans,
+    get_indent_paragraph_spans,
+    get_comment_block_spans,
+    find_next_span,
+    contract,
+)
+
+
+def get_ast_spans(code: str) -> Set[Tuple[int, int]]:
+    """Get spans from Python AST nodes."""
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return set()
+
+    spans = set()
+    lines = code.split('\n')
+
+    def offset(lineno: int, col: int) -> int:
+        return sum(len(line) + 1 for line in lines[:lineno - 1]) + col
+
+    def visit(node):
+        if hasattr(node, 'lineno') and hasattr(node, 'col_offset'):
+            start = offset(node.lineno, node.col_offset)
+            if hasattr(node, 'end_lineno') and hasattr(node, 'end_col_offset'):
+                end = offset(node.end_lineno, node.end_col_offset)
+            else:
+                end = start + 1
+            spans.add((start, end))
+        for child in ast.iter_child_nodes(node):
+            visit(child)
+
+    visit(tree)
+    return spans
+
+
+def get_synthetic_spans(code: str) -> Set[Tuple[int, int]]:
+    """Get all synthetic (non-AST) spans."""
+    spans = set()
+    spans |= get_word_spans(code)
+    spans |= get_string_content_spans(code)
+    spans |= get_bracket_spans(code)
+    spans |= get_line_spans(code)
+    spans |= get_indent_paragraph_spans(code)
+    spans |= get_comment_block_spans(code)
+    return spans
+
+
+def expand_selection(
+    code: str,
+    start: int,
+    end: int,
+    history: List[Tuple[int, int]]
+) -> Optional[Tuple[int, int, List[Tuple[int, int]]]]:
+    """Expand selection to next span."""
+    ast_spans = get_ast_spans(code)
+    synthetic = get_synthetic_spans(code)
+    all_spans = ast_spans | synthetic
+    # For AST fallback, use all AST spans as atomic (stricter validation)
+    result = find_next_span(start, end, all_spans, ast_spans, code=code)
+    if result:
+        return (result[0], result[1], history + [(start, end)])
+    return None
+
+
+def contract_selection(
+    code: str,
+    start: int,
+    end: int,
+    history: List[Tuple[int, int]]
+) -> Optional[Tuple[int, int, List[Tuple[int, int]]]]:
+    """Contract selection by popping history."""
+    return contract(history)

rp-0.1.1360/rp/rp_ptpython/bash_selection.py

@@ -0,0 +1,198 @@
+"""
+Tree-sitter based smart selection for Bash code.
+
+Uses tree-sitter-bash for robust parsing that handles incomplete syntax.
+"""
+from typing import List, Tuple, Optional, Set
+import tree_sitter
+import tree_sitter_bash
+
+from .selection_utils import (
+    get_word_spans,
+    get_bracket_spans,
+    get_line_spans,
+    get_indent_paragraph_spans,
+    find_next_span,
+    contract,
+)
+
+_parser = None
+
+
+def _get_parser():
+    global _parser
+    if _parser is None:
+        lang = tree_sitter.Language(tree_sitter_bash.language())
+        _parser = tree_sitter.Parser(lang)
+    return _parser
+
+
+# Node types that are "atomic" - cannot be split by synthetic spans
+ATOMIC_NODE_TYPES = {
+    'word', 'string', 'raw_string', 'ansii_c_string', 'heredoc_body',
+    'number', 'variable_name', 'special_variable_name',
+    'simple_expansion', 'expansion',
+}
+
+
+def get_bash_string_content_spans(code: str) -> Set[Tuple[int, int]]:
+    """Spans for string contents (without quotes) in bash."""
+    spans, i = set(), 0
+    while i < len(code):
+        if code[i] == '"':
+            # Double quote - find matching
+            j = i + 1
+            while j < len(code) and code[j] != '"':
+                if code[j] == '\\' and j + 1 < len(code):
+                    j += 2
+                else:
+                    j += 1
+            if j < len(code) and j > i + 1:
+                spans.add((i + 1, j))
+            i = j + 1 if j < len(code) else j
+        elif code[i] == "'":
+            # Single quote - literal, no escapes
+            j = i + 1
+            while j < len(code) and code[j] != "'":
+                j += 1
+            if j < len(code) and j > i + 1:
+                spans.add((i + 1, j))
+            i = j + 1 if j < len(code) else j
+        elif code[i] == '$' and i + 1 < len(code) and code[i + 1] == "'":
+            # $'...' ANSI-C quoting
+            j = i + 2
+            while j < len(code) and code[j] != "'":
+                if code[j] == '\\' and j + 1 < len(code):
+                    j += 2
+                else:
+                    j += 1
+            if j < len(code) and j > i + 2:
+                spans.add((i + 2, j))
+            i = j + 1 if j < len(code) else j
+        else:
+            i += 1
+    return spans
+
+
+def get_bash_comment_block_spans(code: str) -> Set[Tuple[int, int]]:
+    """Spans for contiguous comment blocks."""
+    spans, offset, start, end = set(), 0, None, None
+    for line in code.split('\n'):
+        stripped = line.strip()
+        if stripped.startswith('#') and not stripped.startswith('#!'):
+            if start is None:
+                start = offset
+            end = offset + len(line)
+        elif start is not None:
+            spans.add((start, end))
+            start = None
+        offset += len(line) + 1
+    if start is not None:
+        spans.add((start, end))
+    return spans
+
+
+def get_ast_spans_and_atomic(code: str) -> Tuple[Set[Tuple[int, int]], Set[Tuple[int, int]]]:
+    """
+    Get spans for all tree-sitter nodes, plus identify atomic spans.
+
+    Returns:
+        (all_spans, atomic_spans) - atomic spans are nodes that can't be split
+    """
+    tree = _get_parser().parse(bytes(code, 'utf8'))
+    all_spans = set()
+    atomic_spans = set()
+
+    def visit(node):
+        span = (node.start_byte, node.end_byte)
+        all_spans.add(span)
+
+        if node.type in ATOMIC_NODE_TYPES:
+            atomic_spans.add(span)
+
+        for child in node.children:
+            visit(child)
+
+    visit(tree.root_node)
+    return all_spans, atomic_spans
+
+
+def get_ast_spans(code: str) -> Set[Tuple[int, int]]:
+    """Get spans for all tree-sitter nodes."""
+    all_spans, _ = get_ast_spans_and_atomic(code)
+    return all_spans
+
+
+def get_pipe_sequence_spans(code: str) -> Set[Tuple[int, int]]:
+    """Get spans for individual commands in a pipeline."""
+    tree = _get_parser().parse(bytes(code, 'utf8'))
+    spans = set()
+
+    def visit(node):
+        # For pipelines, add each command as a span
+        if node.type == 'pipeline':
+            for child in node.children:
+                if child.type not in ('|', '|&'):
+                    spans.add((child.start_byte, child.end_byte))
+
+        # For command lists (&&, ||, ;)
+        if node.type == 'list':
+            for child in node.children:
+                if child.type not in ('&&', '||', ';'):
+                    spans.add((child.start_byte, child.end_byte))
+
+        for child in node.children:
+            visit(child)
+
+    visit(tree.root_node)
+    return spans
+
+
+def get_synthetic_spans(code: str) -> Set[Tuple[int, int]]:
+    """Get all synthetic (non-AST) spans for bash."""
+    spans = set()
+    spans |= get_word_spans(code)
+    spans |= get_bash_string_content_spans(code)
+    spans |= get_bracket_spans(code)
+    spans |= get_line_spans(code)
+    spans |= get_indent_paragraph_spans(code)
+    spans |= get_bash_comment_block_spans(code)
+    spans |= get_pipe_sequence_spans(code)
+    return spans
+
+
+def get_all_spans(code: str) -> Tuple[Set[Tuple[int, int]], Set[Tuple[int, int]]]:
+    """
+    Get all candidate spans and atomic spans for selection.
+
+    Returns (all_spans, atomic_spans)
+    """
+    ast_spans, atomic_spans = get_ast_spans_and_atomic(code)
+    synthetic_spans = get_synthetic_spans(code)
+    return ast_spans | synthetic_spans, atomic_spans
+
+
+def expand_selection(
+    code: str,
+    start: int,
+    end: int,
+    history: List[Tuple[int, int]]
+) -> Optional[Tuple[int, int, List[Tuple[int, int]]]]:
+    """Expand selection to next span."""
+    ast_spans, atomic_spans = get_ast_spans_and_atomic(code)
+    synthetic_spans = get_synthetic_spans(code)
+    all_spans = ast_spans | synthetic_spans
+    result = find_next_span(start, end, all_spans, atomic_spans, ast_spans, code)
+    if result:
+        return (result[0], result[1], history + [(start, end)])
+    return None
+
+
+def contract_selection(
+    code: str,
+    start: int,
+    end: int,
+    history: List[Tuple[int, int]]
+) -> Optional[Tuple[int, int, List[Tuple[int, int]]]]:
+    """Contract selection by popping history."""
+    return contract(history)

{rp-0.1.1359 → rp-0.1.1360}/rp/rp_ptpython/completer.py

@@ -313,9 +313,7 @@ class PythonCompleter(Completer):
 
         # Import statements
         if re.fullmatch(r'\s*(from|import)\s+\w*', before_line):
-            python_candidates = [Candidate(name=name) for name in get_all_importable_module_names()]
-            bash_candidates = [Candidate(name='!'+name) for name in rp.r._get_sys_commands_cache]
-            return python_candidates + bash_candidates
+            return [Candidate(name=name) for name in get_all_importable_module_names()]
 
         # First Word Completions - should be super fast, much faster than Jedi
         if not text: