rp 0.1.1348__tar.gz → 0.1.1350__tar.gz

{rp-0.1.1348 → rp-0.1.1350}/PKG-INFO

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

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/keys.py

@@ -67,6 +67,11 @@ class Keys(object):
     ShiftDown   = Key('<ShiftDown>')
     ShiftRight  = Key('<ShiftRight>')
 
+    AltShiftUp    = Key('<AltShiftUp>')
+    AltShiftDown  = Key('<AltShiftDown>')
+    AltShiftLeft  = Key('<AltShiftLeft>')
+    AltShiftRight = Key('<AltShiftRight>')
+
     Home        = Key('<Home>')
     End         = Key('<End>')
     Delete      = Key('<Delete>')

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/layout/lexers.py

@@ -244,7 +244,7 @@ class LazyBashLexer(LazyLexer):
         import re
         import rp
         Name = shell.Name
-        commands = rp.get_system_commands() + ['!']
+        commands = rp.get_system_commands(use_cache=True) + ['!']
         shell.BashLexer.tokens['basic'] += [(r'(^|!|\b)(' + '|'.join(re.escape(x) for x in commands) + r')(?=[\s)\`]|$)', Name.Function),]
 
 

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/layout/processors.py

@@ -21,9 +21,11 @@ from rp.prompt_toolkit.token import Token
 
 from .utils import token_list_len, explode_tokens
 
-import re
 import keyword
 
+# Only import when async analyzers are needed (avoid circular imports)
+# from rp.rp_ptpython.async_analyzer_base import AsyncAnalyzerBase, build_line_map_difflib
+
 __all__ = (
     'Processor',
     'Transformation',
@@ -44,6 +46,7 @@ __all__ = (
     'ShowWhitespaceProcessor',
     'HighlightWordOccurrencesProcessor',
     'HighlightInjectedLanguageProcessor',
+    'SyntaxErrorProcessor',
 )
 
 
@@ -966,3 +969,290 @@ class HighlightInjectedLanguageProcessor(Processor):
     def apply_transformation(self, cli, document, lineno, source_to_display, tokens):
         """No transformation needed - lexer handles it."""
         return Transformation(tokens)
+
+from rp.rp_ptpython.async_analyzer_base import AsyncAnalyzerBase, build_line_map_difflib
+
+
+class AsyncRuffChecker(AsyncAnalyzerBase):
+    """
+    Background ruff checker using AsyncAnalyzerBase.
+    Runs ruff in background thread (debounced to 0.1s) to avoid blocking UI.
+    """
+    def __init__(self, redraw_callback=None):
+        super().__init__(debounce_interval=0.1, redraw_callback=redraw_callback)
+
+        # Import subprocess tools
+        import json
+        import subprocess
+        import tempfile
+        from pathlib import Path
+        self.json = json
+        self.subprocess = subprocess
+        self.tempfile = tempfile
+        self.Path = Path
+
+    def _empty_results(self):
+        return {}
+
+    def _translate_results(self, old_code, new_code, old_diags):
+        """Translate diagnostic line numbers using difflib."""
+        if not old_code or not old_diags:
+            return {}
+
+        line_map = build_line_map_difflib(old_code, new_code)
+
+        # Translate diagnostics to new line numbers
+        new_diags = {}
+        for old_line, issues in old_diags.items():
+            if old_line in line_map:
+                new_line, _ = line_map[old_line]
+                new_diags[new_line] = issues
+
+        return new_diags
+
+    def _analyze(self, text, known_names):
+        """Run ruff subprocess in background, filtering out F821 for known REPL variables."""
+        # Write to temp file (no injection needed!)
+        with self.tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write(text)
+            temp_path = f.name
+
+        try:
+            # Use temp dir for cache - faster (local storage) and avoids littering .ruff_cache everywhere
+            import os
+            import rp.r as r
+            cache_dir = r._ruff_cache_dir
+            os.makedirs(cache_dir, exist_ok=True)
+
+            result = self.subprocess.run(
+                ['ruff', 'check', '--output-format=json', '--cache-dir', cache_dir, temp_path],
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+
+            diagnostics = self.json.loads(result.stdout) if result.stdout else []
+
+            lines_with_issues = {}
+            for diag in diagnostics:
+                line_num = diag['location']['row']
+
+                # Filter out F821 (undefined name) for variables we know are in REPL scope
+                if diag['code'] == 'F821' and known_names:
+                    # Extract variable name from message like "Undefined name `asdf`"
+                    import re
+                    match = re.search(r'Undefined name `([^`]+)`', diag['message'])
+                    if match and match.group(1) in known_names:
+                        continue  # Skip this warning - variable is defined in REPL
+
+                col = diag['location']['column']
+                end_col = diag.get('end_location', {}).get('column', col + 1)
+                # Only E9XX codes are syntax errors (red); E1XX-E8XX are style violations (yellow)
+                is_error = diag['code'] == 'invalid-syntax' or (diag['code'].startswith('E9') and len(diag['code']) >= 3)
+
+                if line_num not in lines_with_issues:
+                    lines_with_issues[line_num] = []
+
+                lines_with_issues[line_num].append({
+                    'col': col,
+                    'end_col': end_col,
+                    'message': diag['message'],
+                    'code': diag['code'],
+                    'is_error': is_error
+                })
+
+            return lines_with_issues
+        except:
+            return {}
+        finally:
+            try:
+                self.Path(temp_path).unlink()
+            except:
+                pass
+
+    def get_diagnostics(self, text, known_names=None):
+        """Get diagnostics, using cache with difflib translation."""
+        known_names = known_names or set()
+        return self.get_results(text, known_names)
+
+
+class AsyncShellcheckChecker(AsyncAnalyzerBase):
+    """
+    Background shellcheck checker using AsyncAnalyzerBase.
+    Runs shellcheck in background thread (debounced to 0.1s) to avoid blocking UI.
+    """
+    def __init__(self, redraw_callback=None):
+        super().__init__(debounce_interval=0.1, redraw_callback=redraw_callback)
+
+        # Import subprocess tools
+        import json
+        import subprocess
+        import tempfile
+        from pathlib import Path
+        self.json = json
+        self.subprocess = subprocess
+        self.tempfile = tempfile
+        self.Path = Path
+
+    def _empty_results(self):
+        return {}
+
+    def _translate_results(self, old_code, new_code, old_diags):
+        """Translate diagnostic line numbers using difflib."""
+        if not old_code or not old_diags:
+            return {}
+
+        line_map = build_line_map_difflib(old_code, new_code)
+
+        # Translate diagnostics to new line numbers
+        new_diags = {}
+        for old_line, issues in old_diags.items():
+            if old_line in line_map:
+                new_line, _ = line_map[old_line]
+                new_diags[new_line] = issues
+
+        return new_diags
+
+    def _analyze(self, text, known_names):
+        """Run shellcheck subprocess in background."""
+        # Strip first ! character if present
+        if text.startswith('!'):
+            bash_text = text[1:]
+            offset = 1
+        else:
+            bash_text = text
+            offset = 0
+
+        # Write to temp file
+        with self.tempfile.NamedTemporaryFile(mode='w', suffix='.sh', delete=False) as f:
+            f.write(bash_text)
+            temp_path = f.name
+
+        try:
+            result = self.subprocess.run(
+                ['shellcheck', '--format=json', temp_path],
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+
+            diagnostics = self.json.loads(result.stdout) if result.stdout else []
+
+            lines_with_issues = {}
+            for diag in diagnostics:
+                line_num = diag['line']
+                col = diag['column']
+                end_col = diag.get('endColumn', col + 1)
+                level = diag['level']  # error, warning, info, style
+                is_error = level == 'error'
+
+                # Adjust column positions for first line to account for stripped !
+                if line_num == 1 and offset > 0:
+                    col += offset
+                    end_col += offset
+
+                if line_num not in lines_with_issues:
+                    lines_with_issues[line_num] = []
+
+                lines_with_issues[line_num].append({
+                    'col': col,
+                    'end_col': end_col,
+                    'message': diag['message'],
+                    'code':"SC{0}".format(diag['code']),
+                    'is_error': is_error
+                })
+
+            return lines_with_issues
+        except:
+            return {}
+        finally:
+            try:
+                self.Path(temp_path).unlink()
+            except:
+                pass
+
+    def get_diagnostics(self, text, known_names=None):
+        """Get diagnostics, using cache with difflib translation."""
+        return self.get_results(text, known_names or set())
+
+
+class SyntaxErrorProcessor(Processor):
+    """
+    Processor that highlights syntax errors and warnings using ruff or shellcheck.
+
+    Applies Token.SyntaxError (with red undercurl) to syntax errors and
+    Token.SyntaxWarning (with yellow undercurl) to warnings like unused imports.
+
+    Uses AsyncRuffChecker for Python code and AsyncShellcheckChecker for bash code (shell mode).
+    Shell mode is detected when text starts with '!'.
+    REPL-aware: injects known variables before linting to avoid false positives.
+    """
+
+    def __init__(self, python_input=None):
+        self.python_input = python_input
+        self._last_refresh_text = None
+
+    def apply_transformation(self, cli, document, lineno, source_to_display, tokens):
+        # Trigger refresh once per render pass (not per line)
+        if self.python_input and document.text != self._last_refresh_text:
+            self._last_refresh_text = document.text
+            self.python_input.refresh_analysis(document.text)
+
+        # Detect shell mode
+        is_shell_mode = document.text.startswith('!')
+
+        # Get the appropriate checker based on mode
+        if is_shell_mode:
+            checker = self.python_input._shellcheck_checker if self.python_input else None
+        else:
+            checker = self.python_input._ruff_checker if self.python_input else None
+
+        if not checker:
+            return Transformation(tokens)
+
+        # Set redraw callback once
+        if not checker.redraw_callback:
+            checker.redraw_callback = lambda: cli.request_redraw()
+
+        # Get current diagnostics
+        with checker.lock:
+            diagnostics = checker.cached_results
+
+        line_issues = diagnostics.get(lineno + 1, [])
+
+        if not line_issues:
+            # No issues on this line
+            return Transformation(tokens)
+
+        # Explode tokens into individual characters so we can apply styles per-character
+        tokens = explode_tokens(tokens)
+
+        # Apply error/warning undercurls to affected characters
+        for i, (token, char) in enumerate(tokens):
+            col = i + 1  # Column is 1-indexed
+
+            # Check if this character position has any issues
+            overlapping_issues = [
+                issue for issue in line_issues
+                if issue['col'] <= col < issue['end_col']
+            ]
+
+            if overlapping_issues:
+                # Determine the most severe issue (error > warning > unused variable/import)
+                is_error = any(issue['is_error'] for issue in overlapping_issues)
+                is_unused_var = any(issue['code'] == 'F841' for issue in overlapping_issues)
+                is_unused_import = any(issue['code'] == 'F401' for issue in overlapping_issues)
+
+                if is_error:
+                    error_token = Token.SyntaxError
+                elif is_unused_var:
+                    error_token = Token.SyntaxWarning.UnusedVariable
+                elif is_unused_import:
+                    error_token = Token.SyntaxWarning.UnusedImport
+                else:
+                    error_token = Token.SyntaxWarning
+
+                # Combine original token with error token using ':' separator to preserve both styles
+                tokens[i] = (token + (':', ) + error_token, char)
+
+        return Transformation(tokens)

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/styles/base.py

@@ -17,7 +17,7 @@ __all__ = (
 
 
 #: Style attributes.
-Attrs = namedtuple('Attrs', 'color bgcolor bold underline italic blink reverse color_alpha bgcolor_alpha')
+Attrs = namedtuple('Attrs', 'color bgcolor bold underline italic blink reverse color_alpha bgcolor_alpha undercurl underline_color faded fastblink hide strike overlined underdouble underdots underdash')
 """
 :param color: Hexadecimal string. E.g. '000000' or Ansi color name: e.g. 'ansiblue'
 :param bgcolor: Hexadecimal string. E.g. 'ffffff' or Ansi color name: e.g. 'ansired'
@@ -28,15 +28,29 @@ Attrs = namedtuple('Attrs', 'color bgcolor bold underline italic blink reverse c
 :param reverse: Boolean
 :param color_alpha: Float 0.0-1.0 for foreground color alpha (1.0 = opaque)
 :param bgcolor_alpha: Float 0.0-1.0 for background color alpha (1.0 = opaque)
+:param undercurl: Boolean - use curly underline instead of straight
+:param underline_color: Hexadecimal string or ANSI color name for underline color (independent of text color)
+:param faded: Boolean - dim/faint text (SGR 2)
+:param fastblink: Boolean - rapid blink (SGR 6)
+:param hide: Boolean - conceal/hide text (SGR 8)
+:param strike: Boolean - strikethrough (SGR 9)
+:param overlined: Boolean - overline (SGR 53)
+:param underdouble: Boolean - double underline (SGR 4:2)
+:param underdots: Boolean - dotted underline (SGR 4:4)
+:param underdash: Boolean - dashed underline (SGR 4:5)
 """
 
 #: The default `Attrs`.
 DEFAULT_ATTRS = Attrs(color=None, bgcolor=None, bold=False, underline=False,
-                      italic=False, blink=False, reverse=False, color_alpha=1.0, bgcolor_alpha=1.0)
+                      italic=False, blink=False, reverse=False, color_alpha=1.0, bgcolor_alpha=1.0,
+                      undercurl=False, underline_color=None, faded=False, fastblink=False,
+                      hide=False, strike=False, overlined=False, underdouble=False, underdots=False, underdash=False)
 
 #: An `Attrs` with all attributes set to None (for style parsing)
 NONE_ATTRS = Attrs(color=None, bgcolor=None, bold=None, underline=None,
-                   italic=None, blink=None, reverse=None, color_alpha=1.0, bgcolor_alpha=1.0)
+                   italic=None, blink=None, reverse=None, color_alpha=1.0, bgcolor_alpha=1.0,
+                   undercurl=None, underline_color=None, faded=None, fastblink=None,
+                   hide=None, strike=None, overlined=None, underdouble=None, underdots=None, underdash=None)
 
 
 #: ``Attrs.bgcolor/fgcolor`` can be in either 'ffffff' format, or can be any of

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/styles/defaults.py

@@ -97,6 +97,12 @@ DEFAULT_STYLE_EXTENSIONS = {
     # Language injection regions (e.g., """#!bash ... """)
     Token.InjectedLanguage:                       'noinherit bg:#0d2b0d',
 
+    # Syntax errors and warnings (with undercurl)
+    Token.SyntaxError:                            'undercurl underline_color:#ff0000',
+    Token.SyntaxWarning:                          'undercurl underline_color:#ffff00',
+    Token.SyntaxWarning.UnusedVariable:           'faded undercurl underline_color:#ffff00',
+    Token.SyntaxWarning.UnusedImport:             'faded undercurl underline_color:#ffff00',
+
     # When Control-C has been pressed. Grayed.
     Token.Aborted:                                '#888888',
 

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/styles/from_dict.py

@@ -120,6 +120,44 @@ def style_from_dict(style_dict, include_defaults=True):
                 attrs = attrs._replace(reverse=True)
             elif part == 'noreverse':
                 attrs = attrs._replace(reverse=False)
+            elif part == 'undercurl':
+                attrs = attrs._replace(undercurl=True)
+            elif part == 'noundercurl':
+                attrs = attrs._replace(undercurl=False)
+
+            # Additional fansi-compatible styles
+            elif part in ('faded', 'dim'):
+                attrs = attrs._replace(faded=True)
+            elif part in ('nofaded', 'nodim'):
+                attrs = attrs._replace(faded=False)
+            elif part == 'fastblink':
+                attrs = attrs._replace(fastblink=True)
+            elif part == 'nofastblink':
+                attrs = attrs._replace(fastblink=False)
+            elif part == 'hide':
+                attrs = attrs._replace(hide=True)
+            elif part == 'nohide':
+                attrs = attrs._replace(hide=False)
+            elif part == 'strike':
+                attrs = attrs._replace(strike=True)
+            elif part == 'nostrike':
+                attrs = attrs._replace(strike=False)
+            elif part == 'overlined':
+                attrs = attrs._replace(overlined=True)
+            elif part == 'nooverlined':
+                attrs = attrs._replace(overlined=False)
+            elif part == 'underdouble':
+                attrs = attrs._replace(underdouble=True)
+            elif part == 'nounderdouble':
+                attrs = attrs._replace(underdouble=False)
+            elif part == 'underdots':
+                attrs = attrs._replace(underdots=True)
+            elif part == 'nounderdots':
+                attrs = attrs._replace(underdots=False)
+            elif part == 'underdash':
+                attrs = attrs._replace(underdash=True)
+            elif part == 'nounderdash':
+                attrs = attrs._replace(underdash=False)
 
             # Pygments properties that we ignore.
             elif part in ('roman', 'sans', 'mono'):
@@ -135,6 +173,9 @@ def style_from_dict(style_dict, include_defaults=True):
             elif part.startswith('bg:'):
                 bgcolor, bgcolor_alpha = _colorformat(part[3:])
                 attrs = attrs._replace(bgcolor=bgcolor, bgcolor_alpha=bgcolor_alpha)
+            elif part.startswith('underline_color:'):
+                ucolor, _ = _colorformat(part[16:])
+                attrs = attrs._replace(underline_color=ucolor)
             else:
                 color, color_alpha = _colorformat(part)
                 attrs = attrs._replace(color=color, color_alpha=color_alpha)

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/styles/utils.py

@@ -108,6 +108,16 @@ def merge_attrs(list_of_attrs):
             blink=attr.blink if attr.blink is not None else result.blink,
             reverse=attr.reverse if attr.reverse is not None else result.reverse,
             color_alpha=new_color_alpha,
-            bgcolor_alpha=new_bgcolor_alpha)
+            bgcolor_alpha=new_bgcolor_alpha,
+            undercurl=attr.undercurl if attr.undercurl is not None else result.undercurl,
+            underline_color=attr.underline_color if attr.underline_color is not None else result.underline_color,
+            faded=attr.faded if attr.faded is not None else result.faded,
+            fastblink=attr.fastblink if attr.fastblink is not None else result.fastblink,
+            hide=attr.hide if attr.hide is not None else result.hide,
+            strike=attr.strike if attr.strike is not None else result.strike,
+            overlined=attr.overlined if attr.overlined is not None else result.overlined,
+            underdouble=attr.underdouble if attr.underdouble is not None else result.underdouble,
+            underdots=attr.underdots if attr.underdots is not None else result.underdots,
+            underdash=attr.underdash if attr.underdash is not None else result.underdash)
 
     return result

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/terminal/vt100_input.py

@@ -189,6 +189,12 @@ ANSI_SEQUENCES = {
     '\x1b[1;3A': (Keys.Escape, Keys.Up),
     '\x1b[1;3B': (Keys.Escape, Keys.Down),
 
+    # Alt+Shift+Arrow keys
+    '\x1b[1;4A': Keys.AltShiftUp,
+    '\x1b[1;4B': Keys.AltShiftDown,
+    '\x1b[1;4C': Keys.AltShiftRight,
+    '\x1b[1;4D': Keys.AltShiftLeft,
+
     # Sequences generated by numpad 5. Not sure what it means. (It doesn't
     # appear in 'infocmp'. Just ignore.
     '\x1b[E': Keys.Ignore,  # Xterm.

{rp-0.1.1348 → rp-0.1.1350}/rp/prompt_toolkit/terminal/vt100_output.py

@@ -251,7 +251,7 @@ class _EscapeCodeCache(dict):
         self.ansi_colors_only = to_simple_filter(ansi_colors_only)
 
     def __missing__(self, attrs):
-        fgcolor, bgcolor, bold, underline, italic, blink, reverse, color_alpha, bgcolor_alpha = attrs
+        fgcolor, bgcolor, bold, underline, italic, blink, reverse, color_alpha, bgcolor_alpha, undercurl, underline_color, faded, fastblink, hide, strike, overlined, underdouble, underdots, underdash = attrs
         # Note: color_alpha and bgcolor_alpha are already blended into fgcolor/bgcolor by merge_attrs()
         parts = []
 
@@ -259,14 +259,41 @@ class _EscapeCodeCache(dict):
 
         if bold:
             parts.append('1')
+        if faded:
+            parts.append('2')
         if italic:
             parts.append('3')
         if blink:
             parts.append('5')
-        if underline:
-            parts.append('4')
+        if fastblink:
+            parts.append('6')
         if reverse:
             parts.append('7')
+        if hide:
+            parts.append('8')
+        if strike:
+            parts.append('9')
+        if overlined:
+            parts.append('53')
+
+        # Handle underline styles (mutually exclusive with priority)
+        if undercurl:
+            parts.append('4:3')  # Undercurl style
+        elif underdouble:
+            parts.append('4:2')  # Double underline
+        elif underdots:
+            parts.append('4:4')  # Dotted underline
+        elif underdash:
+            parts.append('4:5')  # Dashed underline
+        elif underline:
+            parts.append('4')    # Regular underline
+
+        # Add underline color if specified (for any underline style)
+        if underline_color is not None and (underline or undercurl or underdouble or underdots or underdash):
+            # Convert underline_color to ANSI 256 color code or RGB
+            ucolor_codes = self._color_to_underline_code(underline_color)
+            if ucolor_codes:
+                parts.extend(ucolor_codes)
 
         if parts:
             result = '\x1b[0;' + ';'.join(parts) + 'm'
@@ -341,6 +368,41 @@ class _EscapeCodeCache(dict):
 
         return map(six.text_type, result)
 
+    def _color_to_underline_code(self, color):
+        """
+        Convert a color to ANSI underline color code (58;5;X or 58;2;R;G;B).
+
+        :param color: Color as hex string or ANSI color name
+        :return: List of ANSI code parts for underline color
+        """
+        if color is None:
+            return []
+
+        # Handle ANSI color names
+        ansi_underline_colors = {
+            'ansiblack': 0, 'ansired': 1, 'ansigreen': 2, 'ansiyellow': 3,
+            'ansiblue': 4, 'ansifuchsia': 5, 'ansiturquoise': 6, 'ansilightgray': 7,
+            'ansidarkgray': 8, 'ansidarkred': 9, 'ansidarkgreen': 10, 'ansibrown': 11,
+            'ansidarkblue': 12, 'ansipurple': 13, 'ansiteal': 14, 'ansiwhite': 15,
+        }
+
+        if color in ansi_underline_colors:
+            return ['58', '5', str(ansi_underline_colors[color])]
+
+        # Handle hex RGB colors
+        try:
+            rgb = self._color_name_to_rgb(color)
+            r, g, b = rgb
+
+            # True colors
+            if self.true_color:
+                return ['58', '2', str(r), str(g), str(b)]
+            # 256 colors
+            else:
+                return ['58', '5', str(_256_colors[rgb])]
+        except (ValueError, KeyError):
+            return []
+
 
 def _get_size(fileno):
     # Thanks to fabric (fabfile.org), and