pyqt-code-editor 0.0.34__tar.gz → 0.0.35__tar.gz

{pyqt_code_editor-0.0.34 → pyqt_code_editor-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.34
+Version: 0.0.35
 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.34 → pyqt_code_editor-0.0.35}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.34'
+__version__ = '0.0.35'

{pyqt_code_editor-0.0.34 → pyqt_code_editor-0.0.35}/pyqt_code_editor/code_editors/languages/python.py

@@ -7,7 +7,7 @@ from pyqt_code_editor.mixins import Complete, PythonAutoIndent, \
 
 class Editor(LineNumber, Zoom, SmartBackspaceDelete, PythonAutoPair, Complete,
              Comment, PythonAutoIndent, SearchReplace, FileLink, Execute,
-             Theme, Check, Shortcuts, Symbols, Base,
+             Theme, Shortcuts, Symbols, Base, Check, 
              QPlainTextEdit):
                  
     code_editor_language = 'python'

{pyqt_code_editor-0.0.34 → pyqt_code_editor-0.0.35}/pyqt_code_editor/mixins/auto_pair.py

@@ -42,6 +42,7 @@ class AutoPair:
         # 1) Handle backspace for removing empty pairs like (|)
         if event.key() == Qt.Key_Backspace:
             if self._handle_auto_pair_backspace():
+                super().keyPressEvent(event)
                 return
         
         typed_char = event.text()
@@ -93,39 +94,45 @@ class AutoPair:
     def _handle_auto_pair_backspace(self) -> bool:
         """
         If the cursor is between an exact open_seq and close_seq pair (e.g., '(|)'),
-        remove the full pair. Returns True if handled, False if not.
+        remove the following close_seq. The preceding open_seq will be removed 
+        by the standard backspace. Only works for pairs of single characters.
+        Returns True if handled, False if not.
         """
         cursor = self.textCursor()
         pos = cursor.position()
-        text = self.toPlainText()
-
+    
+        # We need at least one character before and after cursor
+        if pos < 1 or cursor.atEnd():
+            return False
+    
+        # Get the character before the cursor
+        cursor.setPosition(pos - 1)
+        cursor.setPosition(pos, cursor.KeepAnchor)
+        char_before = cursor.selectedText()
+    
+        # Get the character after the cursor
+        cursor.setPosition(pos)
+        cursor.setPosition(pos + 1, cursor.KeepAnchor)
+        char_after = cursor.selectedText()
+    
+        # Check if they form a pair
         for pair in self.PAIRS:
             open_seq = pair["open_seq"]
             close_seq = pair["close_seq"]
-            if open_seq and close_seq:
-                l_open = len(open_seq)
-                l_close = len(close_seq)
-                
-                # Make sure there's enough room before and after the cursor
-                if pos >= l_open and pos + l_close <= len(text):
-                    behind = text[pos - l_open : pos]
-                    ahead = text[pos : pos + l_close]
-
-                    # If the cursor is right between open_seq and close_seq
-                    # with nothing typed in between (e.g. (|))
-                    if behind == open_seq and ahead == close_seq:
-                        c = self.textCursor()
-                        c.beginEditBlock()
-                        # Remove from open_seq start to close_seq end
-                        c.setPosition(pos - l_open)
-                        for _ in range(l_open + l_close):
-                            c.deleteChar()
-                        c.endEditBlock()
-
-                        # Move cursor to the old open_seq start
-                        c.setPosition(pos - l_open)
-                        self.setTextCursor(c)
-                        return True
+        
+            # Only handle single-character pairs
+            if len(open_seq) != 1 or len(close_seq) != 1:
+                continue
+            
+            if char_before == open_seq and char_after == close_seq:
+                logger.info("deleting closing bracket")
+                # Delete only the closing character
+                cursor.setPosition(pos)
+                cursor.deleteChar()
+            
+                # The standard backspace will handle the opening character
+                return True
+    
         return False
 
 

{pyqt_code_editor-0.0.34 → pyqt_code_editor-0.0.35}/pyqt_code_editor/worker/providers/jedi.py

@@ -7,18 +7,77 @@ logger = logging.getLogger(__name__)
 env_cache = {}
 
 
-def _signature_to_html(signature) -> str:
+def _estimate_width(text):
+    """Helper function to estimate display width of signature
+    (rough approximation)
+    """
+    # Remove HTML tags for width calculation
+    clean_text = re.sub(r'<[^>]+>', '', text)
+    return len(clean_text)
+
+
+def _wrap_params(params, width_limit):
+    """Helper function to wrap signature parameters"""
+    lines = []
+    current_line = []
+    current_width = 1  # Starting with "("
+    
+    for i, param in enumerate(params):
+        param_width = _estimate_width(param)
+        # Add comma and space width for non-first parameters
+        if current_line:
+            param_width += 2
+        
+        # Check if adding this param would exceed width
+        if current_line and current_width + param_width > width_limit:
+            # Start a new line
+            lines.append(", ".join(current_line))
+            current_line = [param]
+            current_width = 6 + param_width  # Indent width + param
+        else:
+            current_line.append(param)
+            current_width += param_width
+    
+    if current_line:
+        lines.append(", ".join(current_line))
+    
+    return lines
+
+
+def _signature_to_html(signature, max_width: int, max_lines: int) -> str:
     """Convert jedi.Script.get_signatures() output to nicely formatted HTML."""
     param_strs = []
     for param in signature.params:
         param_strs.append(param.to_string())
-    # Build the signature line
-    sig_line = ",<br />&nbsp;".join(param_strs)
+    
+    # Get return annotation if available
     return_hint = ""
-    # If there's a known return annotation, append it
     if hasattr(signature, "annotation_string") and signature.annotation_string:
-        return_hint = f"-> {signature.annotation_string}"
-    return f"({sig_line}){return_hint}"
+        return_hint = f" -> {signature.annotation_string}"
+    
+    # Wrap parameters based on max_width
+    wrapped_lines = _wrap_params(param_strs,
+                                 max_width - _estimate_width(return_hint) - 2)
+    
+    # Limit number of lines
+    if len(wrapped_lines) > max_lines:
+        # Keep first max_lines-1 lines and add ellipsis
+        wrapped_lines = wrapped_lines[:max_lines-1]
+        if wrapped_lines:
+            wrapped_lines[-1] += ", ..."
+    
+    # Build the final HTML
+    if len(wrapped_lines) == 0:
+        return f"(){return_hint}"
+    elif len(wrapped_lines) == 1:
+        return f"({wrapped_lines[0]}){return_hint}"
+    else:
+        # Multi-line format with indentation
+        html_lines = [f"({wrapped_lines[0]},"]
+        for line in wrapped_lines[1:-1]:
+            html_lines.append(f"<br />&nbsp;{line},")
+        html_lines.append(f"<br />&nbsp;{wrapped_lines[-1]}){return_hint}")
+        return "".join(html_lines)
 
 
 def _prepare_jedi_script(code: str, cursor_position: int, path: str | None,
@@ -84,8 +143,7 @@ def jedi_complete(code: str, cursor_position: int, path: str | None,
 
 
 def jedi_signatures(code: str, cursor_position: int, path: str | None,
-                    multiline: bool = False, max_width: int = 40,
-                    max_lines: int = 10,
+                    max_width: int = 40, max_lines: int = 10,
                     env_path: str | None = None,
                     prefix: str | None = None) -> list[str]:
     """
@@ -100,7 +158,7 @@ def jedi_signatures(code: str, cursor_position: int, path: str | None,
         logger.info("No code or cursor_position=0; cannot fetch calltip.")
         return None
 
-    logger.info("Starting Jedi calltip request (multiline=%r).", multiline)
+    logger.info("Starting Jedi calltip request")
     script, line_no, column_no = _prepare_jedi_script(code, cursor_position,
                                                       path, env_path, prefix)
 
@@ -111,7 +169,7 @@ def jedi_signatures(code: str, cursor_position: int, path: str | None,
 
     results = []
     for sig in signatures:
-        results.append(_signature_to_html(sig))
+        results.append(_signature_to_html(sig, max_width, max_lines))
 
     logger.info("Got %d signature(s) from Jedi.", len(results))
     return results or None