pyqt-code-editor 0.0.47__tar.gz → 0.0.50__tar.gz

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqt_code_editor
-Version: 0.0.47
+Version: 0.0.50
 Summary: Fully featured code-editor widgets for PyQt
 Keywords: code editor,pyqt,ide
 Author-email: Sebastiaan Mathôt <s.mathot@cogsci.nl>
@@ -12,15 +12,22 @@ Requires-Dist: detect-indent
 Requires-Dist: jedi
 Requires-Dist: httpx<0.29.0
 Requires-Dist: mistralai
+Requires-Dist: opensesame-extension-sigmund
 Requires-Dist: pathspec
 Requires-Dist: psutil
 Requires-Dist: pygments
 Requires-Dist: qtawesome
 Requires-Dist: qtpy
-Requires-Dist: ruff
-Requires-Dist: opensesame-extension-sigmund
 Requires-Dist: pyqt6
 Requires-Dist: qtconsole
+Requires-Dist: tree-sitter
+Requires-Dist: tree-sitter-javascript
+Requires-Dist: tree-sitter-json
+Requires-Dist: tree-sitter-html
+Requires-Dist: tree-sitter-python
+Requires-Dist: tree-sitter-toml
+Requires-Dist: tree-sitter-yaml
+Requires-Dist: ruff
 Project-URL: Source, https://github.com/open-cogsci/sigmund-analyst
 
 # PyQt Code Editor / Sigmund Analyst

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyproject.toml

@@ -17,15 +17,22 @@ dependencies = [
     "jedi",
     "httpx<0.29.0",
     "mistralai",
+    "opensesame-extension-sigmund",
     "pathspec",
     "psutil",
     "pygments",
     "qtawesome",
     "qtpy",
-    "ruff",
-    "opensesame-extension-sigmund",
     "pyqt6",
-    "qtconsole"
+    "qtconsole",
+    "tree-sitter",
+    "tree-sitter-javascript",
+    "tree-sitter-json",
+    "tree-sitter-html",
+    "tree-sitter-python",
+    "tree-sitter-toml",
+    "tree-sitter-yaml",
+    "ruff"
 ]
 keywords = ["code editor", "pyqt", "ide"]
 

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/__init__.py

@@ -2,4 +2,4 @@
 
 from ._settings import settings
 
-__version__ = '0.0.47'
+__version__ = '0.0.50'

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/app.py

@@ -37,6 +37,7 @@ class SigmundAnalyst(QMainWindow):
         # The editor panel provides splittable editor tabs
         self._editor_panel = EditorPanel()
         self._editor_panel.open_folder_requested.connect(self._open_folder)
+        self._editor_panel.open_file_requested.connect(self._open_file)
         self.setCentralWidget(self._editor_panel)
         self._project_explorers = []
         # Track if project explorers are hidden as a group
@@ -407,6 +408,9 @@ class SigmundAnalyst(QMainWindow):
             self._project_explorers_hidden = False
             for explorer in self._project_explorers:
                 explorer.setVisible(True)
+                
+    def _open_file(self, path):
+        self._editor_panel.open_file(path)
 
     def closeEvent(self, event):
         # Check if there are unsaved changes, and ask for confirmation if there

pyqt_code_editor-0.0.50/pyqt_code_editor/code_editors/languages/generic.py

@@ -0,0 +1,13 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import (MergeUndoActions, Complete, Theme, Zoom,
+                                     LineNumber, Comment, AutoIndent,
+                                     AutoPair, SearchReplace, Base, Check,
+                                     Shortcuts, FileLink, Symbols,
+                                     HighlightMatchingBrackets)
+
+
+class Editor(MergeUndoActions, LineNumber, Zoom, Complete, AutoIndent,
+             AutoPair, Comment, SearchReplace, FileLink, Theme, Check,
+             Shortcuts, HighlightMatchingBrackets, Symbols, Base,
+             QPlainTextEdit):
+    pass

pyqt_code_editor-0.0.50/pyqt_code_editor/code_editors/languages/markdown.py

@@ -0,0 +1,11 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import (MergeUndoActions, Complete,
+                                     HighlightSyntax, Zoom, LineNumber,
+                                     Comment, SearchReplace, Base, Check,
+                                     Shortcuts, FileLink, Symbols)
+
+
+class Editor(MergeUndoActions, LineNumber, Zoom, Complete, Comment,
+             SearchReplace, FileLink, HighlightSyntax, Check, Shortcuts,
+             Symbols, Base, QPlainTextEdit):
+    pass

pyqt_code_editor-0.0.50/pyqt_code_editor/code_editors/languages/python.py

@@ -0,0 +1,16 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import (Complete, PythonAutoIndent,
+                                     PythonAutoPair, Theme, Zoom, LineNumber,
+                                     Comment, SearchReplace, Base, Check,
+                                     Shortcuts, FileLink, Symbols,
+                                     SmartBackspaceDelete, Execute,
+                                     MergeUndoActions,
+                                     HighlightMatchingBrackets)
+
+
+class Editor(MergeUndoActions, LineNumber, Zoom, SmartBackspaceDelete,
+             PythonAutoPair, Complete, Comment, PythonAutoIndent,
+             SearchReplace, FileLink, Execute, Check, Theme, Shortcuts,
+             HighlightMatchingBrackets, Symbols, Base, QPlainTextEdit):
+                 
+    code_editor_language = 'python'

pyqt_code_editor-0.0.50/pyqt_code_editor/code_editors/languages/text.py

@@ -0,0 +1,11 @@
+from qtpy.QtWidgets import QPlainTextEdit
+from pyqt_code_editor.mixins import (MergeUndoActions, Complete,
+                                     HighlightSyntax, Zoom, LineNumber,
+                                     SearchReplace, Base, Check, Shortcuts,
+                                     FileLink)
+
+
+class Editor(MergeUndoActions, LineNumber, Zoom, Complete, SearchReplace,
+             FileLink, HighlightSyntax, Check, Shortcuts, Base,
+             QPlainTextEdit):
+    pass

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/components/editor_panel.py

@@ -11,6 +11,7 @@ logger = logging.getLogger(__name__)
 class EditorPanel(QWidget):
     
     open_folder_requested = Signal(str)
+    open_file_requested = Signal(str)
     
     def __init__(self, parent=None, initial_path=None):
         super().__init__(parent)
@@ -58,6 +59,7 @@ class EditorPanel(QWidget):
         t.lastTabClosed.connect(self.handle_tabbed_editor_empty)
         t.tabCloseRequested.connect(self._relabel_tabs)
         t.open_folder_requested.connect(self.open_folder_requested)
+        t.open_file_requested.connect(self.open_file_requested)
         return t
     
     def unsaved_changes(self):
@@ -92,7 +94,7 @@ class EditorPanel(QWidget):
             settings.current_folder = os.path.dirname(path)
             self.open_file(path)
             
-    def _keep_track_of_active_editor(self, editor):
+    def _keep_track_of_active_editor(self, editor):        
         logger.info(f"active editor = {editor}")
         self._active_editor = editor
         self._active_tab_widget = self._active_editor.parent().parent()

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/components/settings_panel.py

@@ -104,7 +104,7 @@ class SettingsWidget(QWidget):
             
         elif isinstance(value, int):
             widget = QSpinBox()
-            widget.setRange(-9999, 9999)  # Reasonable default range
+            widget.setRange(int(-1e9), int(1e9))  # Reasonable default range
             widget.setValue(value)
             widget.valueChanged.connect(lambda val, name=setting_name: 
                                        self.update_setting(name, val))

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/components/workspace_explorer.py

@@ -1,8 +1,9 @@
-from qtpy.QtWidgets import (QDockWidget, QWidget, QVBoxLayout, QHBoxLayout, 
-                            QTableView, QHeaderView, QLineEdit, QLabel, 
-                            QAbstractItemView, QMenu, QAction)
-from qtpy.QtCore import Qt, QSortFilterProxyModel, QAbstractTableModel, QModelIndex
-from qtpy.QtGui import QIcon, QColor, QFont, QBrush
+from qtpy.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QTableView, 
+                            QHeaderView, QLineEdit, QAbstractItemView, QMenu,
+                            QAction)
+from qtpy.QtCore import (Qt, QSortFilterProxyModel, QAbstractTableModel,
+                         QModelIndex)
+from qtpy.QtGui import QColor, QFont, QBrush
 from ..widgets import Dock
 
 
@@ -77,6 +78,7 @@ class WorkspaceModel(QAbstractTableModel):
             return self._headers[section]
         return None
 
+
 class WorkspaceExplorer(Dock):
     """Dock widget for exploring variables in the Jupyter workspace"""
     
@@ -150,13 +152,7 @@ class WorkspaceExplorer(Dock):
             # Add actions specific to the variable
             inspect_action = QAction(f"Inspect '{var_name}'", self)
             delete_action = QAction(f"Delete '{var_name}'", self)
-            
             menu.addAction(inspect_action)
             menu.addAction(delete_action)
-            
-            # Show the menu
-            action = menu.exec_(self.table_view.mapToGlobal(position))
-            
-            # Handle action selection
-            # (In a real implementation, would connect to actual functionality)
+            menu.exec_(self.table_view.mapToGlobal(position))
             

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/mixins/__init__.py

@@ -14,3 +14,5 @@ from .symbols import Symbols
 from .shortcuts import Shortcuts
 from .theme import Theme
 from .zoom import Zoom
+from .merge_undo_actions import MergeUndoActions
+from .highlight_matching_brackets import HighlightMatchingBrackets

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/mixins/auto_indent.py

@@ -118,7 +118,6 @@ class AutoIndent:
         """
         logger.info("indent_code triggered")
         cursor = self.textCursor()
-        cursor.beginEditBlock()
 
         if self._is_multiline_selection():
             logger.info("Multi-line selection -> indent each line")
@@ -128,8 +127,6 @@ class AutoIndent:
             indent_str = self._get_indent_string()
             cursor.insertText(indent_str)
 
-        cursor.endEditBlock()
-
     def dedent_code(self):
         """
         Dedent either the selected lines (if multi-line selection)
@@ -137,7 +134,6 @@ class AutoIndent:
         """
         logger.info("dedent_code triggered")
         cursor = self.textCursor()
-        cursor.beginEditBlock()
 
         if self._is_multiline_selection():
             logger.info("Multi-line selection -> dedent each line")
@@ -156,8 +152,6 @@ class AutoIndent:
             for _ in range(remove_chars):
                 self._delete_forward_if_tab_or_space(cursor)
 
-        cursor.endEditBlock()
-
     def _indent_selection(self):
         """
         Increase indent for each selected line by one chunk.

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/mixins/auto_pair.py

@@ -4,9 +4,8 @@ logger = logging.getLogger(__name__)
 
 
 class AutoPair:
-    """
-    Generic mixin for auto-pairing brackets/quotes/etc.
-    
+    """Generic mixin for auto-pairing brackets/quotes/etc.
+
     You can override self.PAIRS to add or remove different open/close
     sequences. Each entry is a dict with:
       - open_seq: string that triggers auto-pair (e.g. '(' or '\"\"\"')
@@ -14,7 +13,7 @@ class AutoPair:
       - inbetween_seq: optional string inserted between open_seq and close_seq
                       (can be empty). e.g. '\n' for triple quotes.
     """
-    
+
     PAIRS = [
         {"open_seq": "(", "close_seq": ")", "inbetween_seq": ""},
         {"open_seq": "[", "close_seq": "]", "inbetween_seq": ""},
@@ -22,155 +21,179 @@ class AutoPair:
         {"open_seq": "\"", "close_seq": "\"", "inbetween_seq": ""},
         {"open_seq": "\'", "close_seq": "\'", "inbetween_seq": ""},
     ]
-    
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.setUndoRedoEnabled(True)
         # For scanning up to the max length of an open_seq
         self._max_open_len = max(len(pair["open_seq"]) for pair in self.PAIRS)
+        self._trigger_chars = ''.join([pair['open_seq'] + pair['close_seq']
+                                      for pair in self.PAIRS])
 
     def keyPressEvent(self, event):
+        # Determine all relevant variables upfront
+        typed_char = event.text()
+        typed_key = event.key()
         cursor = self.textCursor()
         old_pos = cursor.position()
         selected_text = cursor.selectedText()
-        
+        doc_text = self.toPlainText()
+        doc_len = len(doc_text)
+        # Get character before cursor
+        if old_pos > 0:
+            char_before = doc_text[old_pos - 1]
+        else:
+            char_before = ""        
+        # Get character after cursor
+        if old_pos < doc_len:
+            char_after = doc_text[old_pos]
+        else:
+            char_after = ""
+
+        # If there is no opening (trigger character or backspace), then we 
+        # don't need to do anything.
+        if typed_char not in self._trigger_chars and typed_key != Qt.Key_Backspace:
+            super().keyPressEvent(event)
+            return
+
+        # Don't autopair when there is no selection and the next character is
+        # alphanumeric or underscore. This is for example when we're typing the
+        # opening bracket of a list that is already completed
+        if not selected_text:
+            if char_after.isalnum() or char_after == "_":
+                super().keyPressEvent(event)
+                return
+
         # Allows auto-pairing to be disabled for certain positions
         if self._disabled_for_position(old_pos):
             super().keyPressEvent(event)
             return
-        
+
         # 1) Handle backspace for removing empty pairs like (|)
-        if event.key() == Qt.Key_Backspace:
-            if self._handle_auto_pair_backspace():
+        if typed_key == Qt.Key_Backspace:
+            if self._handle_auto_pair_backspace(char_before, char_after, old_pos):
                 super().keyPressEvent(event)
                 return
-        
-        typed_char = event.text()
-        
+
         # Pass the event up (inserts the typed_char)
         super().keyPressEvent(event)
-        
+
         # 2) Possibly skip duplicate closing bracket/quote
         #    when the user manually types it.
         if typed_char and len(typed_char) == 1:
             for pair in self.PAIRS:
                 if typed_char == pair["close_seq"]:
+                    print(typed_char)
                     new_cursor = self.textCursor()
-                    doc_text = self.toPlainText()
-                    if (new_cursor.position() < len(doc_text) and
-                        doc_text[new_cursor.position()] == typed_char):
+                    new_pos = new_cursor.position()
+                    new_doc_text = self.toPlainText()
+                    new_doc_len = len(new_doc_text)
+                    if new_pos < new_doc_len and new_doc_text[new_pos] == typed_char:
                         # We remove the newly typed character and move cursor forward
-                        new_cursor.beginEditBlock()
                         # Remove the bracket that was just typed
                         new_cursor.setPosition(old_pos)
                         new_cursor.deleteChar()
                         # Move cursor to skip the existing bracket
                         new_cursor.setPosition(old_pos + 1)
-                        new_cursor.endEditBlock()
                         self.setTextCursor(new_cursor)
                     break
-        
+
         # 3) After insertion, see if the text before the cursor matches an 'open_seq'
         #    If it does, insert close_seq + inbetween_seq, then restore cursor.
         new_cursor = self.textCursor()
         new_pos = new_cursor.position()
         text = self.toPlainText()
-        
+
         # We'll scan backward from new_pos for up to _max_open_len chars
         start_search = max(0, new_pos - self._max_open_len)
         just_typed = text[start_search:new_pos]
-        
+
         for pair in self.PAIRS:
             open_seq = pair["open_seq"]
             close_seq = pair["close_seq"]
             inbetween_seq = pair["inbetween_seq"]
-            
+
             if just_typed.endswith(open_seq) and event.text() == text[new_pos - 1: new_pos]:
                 self._insert_pair(open_seq, close_seq, inbetween_seq,
-                                  selected_text)
+                                  selected_text, new_pos)
                 break
 
-
-    def _handle_auto_pair_backspace(self) -> bool:
+    def _handle_auto_pair_backspace(self, char_before, char_after, pos) -> bool:
         """
         If the cursor is between an exact open_seq and close_seq pair (e.g., '(|)'),
         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.
+
+        Args:
+            char_before: The character before the cursor
+            char_after: The character after the cursor
+            pos: The cursor position
+
+        Returns:
+            True if handled, False if not.
         """
-        cursor = self.textCursor()
-        pos = cursor.position()
-    
         # We need at least one character before and after cursor
-        if pos < 1 or cursor.atEnd():
+        if not char_before or not char_after:
             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"]
-        
+
             # 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 = self.textCursor()
                 cursor.setPosition(pos)
                 cursor.deleteChar()
-            
+
                 # The standard backspace will handle the opening character
                 return True
-    
-        return False
 
+        return False
 
-    def _insert_pair(self, open_seq, close_seq, inbetween_seq, selected_text):
+    def _insert_pair(self, open_seq, close_seq, inbetween_seq, selected_text, cursor_pos):
         """
         Called when we recognize that the user typed an open_seq in full.
         Insert the close_seq plus any inbetween_seq, and restore the cursor
         to the original position (right after the open_seq).
+
+        Args:
+            open_seq: The opening sequence that was typed
+            close_seq: The closing sequence to insert
+            inbetween_seq: Text to insert between open and close
+            selected_text: Text that was selected (if any)
+            cursor_pos: Current cursor position (after the open_seq was inserted)
         """
         c = self.textCursor()
-        
-        # We'll remember where the user ended up (right after open_seq).
-        old_pos = c.position()
+
         if inbetween_seq == '\n':
             # Get indentation level of block after cursor
-            block = self.document().findBlock(old_pos)
+            block = self.document().findBlock(cursor_pos)
             block_text = block.text()
             indent = block_text[:len(block_text) - len(block_text.lstrip())]        
             inbetween_seq = '\n' + indent
-        # Insert the close_seq and inbetween_seq, indented to the same level as the block
-        c.beginEditBlock()
-                
+
         # Insert in-between text, then the closing
         c.insertText(selected_text + inbetween_seq + close_seq)
-        
+
         # Move the cursor back so that it's right after the open_seq and (if any)
         # the selected text
         c.movePosition(c.Left, c.MoveAnchor, len(close_seq) + len(inbetween_seq))
-        
-        c.endEditBlock()
+
         self.setTextCursor(c)
-        
+
         logger.info(
             "Auto-paired '%s' with '%s', inserted in-between '%s'. "
             "Cursor restored to position %d",
-            open_seq, close_seq, inbetween_seq, old_pos
+            open_seq, close_seq, inbetween_seq, cursor_pos
         )
-        
+
     def _disabled_for_position(self, pos):
         return False
 
@@ -186,7 +209,7 @@ class PythonAutoPair(AutoPair):
         {"open_seq": "\"", "close_seq": "\"", "inbetween_seq": ""},
         {"open_seq": "\'", "close_seq": "\'", "inbetween_seq": ""},
     ]
-    
+
     def _disabled_for_position(self, pos):
         """
         Returns True if 'pos' (a QTextCursor.position() in self)
@@ -197,12 +220,12 @@ class PythonAutoPair(AutoPair):
         block = self.document().findBlock(pos)
         line_text = block.text()
         column = pos - block.position()
-    
+
         # Find the first '#' in line_text
         hash_index = line_text.find('#')
-    
+
         # If a '#' is found and it's to the left of the cursor, assume comment
         if hash_index != -1 and hash_index < column:
             return True
-    
+
         return False

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/mixins/base.py

@@ -50,6 +50,13 @@ class Base:
         for example to avoid certain keypresses from being consumed.
         """
         return False
+        
+    def setFocus(self):
+        """Allows managing widgets, such as the editor panel, to keep track of
+        which editor is active
+        """
+        super().setFocus()
+        self.received_focus.emit(self)
 
     def focusInEvent(self, event):
         """Allows managing widgets, such as the editor panel, to keep track of

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/mixins/check.py

@@ -23,10 +23,6 @@ class Check:
         self._check_debounce_timer.setSingleShot(True)
         self._check_debounce_timer.setInterval(500)
         self._check_debounce_timer.timeout.connect(self._execute_check)
-        # Periodic timer: also periodically run a check
-        self._check_interval_timer = QTimer(self)
-        self._check_interval_timer.setInterval(5000)
-        self._check_interval_timer.timeout.connect(self._execute_check)
 
         # Connect textChanged signal to a debounced method
         self.textChanged.connect(self._on_code_changed)

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/mixins/comment.py

@@ -35,10 +35,8 @@ class Comment:
                 # Extract the indentation from the current line
                 indentation = line_text[:len(line_text) - len(stripped)]                
                 # Insert newline with same indentation plus comment marker
-                cursor.beginEditBlock()
                 cursor.insertText(
                     '\n' + indentation + self.code_editor_comment_string)
-                cursor.endEditBlock()
                 event.accept()
                 return
         super().keyPressEvent(event)    
@@ -76,7 +74,6 @@ class Comment:
     def _comment_blocks(self, start_block: int, end_block: int):
         """Comment all lines from start_block to end_block."""
         cursor = self.textCursor()
-        cursor.beginEditBlock()  # group undo steps
         for block_num in range(start_block, end_block + 1):
             block = self.document().findBlockByNumber(block_num)
             if not block.isValid():
@@ -87,12 +84,10 @@ class Comment:
             insert_position = block.position() + leading_spaces
             cursor.setPosition(insert_position)
             cursor.insertText(self.code_editor_comment_string)  
-        cursor.endEditBlock()
 
     def _uncomment_blocks(self, start_block: int, end_block: int):
         """Uncomment all lines from start_block to end_block."""
         cursor = self.textCursor()
-        cursor.beginEditBlock()
         for block_num in range(start_block, end_block + 1):
             block = self.document().findBlockByNumber(block_num)
             if not block.isValid():
@@ -107,4 +102,3 @@ class Comment:
                 cursor.setPosition(remove_position + strip_len, cursor.KeepAnchor)
                 if cursor.selectedText() == self.code_editor_comment_string.rstrip('\r\n'):
                     cursor.removeSelectedText()
-        cursor.endEditBlock()

{pyqt_code_editor-0.0.47 → pyqt_code_editor-0.0.50}/pyqt_code_editor/mixins/file_link.py

@@ -42,29 +42,30 @@ class FileLink:
         # Check file size
         file_size = path.stat().st_size
         is_large = file_size > settings.max_file_size
-        
-        raw_data = path.read_bytes()
         encoding_unknown = False
 
-        if encoding is None:
-            # First see if everything is within ASCII range
-            try:
-                raw_data.decode("utf-8")
-                # If no error -> it's strictly ASCII, so decode as UTF-8
-                used_encoding = "utf-8"
-            except UnicodeDecodeError:
-                # Not pure ASCII; let chardet pick
-                detect_result = chardet.detect(raw_data)
-                # If detection fails or returns None, or confidence is low
-                if (detect_result is None or 
-                    detect_result.get("encoding") is None or
-                    detect_result.get("confidence", 0) < 0.7):
+        if not is_large:
+            raw_data = path.read_bytes()
+    
+            if encoding is None:
+                # First see if everything is within ASCII range
+                try:
+                    raw_data.decode("utf-8")
+                    # If no error -> it's strictly ASCII, so decode as UTF-8
                     used_encoding = "utf-8"
-                    encoding_unknown = True
-                else:
-                    used_encoding = detect_result["encoding"]
-        else:
-            used_encoding = encoding
+                except UnicodeDecodeError:
+                    # Not pure ASCII; let chardet pick
+                    detect_result = chardet.detect(raw_data)
+                    # If detection fails or returns None, or confidence is low
+                    if (detect_result is None or 
+                        detect_result.get("encoding") is None or
+                        detect_result.get("confidence", 0) < 0.7):
+                        used_encoding = "utf-8"
+                        encoding_unknown = True
+                    else:
+                        used_encoding = detect_result["encoding"]
+            else:
+                used_encoding = encoding
             
         # Show warning if file is large or encoding is uncertain
         if is_large or encoding_unknown: