pyqt-code-editor 0.0.14__tar.gz → 0.0.16__tar.gz

{pyqt_code_editor-0.0.14 → pyqt_code_editor-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.14
+Version: 0.0.16
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>

{pyqt_code_editor-0.0.14 → pyqt_code_editor-0.0.16}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.14'
+__version__ = '0.0.16'

{pyqt_code_editor-0.0.14 → pyqt_code_editor-0.0.16}/pyqt_code_editor/app.py

@@ -339,6 +339,7 @@ class MainWindow(QMainWindow):
             self._jupyter_console.change_directory(
                 os.path.dirname(editor.code_editor_file_path)
             )
+        self._toggle_dock_widget(self._jupyter_console, show=True)
         self._jupyter_console.execute_code(code)
 
     def _execute_file(self, path):

{pyqt_code_editor-0.0.14 → pyqt_code_editor-0.0.16}/pyqt_code_editor/mixins/complete.py

@@ -354,10 +354,40 @@ class Complete:
                 left_overlap_size = i
                 break
         # Captures special case of exactly 1 character of left overlap, which
-        # can reflect words with double letters, such as Hel + lo = Hello,
-        # and not Helo.
+        # can reflect words with double letters, but it doesn't need to. To
+        # decide whether the overlap needs to be removed we check whether the
+        # stripped version exists in the text. If so, we use that, if not,
+        # we assume that the doubling is intended.
+        #
+        # def aabb(): pass
+        # a| completion is 'abb' overlap = 0
+        #
+        # def abb(): pass
+        # a| completion is 'abb' overlap = 1        
         if left_overlap_size == 1:
-            left_overlap_size = 0
+            # Get the index of the last character in before_text that is
+            # alphanumeric or underscore
+            last_symbol_index = -1
+            while -last_symbol_index <= len(before_text) and \
+                    (before_text[last_symbol_index].isalnum() or
+                     before_text[last_symbol_index] == '_'):
+                last_symbol_index -= 1
+            last_symbol_index += 1
+            symbol_before = before_text[last_symbol_index:]
+            # Get the index of the first character in completion that is
+            # alphanumeric or underscore
+            last_symbol_index = 0
+            while last_symbol_index < len(completion) and \
+                    (completion[last_symbol_index].isalnum() or
+                     completion[last_symbol_index] == '_'):
+                last_symbol_index += 1
+            symbol_after = completion[:last_symbol_index]
+            symbol = symbol_before + symbol_after
+            if symbol in doc_text:
+                left_overlap_size = 0
+                logger.info(f'{symbol} exists in text, keeping overlap')                
+            else:
+                logger.info(f'{symbol} does not exists in text, stripping overlap')                
         # Create a new completion without what's already typed
         new_completion = completion[left_overlap_size:]
 

{pyqt_code_editor-0.0.14 → pyqt_code_editor-0.0.16}/pyqt_code_editor/mixins/execute.py

@@ -1,7 +1,7 @@
 from qtpy.QtCore import Signal, Qt, QTimer
 from qtpy.QtGui import QTextCursor, QTextCharFormat, QColor, QKeySequence
 from qtpy.QtWidgets import QShortcut, QTextEdit
-from .. python_utils import extract_cells_from_code
+from ..utils.languages.python import extract_cells_from_code
 from .. import settings
 import logging
 

{pyqt_code_editor-0.0.14 → pyqt_code_editor-0.0.16}/pyqt_code_editor/mixins/python_auto_indent.py

@@ -1,5 +1,7 @@
 from qtpy.QtCore import Qt
-from .. import python_utils, settings
+from qtpy.QtGui import QTextCursor
+from .. import settings
+from ..utils.languages import python as python_utils
 import logging
 logging.basicConfig(level=logging.INFO, force=True)
 
@@ -50,7 +52,14 @@ class PythonAutoIndent:
             logging.info("Enter/Return pressed")
             cursor = self.textCursor()
             cursor.beginEditBlock()
-            code = self.toPlainText()[:cursor.position()]
+    
+            # Use QTextCursor to get text up to cursor position
+            # This handles UTF-16 encoding correctly
+            temp_cursor = self.textCursor()
+            temp_cursor.movePosition(QTextCursor.Start)
+            temp_cursor.setPosition(cursor.position(), QTextCursor.KeepAnchor)
+            code = temp_cursor.selectedText().replace('\u2029', '\n')
+    
             new_indent = python_utils.python_auto_indent(code)
             # Insert the computed indentation
             super().keyPressEvent(event)
@@ -60,7 +69,6 @@ class PythonAutoIndent:
             cursor.endEditBlock()
             self.setTextCursor(cursor)
             return
-
         # Otherwise, default behavior
         super().keyPressEvent(event)
 

pyqt_code_editor-0.0.16/pyqt_code_editor/utils/languages/python/__init__.py

@@ -0,0 +1,3 @@
+from ._auto_indent import python_auto_indent
+from ._extract_cells import extract_cells_from_code
+from ._mask_str_in_code import mask_str_in_code

pyqt_code_editor-0.0.14/pyqt_code_editor/python_utils.py → pyqt_code_editor-0.0.16/pyqt_code_editor/utils/languages/python/_auto_indent.py

@@ -1,9 +1,16 @@
-import re
-from . import settings
+from .... import settings
+from ._mask_str_in_code import mask_str_in_code
 import logging
 logging.basicConfig(level=logging.INFO, force=True)
 logger = logging.getLogger(__name__)
 
+BLOCK_KEYWORDS = (
+    "def", "class", "if", "elif", "else", "while", 
+    "for", "with", "try", "except", "finally"
+)
+OPEN_TO_CLOSE = {'(': ')', '[': ']', '{': '}'}
+CLOSE_TO_OPEN = {')': '(', ']': '[', '}': '{'}    
+
 
 def get_leading_spaces(line: str) -> int:
     """
@@ -11,8 +18,20 @@ def get_leading_spaces(line: str) -> int:
     """
     return len(line) - len(line.lstrip(' '))
 
+    
+def _is_block_opener(line: str) -> bool:
+    stripped = line.lstrip()
+    lower_stripped = stripped.lower()
+    for kw in BLOCK_KEYWORDS:
+        if lower_stripped.startswith(kw) and (
+            len(stripped) == len(kw)
+            or stripped[len(kw)] in (' ', '(', ':')
+        ):
+            return True
+    return False
+
 
-def parse_brackets(code: str):
+def parse_brackets(code: str) -> tuple[list[tuple[str, int, int]], dict]:
     """
     Parse all lines of code, ignoring quoted strings in a simple way,
     and return:
@@ -20,30 +39,20 @@ def parse_brackets(code: str):
                        each as (bracket_char, line_index, col_index).
         bracket_closings: A dict mapping close_line_idx -> (open_line_idx, open_line_indent, open_bracket).
     """
-    open_to_close = {'(': ')', '[': ']', '{': '}'}
-    close_to_open = {')': '(', ']': '[', '}': '{'}
-    
-    # A naive bracket parser that ignores strings by removing them first
-    # (this is simplistic; real logic may need to handle triple quotes, etc.)
-    def remove_strings(line: str) -> str:
-        return re.sub(r'(".*?"|\'.*?\')', '', line)
-    
+
     lines = code.split("\n")
     bracket_stack = []
     bracket_closings = {}
     
-    for i, raw_line in enumerate(lines):
-        # remove quoted strings
-        stripped_line = remove_strings(raw_line)
-        
+    for i, line in enumerate(lines):        
         j = 0
-        while j < len(stripped_line):
-            ch = stripped_line[j]
-            if ch in open_to_close:
+        while j < len(line):
+            ch = line[j]
+            if ch in OPEN_TO_CLOSE:
                 bracket_stack.append((ch, i, j))
-            elif ch in close_to_open:
+            elif ch in CLOSE_TO_OPEN:
                 # If there's something on the stack and it matches, pop it
-                if bracket_stack and bracket_stack[-1][0] == close_to_open[ch]:
+                if bracket_stack and bracket_stack[-1][0] == CLOSE_TO_OPEN[ch]:
                     open_bracket_char, open_line_idx, open_col_idx = bracket_stack.pop()
                     # record the closing bracket
                     bracket_closings[i] = (open_line_idx, get_leading_spaces(lines[open_line_idx]), open_bracket_char)
@@ -57,16 +66,15 @@ def _get_unclosed_open_idx(code : str, open_char : str,
     """Returns the index of the last unclosed unopening character, such as an
     opening parenthesis, or None if no unclosed opening character was found.
     """
-    # We only consider code from the end of the last code comment or the last
-    # quote, whatever comes last. This is a cheap way to avoid the auto indenter
-    # from being confused by parentheses in strings or comments.                 
-    last_quote = max(code.rfind("'"), code.rfind('"'))
+    # We only consider code from the end of the last code comment. This is a
+    # cheap way to avoid the auto indenter from being confused by parentheses
+    # in comments.
     last_comment = code.rfind('#')
     if last_comment >= 0:
         last_comment_end = code[last_comment:].find('\n')
         if last_comment_end >= 0:
             last_comment += last_comment_end
-    search_start = max(0, last_quote, last_comment)         
+    search_start = max(0, last_comment)
     if search_start:
         code = code[search_start:]
     n_open_required = 1    
@@ -112,7 +120,8 @@ def _line_col_from_idx(full_text, char_index):
     return (line, column)    
     
 
-def _indent_inside_unclosed_call_def_or_class(code: str, char_idx : int) -> int:
+def _indent_inside_unclosed_call_def_or_class(code: str, lines: list,
+                                              char_idx : int) -> int:
     """
     Return after opening parenthesis as part of function call should trigger indent
     
@@ -140,7 +149,14 @@ def _indent_inside_unclosed_call_def_or_class(code: str, char_idx : int) -> int:
     ```
     function(arg1,>
              |
-    ```    
+    ```
+             
+    Return after opening parenthesis and one or more arguments as part of function call should trigger matching indent to first argument, also when the argument contains default values with strings.
+    
+    ```
+    function("arg1", arg2='default', arg3=\"\"\"test\"\"\",>
+             |
+    ```
         
     Return after parenthesis and one or more arguments after function definition should trigger matching indent to first argument
     
@@ -223,10 +239,8 @@ def _indent_inside_unclosed_call_def_or_class(code: str, char_idx : int) -> int:
             |
     ```            
     """
-    lines = code.splitlines()
     if not lines:
-        return 0
-    
+        return 0    
     line_idx, col_idx = _line_col_from_idx(code, char_idx)
     # Get the line where the last unclosed parenthesis is
     open_line = lines[line_idx]
@@ -249,7 +263,7 @@ def _indent_inside_unclosed_call_def_or_class(code: str, char_idx : int) -> int:
     return len(prefix) + after_paren_offset
 
 
-def _indent_after_block_opener(code: str) -> int:
+def _indent_after_block_opener(code: str, lines: list) -> int:
     """
     Return after function definition should trigger indent
     
@@ -403,24 +417,7 @@ def _indent_after_block_opener(code: str) -> int:
         if x == y:>
             |
     ```
-    """
-    BLOCK_KEYWORDS = (
-        "def", "class", "if", "elif", "else", "while", 
-        "for", "with", "try", "except", "finally"
-    )
-    
-    def is_block_opener(line: str) -> bool:
-        stripped = line.lstrip()
-        lower_stripped = stripped.lower()
-        for kw in BLOCK_KEYWORDS:
-            if lower_stripped.startswith(kw) and (
-                len(stripped) == len(kw)
-                or stripped[len(kw)] in (' ', '(', ':')
-            ):
-                return True
-        return False
-    
-    lines = code.splitlines()
+    """    
     if not lines:
         return 0
     
@@ -433,7 +430,7 @@ def _indent_after_block_opener(code: str) -> int:
     # If it DOES end with a colon, we see if we can locate the block opener line
     block_opener_idx = len(lines) - 1
     for i in range(len(lines) - 1, -1, -1):
-        if is_block_opener(lines[i]):
+        if _is_block_opener(lines[i]):
             block_opener_idx = i
             break
     
@@ -477,6 +474,13 @@ def _indent_inside_uncloded_list_tuple_set_or_dict(code: str, char_idx: int) ->
     l = [item1,>
          |
     ```
+         
+    Return after opening of list with one or more elements should trigger matching indent to first element, also when the element is a string
+    
+    ```
+    l = ['item1',>
+         |
+    ```
     
     Return after opening of tuple with one or more elements should trigger matching indent to first element
     
@@ -733,6 +737,7 @@ def python_auto_indent(code: str) -> int:
     |
     ```
     """
+    code = mask_str_in_code(code)
     lines = code.splitlines()
     # If code ends with a newline => cursor is on a fresh line
     if code.endswith('\n'):
@@ -744,7 +749,7 @@ def python_auto_indent(code: str) -> int:
     # 1. ends with colon => block opener
     if last_line.endswith(":"):
         logging.info('indent after block opener')
-        return _indent_after_block_opener(code)
+        return _indent_after_block_opener(code, lines)
             
     # 2. unmatched '(' => function call/def or tuple
     last_paren_idx_tuple = _get_unclosed_open_idx(code, '(', ')')
@@ -758,7 +763,7 @@ def python_auto_indent(code: str) -> int:
             if preceding_char.isalnum() or preceding_char == "_":
                 logging.info("indent as unclosed call/def")
                 return _indent_inside_unclosed_call_def_or_class(
-                    code, last_paren_idx_tuple)
+                    code, lines, last_paren_idx_tuple)
             else:
                 logging.info("indent as unclosed tuple")
                 return _indent_inside_uncloded_list_tuple_set_or_dict(
@@ -796,141 +801,3 @@ def python_auto_indent(code: str) -> int:
     # 7. fallback => preserve current line indent
     logging.info('indent fallback to current line')
     return leading_spaces
-
-
-def extract_cells_from_code(code: str) -> list:
-    """Extracts cells from code. The return value is a 
-    list of cells, where each cell is a dict like so:
-
-    {
-        'description': str | None,
-        'start_pos': int,
-        'end_pos': int,
-        'code': str
-    }
-
-    A description only applies to cells that have been defined with
-    triple-quoted strings. Otherwise it is None.
-    
-    Cells can be defined by:
-    - # %%
-    - #%%
-    - # In[]:
-    - Triple-quoted strings
-    """
-    # Store all detected cells
-    cells = []
-    
-    # Define regex patterns for cell markers
-    marker_pattern = re.compile(r'^(# %%|#%%|# In\[\]:?).*?$', re.MULTILINE)
-    triple_quotes_pattern = re.compile(
-        r'(?m)^(""".*?"""|\'\'\'.*?\'\'\')',
-        re.DOTALL
-    )
-    
-    # Find all marker-based cells
-    marker_matches = list(marker_pattern.finditer(code))
-    
-    # Find all triple-quoted docstrings that are at the top level
-    # (we'll filter out non-top-level ones later)
-    docstring_matches = list(triple_quotes_pattern.finditer(code))
-    
-    # Combine all match types and sort by position
-    all_markers = []
-    
-    # Add marker matches
-    for match in marker_matches:
-        start_pos = match.start()
-        all_markers.append({
-            'type': 'marker',
-            'match': match,
-            'start_pos': start_pos
-        })
-    
-    # Add docstring matches
-    for match in docstring_matches:
-        start_pos = match.start()
-        # Only include if not inside string/comment (simplified check)
-        # We'll do more thorough validation later
-        all_markers.append({
-            'type': 'docstring',
-            'match': match,
-            'start_pos': start_pos
-        })
-    
-    # Sort all markers by position
-    all_markers.sort(key=lambda x: x['start_pos'])
-    
-    # Process each marker to create cells
-    for i, marker in enumerate(all_markers):
-        match = marker['match']
-        start_pos = marker['start_pos']
-        
-        # Determine where this cell ends (next marker or end of file)
-        if i < len(all_markers) - 1:
-            end_pos = all_markers[i + 1]['start_pos']
-        else:
-            end_pos = len(code)
-        
-        # Check if this docstring is actually a top-level triple-quoted string
-        # and not part of a function definition, string literal, etc.
-        if marker['type'] == 'docstring':
-            # Skip if not a top-level docstring (simplified check)
-            # This is a simplification; a more robust solution would check code structure
-            line_start = code.rfind('\n', 0, start_pos) + 1
-            if line_start < start_pos:
-                indent = code[line_start:start_pos].strip()
-                if indent:  # If there's text before the docstring on the same line, skip it
-                    continue
-            
-            # Extract description from the docstring
-            docstring_content = match.group(0)[3:-3].strip()
-            
-            # Extract code content (from end of docstring to end of cell)
-            docstring_end = match.end()
-            cell_code = code[docstring_end:end_pos].strip()
-            
-            cells.append({
-                'description': docstring_content,
-                'start_pos': start_pos,
-                'end_pos': end_pos,
-                'code': cell_code
-            })
-            
-        else:  # Marker-based cell
-            # Extract code content (from end of marker line to end of cell)
-            marker_line_end = code.find('\n', start_pos)
-            if marker_line_end == -1:  # If no newline is found
-                marker_line_end = len(code)
-            
-            cell_code = code[marker_line_end + 1:end_pos].strip()
-            
-            cells.append({
-                'description': None,
-                'start_pos': start_pos,
-                'end_pos': end_pos,
-                'code': cell_code
-            })
-    
-    # Handle the case where the file starts with code before any marker
-    if all_markers and all_markers[0]['start_pos'] > 0:
-        first_code = code[:all_markers[0]['start_pos']].strip()
-        if first_code:
-            cells.insert(0, {
-                'description': None,
-                'start_pos': 0,
-                'end_pos': all_markers[0]['start_pos'],
-                'code': first_code
-            })
-    
-    # Handle the case where there are no markers at all
-    if not cells and code.strip():
-        cells.append({
-            'description': None,
-            'start_pos': 0,
-            'end_pos': len(code),
-            'code': code.strip()
-        })
-    
-    return cells
-    

pyqt_code_editor-0.0.16/pyqt_code_editor/utils/languages/python/_extract_cells.py

@@ -0,0 +1,138 @@
+import re
+
+
+def extract_cells_from_code(code: str) -> list:
+    """Extracts cells from code. The return value is a 
+    list of cells, where each cell is a dict like so:
+
+    {
+        'description': str | None,
+        'start_pos': int,
+        'end_pos': int,
+        'code': str
+    }
+
+    A description only applies to cells that have been defined with
+    triple-quoted strings. Otherwise it is None.
+    
+    Cells can be defined by:
+    - # %%
+    - #%%
+    - # In[]:
+    - Triple-quoted strings
+    """
+    # Store all detected cells
+    cells = []
+    
+    # Define regex patterns for cell markers
+    marker_pattern = re.compile(r'^(# %%|#%%|# In\[\]:?).*?$', re.MULTILINE)
+    triple_quotes_pattern = re.compile(
+        r'(?m)^(""".*?"""|\'\'\'.*?\'\'\')',
+        re.DOTALL
+    )
+    
+    # Find all marker-based cells
+    marker_matches = list(marker_pattern.finditer(code))
+    
+    # Find all triple-quoted docstrings that are at the top level
+    # (we'll filter out non-top-level ones later)
+    docstring_matches = list(triple_quotes_pattern.finditer(code))
+    
+    # Combine all match types and sort by position
+    all_markers = []
+    
+    # Add marker matches
+    for match in marker_matches:
+        start_pos = match.start()
+        all_markers.append({
+            'type': 'marker',
+            'match': match,
+            'start_pos': start_pos
+        })
+    
+    # Add docstring matches
+    for match in docstring_matches:
+        start_pos = match.start()
+        # Only include if not inside string/comment (simplified check)
+        # We'll do more thorough validation later
+        all_markers.append({
+            'type': 'docstring',
+            'match': match,
+            'start_pos': start_pos
+        })
+    
+    # Sort all markers by position
+    all_markers.sort(key=lambda x: x['start_pos'])
+    
+    # Process each marker to create cells
+    for i, marker in enumerate(all_markers):
+        match = marker['match']
+        start_pos = marker['start_pos']
+        
+        # Determine where this cell ends (next marker or end of file)
+        if i < len(all_markers) - 1:
+            end_pos = all_markers[i + 1]['start_pos']
+        else:
+            end_pos = len(code)
+        
+        # Check if this docstring is actually a top-level triple-quoted string
+        # and not part of a function definition, string literal, etc.
+        if marker['type'] == 'docstring':
+            # Skip if not a top-level docstring (simplified check)
+            # This is a simplification; a more robust solution would check code structure
+            line_start = code.rfind('\n', 0, start_pos) + 1
+            if line_start < start_pos:
+                indent = code[line_start:start_pos].strip()
+                if indent:  # If there's text before the docstring on the same line, skip it
+                    continue
+            
+            # Extract description from the docstring
+            docstring_content = match.group(0)[3:-3].strip()
+            
+            # Extract code content (from end of docstring to end of cell)
+            docstring_end = match.end()
+            cell_code = code[docstring_end:end_pos].strip()
+            
+            cells.append({
+                'description': docstring_content,
+                'start_pos': start_pos,
+                'end_pos': end_pos,
+                'code': cell_code
+            })
+            
+        else:  # Marker-based cell
+            # Extract code content (from end of marker line to end of cell)
+            marker_line_end = code.find('\n', start_pos)
+            if marker_line_end == -1:  # If no newline is found
+                marker_line_end = len(code)
+            
+            cell_code = code[marker_line_end + 1:end_pos].strip()
+            
+            cells.append({
+                'description': None,
+                'start_pos': start_pos,
+                'end_pos': end_pos,
+                'code': cell_code
+            })
+    
+    # Handle the case where the file starts with code before any marker
+    if all_markers and all_markers[0]['start_pos'] > 0:
+        first_code = code[:all_markers[0]['start_pos']].strip()
+        if first_code:
+            cells.insert(0, {
+                'description': None,
+                'start_pos': 0,
+                'end_pos': all_markers[0]['start_pos'],
+                'code': first_code
+            })
+    
+    # Handle the case where there are no markers at all
+    if not cells and code.strip():
+        cells.append({
+            'description': None,
+            'start_pos': 0,
+            'end_pos': len(code),
+            'code': code.strip()
+        })
+    
+    return cells

pyqt_code_editor-0.0.16/pyqt_code_editor/utils/languages/python/_mask_str_in_code.py

@@ -0,0 +1,185 @@
+import tokenize
+import io
+import re
+
+
+def mask_str_in_code(code: str, mask_char: str = 'X') -> str:
+    """Takes Python code and masks all characters that are part of a string
+    by the mask_char.
+    
+    Examples:
+    ---------
+
+    In:
+
+    print('test')
+    
+    Out:
+    
+    print('XXXX')
+    
+    In:
+    
+    print('A string with \'quotes\'')
+    
+    Out:
+    
+    print('XXXXXXXXXXXXXXXXXXXXXXXX')
+    
+    In:
+    
+    '''A triple quoted string
+    across multiple lines
+    '''
+    
+    Out:
+    
+    '''XXXXXXXXXXXXXXXXXXXXXX
+    XXXXXXXXXXXXXXXXXXXXX
+    '''
+    """
+    # First handle f-strings separately using regex
+    # This regex matches f-strings with their content
+    fstring_pattern = r'(f)(""".*?"""|\'\'\'.*?\'\'\'|".*?"|\'.*?\')'
+    
+    def mask_fstring(match):
+        prefix = match.group(1)
+        full_string = match.group(2)
+        quote = ''
+        content = ''
+        
+        if full_string.startswith(('"""', "'''")):
+            quote = full_string[:3]
+            content = full_string[3:-3]
+        else:
+            quote = full_string[0]
+            content = full_string[1:-1]
+        
+        # Mask everything in f-string content
+        masked_content = mask_char * len(content)
+        return prefix + quote + masked_content + quote
+    
+    # Apply f-string masking
+    code = re.sub(fstring_pattern, mask_fstring, code, flags=re.DOTALL)
+    
+    # Now handle regular strings with tokenizer
+    code_bytes = code.encode('utf-8')
+    readline = io.BytesIO(code_bytes).readline
+    
+    masked_parts = []
+    last_end = (1, 0)
+    
+    try:
+        tokens = tokenize.tokenize(readline)
+        
+        for token in tokens:
+            if token.type == tokenize.STRING:
+                # Get the string content including quotes
+                string_value = token.string
+                
+                # Skip if it looks like an f-string (already handled)
+                if string_value.startswith(('f"', "f'", 'f"""', "f'''")):
+                    # Add any code between last token and this one
+                    start_line, start_col = token.start
+                    end_line, end_col = last_end
+                    
+                    if start_line > end_line or (start_line == end_line and start_col > end_col):
+                        lines = code.split('\n')
+                        if end_line == start_line:
+                            masked_parts.append(lines[end_line - 1][end_col:start_col])
+                        else:
+                            # Add remainder of last line
+                            masked_parts.append(lines[end_line - 1][end_col:])
+                            masked_parts.append('\n')
+                            # Add intermediate lines
+                            for line_num in range(end_line, start_line - 1):
+                                masked_parts.append(lines[line_num])
+                                masked_parts.append('\n')
+                            # Add beginning of current line
+                            masked_parts.append(lines[start_line - 1][:start_col])
+                    
+                    masked_parts.append(string_value)
+                    last_end = token.end
+                    continue
+                
+                # Determine quote style and content
+                prefix = ''
+                quote = ''
+                end_quote = ''
+                content = ''
+                
+                # Check for string prefix (r, b, u, etc. - but not f)
+                i = 0
+                while i < len(string_value) and string_value[i].lower() in 'rbux':
+                    prefix += string_value[i]
+                    i += 1
+                
+                remaining = string_value[i:]
+                
+                if remaining.startswith(('"""', "'''")):
+                    quote = prefix + remaining[:3]
+                    end_quote = remaining[-3:]
+                    content = remaining[3:-3]
+                elif remaining.startswith(('"', "'")):
+                    quote = prefix + remaining[0]
+                    end_quote = remaining[-1]
+                    content = remaining[1:-1]
+                
+                # For regular strings, mask content while preserving newlines and leading spaces
+                lines = content.split('\n')
+                masked_lines = []
+                
+                for line in lines:
+                    # Find leading whitespace
+                    leading_space = ''
+                    for char in line:
+                        if char in (' ', '\t'):
+                            leading_space += char
+                        else:
+                            break
+                    
+                    # Mask the rest of the line
+                    rest_of_line = line[len(leading_space):]
+                    masked_rest = mask_char * len(rest_of_line)
+                    masked_lines.append(leading_space + masked_rest)
+                
+                masked_content = '\n'.join(masked_lines)
+                
+                masked_string = quote + masked_content + end_quote
+                
+                # Add any code between last token and this one
+                start_line, start_col = token.start
+                end_line, end_col = last_end
+                
+                if start_line > end_line or (start_line == end_line and start_col > end_col):
+                    lines = code.split('\n')
+                    if end_line == start_line:
+                        masked_parts.append(lines[end_line - 1][end_col:start_col])
+                    else:
+                        # Add remainder of last line
+                        masked_parts.append(lines[end_line - 1][end_col:])
+                        masked_parts.append('\n')
+                        # Add intermediate lines
+                        for line_num in range(end_line, start_line - 1):
+                            masked_parts.append(lines[line_num])
+                            masked_parts.append('\n')
+                        # Add beginning of current line
+                        masked_parts.append(lines[start_line - 1][:start_col])
+                
+                masked_parts.append(masked_string)
+                last_end = token.end
+            
+    except tokenize.TokenError:
+        # Handle incomplete code
+        pass
+    
+    # Add any remaining code
+    lines = code.split('\n')
+    end_line, end_col = last_end
+    if end_line <= len(lines):
+        masked_parts.append(lines[end_line - 1][end_col:])
+        if end_line < len(lines):
+            masked_parts.append('\n')
+            masked_parts.extend('\n'.join(lines[end_line:]))
+    
+    return ''.join(masked_parts)

{pyqt_code_editor-0.0.14 → pyqt_code_editor-0.0.16}/pyqt_code_editor/widgets/completion_popup.py

@@ -1,5 +1,4 @@
 from qtpy.QtCore import Qt
-from qtpy.QtGui import QTextCursor
 from qtpy.QtWidgets import QListWidget, QListWidgetItem
 from .. import settings
 

pyqt_code_editor-0.0.16/pyqt_code_editor/worker/languages/python.py

@@ -0,0 +1,24 @@
+from ..providers import jedi, codestral, ruff
+
+
+def complete(code, cursor_pos, path, multiline, full):
+    if full or multiline:
+        codestral_completions = codestral.codestral_complete(
+            code, cursor_pos, path=path, multiline=multiline)
+    else:
+        codestral_completions = []
+    if not multiline:
+        jedi_completions = jedi.jedi_complete(code, cursor_pos, path=path)
+    else:
+        jedi_completions = []
+    # If there is at least one jedi completion, it is always insert at first.
+    # This is to avoid the codestral completion from suddenly replacing the
+    # jedi completion that is shown already during the first (non-full) pass
+    if jedi_completions:
+        return [jedi_completions[0]] + codestral_completions + jedi_completions[1:]        
+    return codestral_completions + jedi_completions
+
+
+calltip = jedi.jedi_signatures
+check = ruff.ruff_check
+symbols = jedi.jedi_symbols

pyqt_code_editor-0.0.14/pyqt_code_editor/worker/languages/python.py

@@ -1,17 +0,0 @@
-from ..providers import jedi, codestral, ruff
-
-
-def complete(code, cursor_pos, path, multiline, full):
-    if full or multiline:
-        completions = codestral.codestral_complete(
-            code, cursor_pos, path=path, multiline=multiline)
-    else:
-        completions = []
-    if not multiline:
-        completions += jedi.jedi_complete(code, cursor_pos, path=path)
-    return completions
-
-
-calltip = jedi.jedi_signatures
-check = ruff.ruff_check
-symbols = jedi.jedi_symbols