rp 0.1.1212__tar.gz → 0.1.1214__tar.gz

{rp-0.1.1212 → rp-0.1.1214}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: rp
-Version: 0.1.1212
+Version: 0.1.1214
 Summary: Ryan's Python
 Home-page: https://github.com/RyannDaGreat/Quick-Python
 Author: Ryan Burgert

{rp-0.1.1212 → rp-0.1.1214}/rp/prompt_toolkit/layout/processors.py

@@ -9,6 +9,7 @@ from __future__ import unicode_literals
 from abc import ABCMeta, abstractmethod
 from six import with_metaclass
 from six.moves import range
+import re
 
 from rp.prompt_toolkit.cache import SimpleCache
 from rp.prompt_toolkit.document import Document
@@ -21,6 +22,7 @@ from rp.prompt_toolkit.token import Token
 from .utils import token_list_len, explode_tokens
 
 import re
+import keyword
 
 __all__ = (
     'Processor',
@@ -38,6 +40,9 @@ __all__ = (
     'ShowLeadingWhiteSpaceProcessor',
     'ShowTrailingWhiteSpaceProcessor',
     'TabsProcessor',
+    'IndentGuideProcessor',
+    'ShowWhitespaceProcessor',
+    'HighlightWordOccurrencesProcessor',
 )
 
 
@@ -603,3 +608,278 @@ class ConditionalProcessor(Processor):
     def __repr__(self):
         return '%s(processor=%r, filter=%r)' % (
             self.__class__.__name__, self.processor, self.filter)
+
+
+class IndentGuideProcessor(Processor):
+    """
+    Render indent guides - vertical lines that help visualize indentation levels.
+    
+    :param tabstop: (Integer) Horizontal space taken by a tab or space indentation level.
+    :param get_char: Callable that takes a `CommandLineInterface` and returns a
+        character (text of length one) to be used for the indent guide.
+    :param propagate: (Boolean) Whether to propagate indentation to empty lines.
+    """
+    def __init__(self, tabstop=4, get_char=None, propagate=False):
+        assert isinstance(tabstop, Integer) or isinstance(tabstop, int)
+        assert get_char is None or callable(get_char)
+        
+        self.get_char = get_char or (lambda cli: '▏')  # Left-aligned vertical bar for indent guides
+        self.tabstop = tabstop
+        self.propagate = propagate
+        # Store the latest indentation guides per line number
+        self._indentation_cache = {}
+        
+    def _get_propagated_indentation(self, cli, document, lineno, line_text):
+        """
+        Determine the appropriate indentation for the current line by looking at surrounding context.
+        Uses a simplified version of the propagate_whitespace logic for empty lines.
+        """
+        # If the line is entirely whitespace, try to propagate indentation from nearby lines
+        if line_text.strip() == '':
+            # Look at lines before this one
+            before_line = lineno - 1
+            before_indent = 0
+            
+            # Look back up to 5 lines to find indentation
+            lookback_count = 0
+            while before_line >= 0 and lookback_count < 5:
+                if before_line < len(document.lines):
+                    before_text = document.lines[before_line]
+                    # Skip completely empty lines
+                    if before_text.strip():
+                        # Count leading spaces
+                        before_indent = len(before_text) - len(before_text.lstrip())
+                        break
+                before_line -= 1
+                lookback_count += 1
+                
+            # Look at lines after this one
+            after_line = lineno + 1
+            after_indent = 0
+            
+            # Look forward up to 5 lines to find indentation
+            lookforward_count = 0
+            while after_line < len(document.lines) and lookforward_count < 5:
+                if after_line < len(document.lines):
+                    after_text = document.lines[after_line]
+                    # Skip completely empty lines
+                    if after_text.strip():
+                        # Count leading spaces
+                        after_indent = len(after_text) - len(after_text.lstrip())
+                        break
+                after_line += 1
+                lookforward_count += 1
+            
+            # Use the minimum indentation level found to be conservative
+            if before_indent > 0 and after_indent > 0:
+                return min(before_indent, after_indent)
+            elif before_indent > 0:
+                return before_indent
+            elif after_indent > 0:
+                return after_indent
+            
+        # For non-empty lines, just count the spaces
+        indent_level = 0
+        for char in line_text:
+            if char == ' ':
+                indent_level += 1
+            elif char == '\t':
+                # For tabs, increment by tabstop
+                indent_level = (indent_level // self.tabstop + 1) * self.tabstop
+            else:
+                break
+                
+        return indent_level
+        
+    def apply_transformation(self, cli, document, lineno, source_to_display, tokens):
+        if not tokens:
+            return Transformation(tokens)
+            
+        # Get line text
+        line_text = token_list_to_text(tokens)
+        
+        # Determine indentation level based on mode
+        if self.propagate and line_text.strip() == '':
+            # In Propagate mode, use context for empty lines
+            indent_level = self._get_propagated_indentation(cli, document, lineno, line_text)
+        else:
+            # In Regular mode, just use the actual indentation of the line
+            indent_level = 0
+            for char in line_text:
+                if char == ' ':
+                    indent_level += 1
+                elif char == '\t':
+                    # For tabs, increment by tabstop
+                    indent_level = (indent_level // self.tabstop + 1) * self.tabstop
+                else:
+                    break
+        
+        # If we have no indentation at all, no guides to add
+        if indent_level == 0:
+            return Transformation(tokens)
+            
+        # Explode tokens to be able to modify individual characters
+        tokens = explode_tokens(tokens)
+        
+        # Character to use for indent guides
+        guide_char = self.get_char(cli)
+        
+        # For each indentation level that's a multiple of tabstop (e.g., 4, 8, 12, etc.)
+        # Add an indent guide character, but skip the first column (position 0)
+        for i in range(self.tabstop, indent_level, self.tabstop):
+            if self.propagate and line_text.strip() == '':
+                # For empty lines in Propagate mode
+                # Make sure we have enough tokens for this indentation level
+                while i >= len(tokens):
+                    tokens.append((Token, ' '))
+                # Replace with indent guide
+                tokens[i] = (Token.IndentGuide, guide_char)
+            elif i < len(tokens) and tokens[i][1].isspace():
+                # For non-empty lines or Regular mode, only replace existing whitespace
+                tokens[i] = (Token.IndentGuide, guide_char)
+        
+        return Transformation(tokens)
+
+
+class HighlightWordOccurrencesProcessor(Processor):
+    """
+    Processor that highlights all occurrences of the word under the cursor.
+    
+    :param get_word_at_cursor: A callable that takes a document and returns the word
+                              at the current cursor position as a string.
+    :param min_word_length: Minimum length of the word before highlighting is triggered.
+    """
+    def __init__(self, get_word_at_cursor=None, min_word_length=3, ignore_case=False, skip_keywords=True):
+        self.get_word_at_cursor = get_word_at_cursor or self._default_get_word_at_cursor
+        self.min_word_length = min_word_length
+        self.ignore_case = ignore_case
+        self.skip_keywords = skip_keywords
+        self._positions_cache = SimpleCache(maxsize=8)
+        
+    def _default_get_word_at_cursor(self, document):
+        """
+        Default implementation to get the word at the cursor position.
+        Extracts the word using alphanumeric characters and underscore only.
+        """
+        if document.is_cursor_at_the_end_of_line:
+            # When cursor is at the end of line, check the word before the cursor
+            word, _ = document.find_boundaries_of_current_word(WORD=False, include_trailing_whitespace=False)
+            text = document.text_before_cursor[word:]
+        else:
+            # Get the word under cursor
+            text = document.get_word_under_cursor(WORD=False)
+            
+        # Only allow alphanumeric characters and underscores
+        import re
+        match = re.search(r'[a-zA-Z0-9_]+', text)
+        if match:
+            return match.group(0)
+        return ''
+    
+    def _get_positions_to_highlight(self, document):
+        """
+        Return a list of (row, col) tuples for all occurrences of the word under cursor.
+        """
+        word = self.get_word_at_cursor(document)
+        
+        # Skip short words, empty strings, and Python keywords
+        if not word or len(word) < self.min_word_length:
+            return []
+            
+        # Skip Python keywords if option is enabled
+        if self.skip_keywords and word in keyword.kwlist:
+            return []
+        
+        positions = []
+        
+        # Use regular expression to find all occurrences
+        # Match only when surrounded by word boundaries or non-alphanumeric characters
+        # This ensures we only match complete words
+        pattern = r'(?<!\w)' + re.escape(word) + r'(?!\w)'
+        flags = re.IGNORECASE if self.ignore_case else 0
+        
+        for lineno, line in enumerate(document.lines):
+            for match in re.finditer(pattern, line, flags=flags):
+                # Store positions with their length for highlighting
+                positions.append((lineno, match.start(), len(word)))
+        
+        return positions
+    
+    def apply_transformation(self, cli, document, lineno, source_to_display, tokens):
+        if not tokens:
+            return Transformation(tokens)
+            
+        # Use caching for performance
+        key = (cli.render_counter, document.text, document.cursor_position)
+        positions = self._positions_cache.get(
+            key, lambda: self._get_positions_to_highlight(document))
+        
+        # Skip highlighting if there's only one occurrence
+        if len(positions) <= 1:
+            return Transformation(tokens)
+            
+        # Apply highlighting for this line
+        tokens = explode_tokens(tokens)
+            
+        for row, col, length in positions:
+            if row == lineno:
+                # Transform column position
+                display_col = source_to_display(col)
+                
+                # Highlight each character of the word
+                for i in range(length):
+                    idx = display_col + i
+                    if 0 <= idx < len(tokens):  # Added bounds check for safety
+                        old_token, text = tokens[idx]
+                        # Preserve the existing token, just add WordOccurrences
+                        tokens[idx] = (old_token + (':', ) + Token.WordOccurrences, text)
+        
+        return Transformation(tokens)
+
+
+class ShowWhitespaceProcessor(Processor):
+    """
+    Render whitespace characters visible - spaces appear as middle dots and tabs as arrows.
+    
+    :param get_space_char: Callable that takes a `CommandLineInterface` and returns a
+        character (text of length one) to be used for spaces.
+    :param get_tab_char: Callable that takes a `CommandLineInterface` and returns a
+        character (text of length one) to be used for tabs.
+    :param token: Token to be used for whitespace characters.
+    """
+    def __init__(self, get_space_char=None, get_tab_char=None, token=None):
+        assert get_space_char is None or callable(get_space_char)
+        assert get_tab_char is None or callable(get_tab_char)
+        
+        self.get_space_char = get_space_char or (lambda cli: '·')  # Middle dot for spaces
+        self.get_tab_char = get_tab_char or (lambda cli: '→')      # Right arrow for tabs
+        self.token = token or Token.Whitespace
+        
+    def apply_transformation(self, cli, document, lineno, source_to_display, tokens):
+        if not tokens:
+            return Transformation(tokens)
+        
+        # Explode tokens to be able to modify individual characters
+        tokens = explode_tokens(tokens)
+        
+        # Get characters to use for whitespace
+        space_char = self.get_space_char(cli)
+        tab_char = self.get_tab_char(cli)
+        
+        # Walk through all tokens and replace whitespace with visible characters
+        for i in range(len(tokens)):
+            token, text = tokens[i]
+            
+            # Skip tokens that are already special (like indent guides)
+            if Token.IndentGuide in token:
+                continue
+                
+            # Replace spaces with visible spaces
+            if text == ' ':
+                tokens[i] = (Token.Whitespace.Space, space_char)
+            
+            # Replace tabs with visible tabs
+            elif text == '\t':
+                tokens[i] = (Token.Whitespace.Tab, tab_char)
+        
+        return Transformation(tokens)

{rp-0.1.1212 → rp-0.1.1214}/rp/prompt_toolkit/styles/defaults.py

@@ -17,18 +17,24 @@ DEFAULT_STYLE_EXTENSIONS = {
     # Highlighting of search matches in document.
     Token.SearchMatch:                            'noinherit reverse',
     Token.SearchMatch.Current:                    'noinherit #ffffff bg:#448844 underline',
+    
+    # Indent guides
+    Token.IndentGuide:                            '#303030',
+    
+    # Whitespace visualization
+    Token.Whitespace:                             '#303030',
 
     # Highlighting of select text in document.
     Token.SelectedText:                           'reverse',
 
     Token.CursorColumn:                           'bg:#dddddd',
-    Token.CursorLine:                             'underline',
+    Token.CursorLine:                             'bg:#2a3438',
     Token.ColorColumn:                            'bg:#ccaacc',
 
-    # Highlighting of matching brackets.
-    Token.MatchingBracket:                        '',
-    Token.MatchingBracket.Other:                  '#000000 bg:#aacccc',
-    Token.MatchingBracket.Cursor:                 '#ff8888 bg:#880000',
+    # Highlighting of matching brackets - must be very vivid to show on top of cursor line
+    Token.MatchingBracket:                        'bold',
+    Token.MatchingBracket.Other:                  '#ffffff bg:#3333ff bold',
+    Token.MatchingBracket.Cursor:                 '#ffffff bg:#ff3333 bold',
 
     Token.MultipleCursors.Cursor:                 '#000000 bg:#ccccaa',
 
@@ -84,6 +90,9 @@ DEFAULT_STYLE_EXTENSIONS = {
     # Trailing whitespace and tabs.
     Token.TrailingWhiteSpace:                     '#999999',
     Token.Tab:                                    '#999999',
+    Token.Whitespace.Space:                       '#252525',  
+    Token.Whitespace.Tab:                         '#252525',
+    Token.WordOccurrences:                        'underline',
 
     # When Control-C has been pressed. Grayed.
     Token.Aborted:                                '#888888',

{rp-0.1.1212 → rp-0.1.1214}/rp/r.py

@@ -16763,6 +16763,10 @@ _default_pyin_settings=dict(
     min_bot_space=15,
     top_space=0,
     true_color=False,
+    indent_guides_mode='Regular',
+    highlight_cursor_line=False  ,# Highlight the background of the cursor line
+    highlight_matching_words=True  ,# Underline all occurrences of the word under cursor
+    show_whitespace=True,
 
     session_title='',
 )
@@ -32372,7 +32376,7 @@ def copy_directory(from_path, to_path, *, extract=False, follow_symlinks=False):
 
     import shutil
     #Do the actual copying - extract into to_path
-    shutil.copytree(from_path, to_path, symlinks=follow_symlinks)
+    shutil.copytree(from_path, to_path, symlinks=follow_symlinks, dirs_exist_ok=True)
 
     return to_path
 

{rp-0.1.1212 → rp-0.1.1214}/rp/rp_ptpython/filters.py

@@ -6,6 +6,7 @@ __all__ = (
     'HasSignature',
     'ShowSidebar',
     'ShowDocstring',
+    'ShouldHighlightCursorLine',
 )
 
 

{rp-0.1.1212 → rp-0.1.1214}/rp/rp_ptpython/layout.py

@@ -12,12 +12,18 @@ from rp.prompt_toolkit.layout.dimension import LayoutDimension
 from rp.prompt_toolkit.layout.lexers import SimpleLexer
 from rp.prompt_toolkit.layout.margins import PromptMargin
 from rp.prompt_toolkit.layout.menus import CompletionsMenu, MultiColumnCompletionsMenu
-from rp.prompt_toolkit.layout.processors import ConditionalProcessor, AppendAutoSuggestion, HighlightSearchProcessor, HighlightSelectionProcessor, HighlightMatchingBracketProcessor, Processor, Transformation
+from rp.prompt_toolkit.layout.processors import (
+    ConditionalProcessor, AppendAutoSuggestion, HighlightSearchProcessor, 
+    HighlightSelectionProcessor, HighlightMatchingBracketProcessor, 
+    Processor, Transformation, IndentGuideProcessor, ShowWhitespaceProcessor,
+    HighlightWordOccurrencesProcessor
+)
 from rp.prompt_toolkit.layout.screen import Char
 from rp.prompt_toolkit.layout.toolbars import CompletionsToolbar, ArgToolbar, SearchToolbar, ValidationToolbar, SystemToolbar, TokenListToolbar
 from rp.prompt_toolkit.layout.utils import token_list_width
 from rp.prompt_toolkit.reactive import Integer
 from rp.prompt_toolkit.selection import SelectionType
+from rp.prompt_toolkit.token import Token
 from rp.prompt_toolkit.document import Document
 from rp.prompt_toolkit.selection import SelectionState
 
@@ -634,20 +640,40 @@ def create_layout(python_input,
                 buffer_name=DEFAULT_BUFFER,
                 lexer=lexer,
                 input_processors=[
+                    # Order matters here! We want to ensure brackets are highlighted properly
+                    # First highlight selections 
+                    HighlightSelectionProcessor(),
+                    DisplayMultipleCursors(DEFAULT_BUFFER),
+                    # Then highlight search results
                     ConditionalProcessor(
                         processor=HighlightSearchProcessor(preview_search=True),
                         filter=HasFocus(SEARCH_BUFFER),
                     ),
-                    HighlightSelectionProcessor(),
-                    DisplayMultipleCursors(DEFAULT_BUFFER),
-                    # Show matching parentheses, but only while editing.
+                    # Then highlight matching brackets - this is critical
                     ConditionalProcessor(
                         processor=HighlightMatchingBracketProcessor(chars='[](){}'),
                         filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
                             Condition(lambda cli: python_input.highlight_matching_parenthesis)),
+                    # Other processors can come after
                     ConditionalProcessor(
                         processor=AppendAutoSuggestion(),
-                        filter=~IsDone())
+                        filter=~IsDone()),
+                    ConditionalProcessor(
+                        processor=IndentGuideProcessor(tabstop=4, propagate=False),
+                        filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
+                            Condition(lambda cli: python_input.indent_guides_mode == 'Regular')),
+                    ConditionalProcessor(
+                        processor=IndentGuideProcessor(tabstop=4, propagate=True),
+                        filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
+                            Condition(lambda cli: python_input.indent_guides_mode == 'Propagate')),
+                    ConditionalProcessor(
+                        processor=ShowWhitespaceProcessor(token=Token.Whitespace),
+                        filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
+                            Condition(lambda cli: python_input.show_whitespace)),
+                    ConditionalProcessor(
+                        processor=HighlightWordOccurrencesProcessor(min_word_length=1, skip_keywords=True),
+                        filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
+                            Condition(lambda cli: python_input.highlight_matching_words))
                 ] + extra_buffer_processors,
                 menu_position=menu_position,
 
@@ -658,6 +684,11 @@ def create_layout(python_input,
             # Scroll offsets. The 1 at the bottom is important to make sure the
             # cursor is never below the "Press [Meta+Enter]" message which is a float.
             scroll_offsets=ScrollOffsets(bottom=1, left=4, right=4),
+            # Highlight cursor line - brackets will be drawn on top of this
+            cursorline=Condition(lambda cli: (python_input.highlight_cursor_line and 
+                                          len(cli.buffers[DEFAULT_BUFFER].document.lines) > 1 and 
+                                          HasFocus(DEFAULT_BUFFER)(cli))),
+            cursorline_token=Token.CursorLine,
             # As long as we're editing, prefer a minimal height of 6.
             get_height=(lambda cli: (
                 None if cli.is_done or python_input.show_exit_confirmation

{rp-0.1.1212 → rp-0.1.1214}/rp/rp_ptpython/python_input.py

@@ -198,6 +198,10 @@ class PythonInput(object):
         self.enable_input_validation=True
         self.enable_auto_suggest=False
         self.enable_mouse_support=False
+        self.indent_guides_mode='Propagate'  # 'Off', 'Regular', or 'Propagate'
+        self.show_whitespace=False  # Show spaces as middle dots and tabs as arrows
+        self.highlight_cursor_line=False  # Highlight the background of the cursor line
+        self.highlight_matching_words=True  # Underline all occurrences of the word under cursor
         self.enable_history_search=False  # When True, like readline, going
         # back in history will filter the
         # history on the records starting
@@ -508,7 +512,24 @@ class PythonInput(object):
                 simple_option(title='Wrap lines',
                               description='Wrap lines instead of scrolling horizontally.',
                               field_name='wrap_lines'),
-                                simple_option(title='History Highlighting',
+                Option(title='Indent guides',
+                       description='Display vertical indent guides. "Regular" shows guides only for existing indentation. "Propagate" also shows guides on empty lines between indented blocks.',
+                       get_current_value=lambda:self.indent_guides_mode,
+                       get_values=lambda:{
+                           'Off': lambda:setattr(self, 'indent_guides_mode', 'Off'),
+                           'Regular': lambda:setattr(self, 'indent_guides_mode', 'Regular'),
+                           'Propagate': lambda:setattr(self, 'indent_guides_mode', 'Propagate'),
+                       }),
+                simple_option(title='Show whitespace',
+                       description='Display spaces as middle dots (·) and tabs as arrows (→).',
+                       field_name='show_whitespace'),
+                simple_option(title='Highlight cursor line',
+                       description='Highlight the background of the line with the cursor.',
+                       field_name='highlight_cursor_line'),
+                simple_option(title='Highlight matching words',
+                       description='Underline all occurrences of the word under the cursor.',
+                       field_name='highlight_matching_words'),
+                simple_option(title='History Highlighting',
                               description='When using F3 (aka History Broswer) to select entries from history,  '
                                           'should we use syntax highlighting? Its pretty, but slow.',
                               field_name='history_syntax_highlighting'),