QCodeSitter 0.1.0__py3-none-any.whl

QCodeSitter/tree_manager.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from Qt import QtCore
+from tree_sitter import Language, Node, Parser, Point, Tree
+
+from .tracked_document import ENC, TrackedDocument
+
+
+class TreeManager(QtCore.QObject):
+    """Owns the tree-sitter parse tree of a document
+
+    Edits are applied incrementally, and every reparse emits `reparsed`.
+    Offsets and Point columns are UTF-16LE bytes, see TrackedDocument.
+    """
+
+    reparsed = QtCore.Signal()
+    # Emitted after the language changes, before the new tree is parsed
+    languageChanged = QtCore.Signal()
+
+    def __init__(self, document: TrackedDocument) -> None:
+        super().__init__()
+        self.document = document
+        self.parser: Parser | None = None
+        self.tree: Tree | None = None
+        self._pause_depth = 0
+        # Whether an edit was made while paused, so unpausing has to reparse
+        self._reparse_pending = False
+
+        # The (first, last) rows touched by edits since the last parse
+        self._edit_rows: tuple[int, int] | None = None
+        # The (first, last) row ranges that changed in the last parse
+        # None means the whole document changed
+        self.changed_rows: list[tuple[int, int]] | None = None
+
+        self._set_parser(None)
+
+    @property
+    def language(self) -> Language | None:
+        return self.parser.language if self.parser is not None else None
+
+    @property
+    def is_paused(self) -> bool:
+        return self._pause_depth > 0
+
+    def set_language(self, language: Language | None) -> None:
+        """Change the language, and parse the document again"""
+        self._set_parser(language)
+        self.languageChanged.emit()
+        self.parse_from_scratch()
+
+    def _set_parser(self, language: Language | None) -> None:
+        self.parser = Parser(language) if language is not None else None
+        self.tree = None
+        self._edit_rows = None
+        self.changed_rows = None
+
+    def treesitter_source_callback(self, _byte_offset: int, ts_point: Point) -> bytes:
+        """Give tree-sitter the UTF-16LE bytes from a Point to the end of its line"""
+        curblock = self.document.findBlockByNumber(ts_point.row)
+        # The block can be invalid after an undo
+        if not curblock.isValid():
+            return b""
+
+        suffix = "\n" if curblock.next().isValid() else ""
+        linetext = curblock.text() + suffix
+        return linetext.encode(ENC)[ts_point.column :]
+
+    def _parse(self, parser: Parser, old_tree: Tree | None = None) -> Tree:
+        if old_tree is None:
+            return parser.parse(self.treesitter_source_callback, encoding="utf16")
+        return parser.parse(self.treesitter_source_callback, old_tree, encoding="utf16")
+
+    def parse_from_scratch(self) -> None:
+        """Parse the whole document from scratch. Without a language there is no tree"""
+        self.tree = self._parse(self.parser) if self.parser is not None else None
+        self._edit_rows = None
+        self.changed_rows = None
+        self.reparsed.emit()
+
+    def pause(self) -> None:
+        """Hold reparses until `unpause`, so a group of edits is parsed once
+
+        Pauses nest, and only the unpause matching the first pause reparses
+        """
+        if self._pause_depth == 0:
+            self._reparse_pending = False
+        self._pause_depth += 1
+
+    def unpause(self) -> None:
+        if self._pause_depth == 0:
+            return
+        self._pause_depth -= 1
+        if self._pause_depth == 0 and self._reparse_pending:
+            self._reparse_pending = False
+            self.reparse()
+
+    def _track_edit_rows(
+        self, start_row: int, old_end_row: int, new_end_row: int
+    ) -> None:
+        """Grow the span of edited rows to include this edit
+
+        The span is kept in the current document's rows, so rows after
+        the edit shift by the number of lines it added or removed
+        """
+        if self._edit_rows is None:
+            self._edit_rows = (start_row, new_end_row)
+            return
+        lo, hi = self._edit_rows
+        if hi > old_end_row:
+            hi += new_end_row - old_end_row
+        else:
+            hi = new_end_row
+        self._edit_rows = (min(lo, start_row), hi)
+
+    def apply_edit(
+        self,
+        start_byte: int,
+        old_end_byte: int,
+        new_end_byte: int,
+        start_point: Point,
+        old_end_point: Point,
+        new_end_point: Point,
+    ) -> None:
+        """Apply a document edit to the tree and reparse
+
+        The arguments match TrackedDocument.byteContentsChange: UTF-16LE byte
+        offsets, and Points whose columns are in bytes
+        """
+        if self.tree is not None:
+            self.tree.edit(
+                start_byte=start_byte,
+                old_end_byte=old_end_byte,
+                new_end_byte=new_end_byte,
+                start_point=start_point,
+                old_end_point=old_end_point,
+                new_end_point=new_end_point,
+            )
+        self._track_edit_rows(start_point.row, old_end_point.row, new_end_point.row)
+        self.reparse()
+
+    def reparse(self) -> None:
+        """Reparse incrementally after edits, recording which rows changed"""
+        if self._pause_depth:
+            self._reparse_pending = True
+            return
+
+        if self.parser is None:
+            self._edit_rows = None
+            return
+
+        old_tree = self.tree
+        self.tree = self._parse(self.parser, old_tree)
+        if old_tree is None:
+            self.changed_rows = None
+        else:
+            # The rows that need rehighlighting are the ones whose syntax changed
+            # plus the ones that were edited, because predicates check the text
+            rows = [
+                (r.start_point.row, r.end_point.row)
+                for r in old_tree.changed_ranges(self.tree)
+            ]
+            if self._edit_rows is not None:
+                rows.append(self._edit_rows)
+            self.changed_rows = rows
+        self._edit_rows = None
+        self.reparsed.emit()
+
+    def node_at_byte(self, byte_offset: int) -> Node | None:
+        """Get the smallest node at a UTF-16LE byte offset"""
+        if self.tree is None:
+            return None
+        return self.tree.root_node.descendant_for_byte_range(byte_offset, byte_offset)
+
+    def node_at_char(self, position: int) -> Node | None:
+        """Get the smallest node at a Qt position"""
+        return self.node_at_byte(TrackedDocument.char_to_byte(position))
+
+    @property
+    def root_node(self) -> Node | None:
+        return self.tree.root_node if self.tree is not None else None

QCodeSitter/utils.py

@@ -0,0 +1,84 @@
+"""Short names for the Qt enums, indentation string helpers, and Qt5/Qt6 event and
+action shims
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from Qt import QtCore, QtGui, QtWidgets
+
+MO = QtGui.QTextCursor.MoveOperation
+MM = QtGui.QTextCursor.MoveMode
+KEY = QtCore.Qt.Key
+MOD = QtCore.Qt.KeyboardModifier
+
+
+def leading_whitespace(text: str) -> str:
+    """The indentation at the start of a line"""
+    return text[: len(text) - len(text.lstrip())]
+
+
+def dedent_string(indent: str, indent_using_tabs: bool, space_indent_width: int) -> str:
+    """Remove one level of indentation from the indent string"""
+    if indent_using_tabs:
+        return indent.removesuffix("\t")
+    trailing_spaces = len(indent) - len(indent.rstrip(" "))
+    remove = min(space_indent_width, trailing_spaces)
+    return indent[:-remove] if remove else indent
+
+
+def event_pos(event: QtGui.QMouseEvent | QtGui.QDropEvent) -> QtCore.QPoint:
+    """The event position as a QPoint in both Qt5 and Qt6"""
+    position = getattr(event, "position", None)
+    return position().toPoint() if position is not None else event.pos()
+
+
+def make_shortcut_action(
+    parent: QtWidgets.QWidget,
+    shortcut: str,
+    slot: Callable[..., object],
+    name: str = "",
+) -> QtGui.QAction:
+    """Create an action for a keyboard shortcut that only fires in the parent widget"""
+    action = QtGui.QAction(name, parent)
+    action.setShortcut(QtGui.QKeySequence(shortcut))
+    action.setShortcutContext(QtCore.Qt.ShortcutContext.WidgetWithChildrenShortcut)
+    action.triggered.connect(slot)
+    return action
+
+
+def add_menu_action(
+    menu: QtWidgets.QMenu,
+    text: str,
+    slot: Callable[[], object],
+    shortcut: str = "",
+    enabled: bool = True,
+) -> QtGui.QAction:
+    """Add an action to a menu, showing the shortcut that runs it elsewhere
+
+    The shortcut is only shown, not bound, so it doesn't clash with the editor's
+    own shortcut action while the menu is open
+    """
+    if shortcut:
+        native = QtGui.QKeySequence(shortcut).toString(
+            QtGui.QKeySequence.SequenceFormat.NativeText
+        )
+        text = f"{text}\t{native}"
+    action = menu.addAction(text)
+    action.setEnabled(enabled)
+    # triggered passes a `checked` bool, which the slot doesn't take
+    action.triggered.connect(lambda _checked=False: slot())
+    return action
+
+
+def tidy_separators(menu: QtWidgets.QMenu) -> None:
+    """Remove the separators at the start or end of a menu, or next to another"""
+    previous_was_separator = True
+    for action in menu.actions():
+        if action.isSeparator() and previous_was_separator:
+            menu.removeAction(action)
+        previous_was_separator = action.isSeparator()
+    actions = menu.actions()
+    if actions and actions[-1].isSeparator():
+        menu.removeAction(actions[-1])

qcodesitter-0.1.0.dist-info/METADATA

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: QCodeSitter
+Version: 0.1.0
+Summary: A tree-sitter powered code editor widget for Qt
+Author-email: Tyler Fox <tyler@blur.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tbttfox/qcodesitter
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: Qt.py>=2.0
+Requires-Dist: tree-sitter<0.26,>=0.25.2
+Requires-Dist: tree-sitter-python<0.26,>=0.23
+Provides-Extra: pyside6
+Requires-Dist: PySide6; extra == "pyside6"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-qt>=4.0; extra == "test"
+Requires-Dist: PySide6; extra == "test"
+Provides-Extra: fuzz
+Requires-Dist: pytest>=7.0; extra == "fuzz"
+Requires-Dist: pytest-qt>=4.0; extra == "fuzz"
+Requires-Dist: pytest-timeout; extra == "fuzz"
+Requires-Dist: hypothesis; extra == "fuzz"
+Requires-Dist: PySide6; extra == "fuzz"
+Provides-Extra: dev
+Requires-Dist: tox>=4.0; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Provides-Extra: preditor
+Requires-Dist: preditor; extra == "preditor"
+Dynamic: license-file
+
+# QCodeSitter
+
+A reusable, tree-sitter-powered code editor widget for Qt applications. QCodeSitter provides a `QPlainTextEdit` subclass with syntax highlighting, multi-cursor editing, smart indentation, code folding, and more -- all driven by a modular plugin system that makes it easy to add, remove, or customize features.
+
+This is not an IDE. It's a drop-in editor widget you can embed in your own Qt application.
+
+## Quick Start
+
+The quickest way to a full editor is the default setup:
+
+```python
+from Qt import QtWidgets
+
+from QCodeSitter import CodeEditor, default_options, install_default_behaviors
+
+app = QtWidgets.QApplication([])
+editor = CodeEditor(default_options())
+install_default_behaviors(editor)
+editor.show()
+app.exec()
+```
+
+`install_default_behaviors(editor, optional=True)` also adds the behaviors that are off by
+default, like `AutoBracket`.
+
+Or pick the options and behaviors yourself:
+
+```python
+from tree_sitter import Language
+import tree_sitter_python as tspython
+from Qt import QtGui
+
+from QCodeSitter import CodeEditor, EditorOptions
+from QCodeSitter.themes import DARK_THEME, read_theme
+from QCodeSitter.behaviors.syntax_highlighting import SyntaxHighlighting
+from QCodeSitter.behaviors.smart_indent import SmartIndent
+from QCodeSitter.behaviors.line_numbers import LineNumbers
+from QCodeSitter.behaviors.auto_bracket import AutoBracket
+
+language = Language(tspython.language())
+colors, syntax = read_theme(DARK_THEME)
+options = EditorOptions({
+    "space_indent_width": 4,
+    "indent_using_tabs": False,
+    "language": language,
+    "syntax": syntax,
+    "colors": colors,
+    "font": QtGui.QFont("Consolas", pointSize=11),
+})
+
+editor = CodeEditor(options)
+editor.add_behavior(SyntaxHighlighting)
+editor.add_behavior(SmartIndent)
+editor.add_behavior(LineNumbers)
+editor.add_behavior(AutoBracket)
+```
+
+You only pay for what you use. If you don't need code folding, don't add it. If you want custom behavior, write your own.
+
+Every option is listed in `OptionsDict` in `editor_options.py`, and the options you don't
+give take their value from `OPTION_DEFAULTS`. Setting an option that isn't listed raises a
+`KeyError`, and a value of the wrong type raises a `TypeError`, so mistakes don't silently
+do nothing. The highlight query comes from the language, so changing `"language"` is all it
+takes to highlight another language. `"syntax"` only holds the format of each capture.
+
+The `"colors"` option holds the gui colors, listed with their defaults in `gui_colors.py`.
+
+Setting an option to the value it already has does nothing, so change a list option by
+setting a new list rather than editing it in place. A behavior from outside the package
+adds its own options with `register_option("my_option", int, default=3)`.
+
+## The Behavior System
+
+Every editor feature beyond basic text editing is implemented as a **Behavior**. Behaviors are essentially just plugins. They are modular, self-contained classes that plug into the editor through a well-defined interface.
+
+### Base Class
+
+All behaviors inherit from `Behavior`:
+
+```python
+from QCodeSitter.behaviors import Behavior
+
+class MyBehavior(Behavior):
+    def __init__(self, editor):
+        super().__init__(editor)
+        # self.editor  - the CodeEditor instance
+        # self.options  - the EditorOptions dict-like object
+        # Signals connected with self.connect are disconnected when it's removed
+        self.connect(editor.textChanged, self.on_text_changed)
+
+    def on_text_changed(self):
+        ...
+
+    def on_remove(self):
+        # Undo anything else done in __init__. This runs after the
+        # signals connected with self.connect are disconnected
+```
+
+Behaviors are added and removed at runtime:
+
+```python
+behavior = editor.add_behavior(MyBehavior)  # Replaces any existing MyBehavior
+editor.remove_behavior(MyBehavior)          # Returns the removed instance
+editor.get_behavior(MyBehavior)             # Returns the instance or None
+```
+
+### Reacting to Option Changes
+
+Every option except `"language"` and `"font"` always has a value, so a behavior can read a
+setting from `self.options` when it needs it. For a setting that needs work when it changes,
+register a handler. Handlers are called with the option's value right away, and again
+whenever it changes. The handlers of `"language"` and `"font"` wait until they are set:
+
+```python
+class MyBehavior(Behavior):
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.font = QtGui.QFont()  # The default until the option is set
+        self.watch_options({"font": self.set_font})
+
+    def set_font(self, font):
+        self.font = font
+```
+
+Parsing and highlighting are the expensive part of an editor, so the editor only sets its
+language when it is first shown. Call `editor.load()` to set it for an editor you don't show.
+
+### Keys, Painting and Signals
+
+- Override `handle_key_press(event)` to get key presses before the editor's own key
+  handling, and return `True` from it to consume the key. Behaviors with a higher
+  `KEY_PRIORITY` get the keys first, like `TabCompletion`, so Tab accepts a completion
+  before `SmartIndent` indents.
+- Return actions from `get_hotkeys` to add keyboard shortcuts to the editor.
+- Connect to `editor.behaviorPaint(event, painter)` to paint over the text.
+- Connect to `editor.cursors.changed`, `editor.tree_manager.reparsed`, or
+  `editor.undoRedoFinished` to react to the editor.
+- Subclass `GutterWidget` (in `gutters.py`) for a column beside the text, like line numbers.
+
+### Languages
+
+Language-specific knowledge (comment prefix, indent rules, foldable node types, and the
+highlight and identifier queries) lives in a `LanguageSpec`, looked up from the editor's
+tree-sitter language. Add a language by registering a spec for its grammar name:
+
+```python
+from QCodeSitter.languages import LanguageSpec, register_language
+
+register_language(LanguageSpec("lua", comment_prefix="-- "))
+```
+
+## Built-in Behaviors
+
+| Behavior | Description |
+|---|---|
+| `SyntaxHighlighting` |  Tree-sitter-based syntax highlighting with incremental updates |
+| `SmartIndent` |  Language-aware auto-indentation on Enter, Tab, Backspace |
+| `LineNumbers` | Line number gutter |
+| `AutoBracket` | Auto-close brackets, quotes, and parens; selection wrapping |
+| `TabCompletion` | Autocomplete popup with pluggable providers |
+| `CodeFolding` | Tree-sitter-based code folding with gutter indicators |
+| `CommentToggle` | Toggle line comments (Ctrl+/) with language detection |
+| `HighlightMatchingBrackets` | Highlight matching bracket/paren/brace pairs |
+| `HighlightMatchingSelection` | Highlight all occurrences of selected text |
+| `MultiCursorPaint` | Render primary and secondary cursors |
+| `Overscroll` | Allow scrolling past end of document |
+
+## Multi-Cursor Editing
+
+The editor has built-in multi-cursor support. All text operations (insert, delete, indent, comment, etc.) apply to every cursor simultaneously.
+
+**Default bindings:**
+- **Ctrl+D** -- Select next occurrence of current selection
+- **Ctrl+Alt+Up/Down** -- Add cursor above/below
+- **Ctrl+Shift+L** -- Add cursors to all line ends in selection
+- **Alt+Click** -- Add cursor at mouse position
+- **Escape** -- Exit multi-cursor mode
+
+Behaviors that modify text across multiple cursors use the editor's `CursorIterator`.
+It moves one cursor to each cursor in turn, and shifts the later cursors by however much
+each edit changed the document:
+
+```python
+def my_multi_cursor_operation(self):
+    citer = self.editor.citer
+    with self.editor.edit_session():  # One undo step, and one reparse
+        for cursor in citer.iterate_cursors(complete_all=True):
+            cursor.insertText("hello")
+```
+
+`complete_all=True` marks every cursor completed, which stops later key handlers in the
+same edit session from editing them. A pass that handles only some cursors calls
+`citer.mark_cursor_completed()` inside the loop for each one it handled instead.
+
+## Tree-Sitter Integration
+
+QCodeSitter uses tree-sitter for parsing, with UTF-16 encoding throughout to match Qt's internal string representation. The `TreeManager` provides:
+
+- Incremental parsing (only re-parses changed regions)
+- A `reparsed` signal for loose coupling between components
+- Pause/unpause to batch edits (e.g., during multi-cursor operations)
+
+The `TrackedDocument` (a `QTextDocument` subclass) and `TrackedCursor` (a `QTextCursor` subclass) automatically track UTF-16 byte offsets and emit change signals that keep the parse tree in sync.
+
+### Dependencies
+
+- Python 3.10+
+
+- [Qt.py](https://github.com/mottosso/Qt.py), and a Qt binding for it. The tests run on
+  PySide6 (`tox`) and PyQt6 (`tox -e pyqt6`); PySide2 and PyQt5 are untested.
+  `pip install QCodeSitter[pyside6]` installs PySide6
+- [tree-sitter](https://github.com/tree-sitter/py-tree-sitter)
+- A tree-sitter language grammar (e.g., `tree-sitter-python`)
+
+### Running Tests
+
+Tests are set up to be run with `tox`, and `tox -e fuzz` runs the slower Hypothesis fuzz
+tests. `python examples/demo.py` opens a window with the default editor.
+

qcodesitter-0.1.0.dist-info/RECORD

@@ -0,0 +1,49 @@
+QCodeSitter/__init__.py,sha256=u2ZKpX2OaFRJy50392y0H4Kz-qLzFO-_zHQ8ZUEHkLw,1049
+QCodeSitter/code_editor.py,sha256=Q2lmfNSpfDsozWl30RXMJaeKVK-32UUHgh-7mVLp5A8,20722
+QCodeSitter/defaults.py,sha256=c4XsoqzxjjHQCX20euJOOialchP1PFPr4dVS_2BJRjo,3189
+QCodeSitter/editing_keys.py,sha256=ymfBrv6_cIajqQhYZClhEiNbUE3ULBEutWNKV0jnAYU,5479
+QCodeSitter/editor_options.py,sha256=YzWz9Ash2xhGUMzYwma6rsIhc8hVSZITxBLgVyIvnzo,9155
+QCodeSitter/gui_colors.py,sha256=7zDN8rCSLGfvG-p5G-RhsgF2qeT07pScPNSFxgRiYi8,1632
+QCodeSitter/gutters.py,sha256=lSANpJ_jV5IjAwWU1AD76ApbFOpIGQo9c11eNba-A9g,5149
+QCodeSitter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QCodeSitter/syntax_specs.py,sha256=kKj8devqE7A35v5V-Zz2B9IR-aAUejF5cTokAsfpCxo,1863
+QCodeSitter/themes.py,sha256=zSmY_96Y9tbCBjJcLC91_3VRz8DyfcLzmLEMUXJECT4,10553
+QCodeSitter/tracked_document.py,sha256=LeT3MQV7POmu3ciWFH8NOClxtvP3WDPN1TBDlxXI6hQ,4185
+QCodeSitter/tree_manager.py,sha256=ByJshn4OpG0-nm2cgRFMaNhpKrKb45PD4j1vElWf-vw,6566
+QCodeSitter/utils.py,sha256=WSUJS0J-jpAl10C6BDM1GUC8K8TIPa3ZMHjqDMi7Bcw,2836
+QCodeSitter/behaviors/__init__.py,sha256=3aYqispH47Nm0FCWKpG-VECO54nhr2Oz7ji7IoTIug8,4435
+QCodeSitter/behaviors/auto_bracket.py,sha256=3harFJwMbGZ2T0MDfa3gyi8bfRIe4YKzMdAOSRaXdk4,6000
+QCodeSitter/behaviors/code_folding.py,sha256=DAxWaikUjvMa0BNEXKUDng_vLeVx4NmLi4R72SIqMxg,20993
+QCodeSitter/behaviors/comment_toggle.py,sha256=XUek0SMBQr2g2v_wevSO2arOQAURmUAs9xITKEa638Q,2651
+QCodeSitter/behaviors/highlight_matching_brackets.py,sha256=tIEGGEC9asyLsJbnR1A_WJuIbQeESCLmLI5QcVwUBkQ,6843
+QCodeSitter/behaviors/highlight_matching_selection.py,sha256=pu02vImwgOIhccT2cNaq_AjNSkiZs4Z41aldbpj8NhY,2132
+QCodeSitter/behaviors/line_numbers.py,sha256=lJAdtKYOnQ95qWZob04LxNTNZ9OUiF07oWE4K4sXIvw,1515
+QCodeSitter/behaviors/multi_cursor_paint.py,sha256=yXIoqsQcvc3cIt_9PszUPr8FI72XX-uL0SGZDOKyA0U,4882
+QCodeSitter/behaviors/overscroll.py,sha256=HR5UnGsUAZ5G9K328Kcs2d10tMFNdlSC9rnVkBFc65Q,3668
+QCodeSitter/behaviors/smart_indent.py,sha256=nFSt6DLgs5moCrqR1IP-GFyFRubiuqa3Ts89y6Ug5GE,7318
+QCodeSitter/behaviors/syntax_highlighting.py,sha256=4XHqQV2sNPgejvD3udpQcrmG2rIhx7I6XoAatkk_ImA,6912
+QCodeSitter/behaviors/tab_completion/__init__.py,sha256=UHTxuDE4bKSYHe4Rv0oWkETQQNh541qC0YJIHO5jOds,9727
+QCodeSitter/behaviors/tab_completion/popup.py,sha256=9VYrVY7qcvb0Nwl94xvT8PF8UozFskGtaAatct8Kjo4,4736
+QCodeSitter/behaviors/tab_completion/providers.py,sha256=ZzhKWSObN26SZeDiA4EA3e-h7Hj6NZA6wHH_y5BJLZg,1939
+QCodeSitter/behaviors/tab_completion/types.py,sha256=otKxLkbTQ_4wQW-aNJZFSXR8kMuEU8ILVC47DFYE5ss,1596
+QCodeSitter/cursors/__init__.py,sha256=d8phNVVxae75vWmZqXDWPc3E3pXZqna3jH1Hv_iMnLQ,402
+QCodeSitter/cursors/clipboard.py,sha256=598AvQup3Nfoxc9RRgh4mnIDSbcfmQLJLqCQrlLwUmU,1664
+QCodeSitter/cursors/iterator.py,sha256=pwcOY3sL1aeuxlCuRx7FrDbRVWVsEJskQdHH1EPfy8g,5413
+QCodeSitter/cursors/line_edits.py,sha256=NboxU7VC1rRJ1o79ZMjyqQdWPWHCl3jlq-spmzBdsXs,4758
+QCodeSitter/cursors/multi.py,sha256=UCOOcxD2vnzb260Gu9Z4sxw0nsTI5Fw-_rKdOdkHtlA,9390
+QCodeSitter/cursors/state.py,sha256=ZGXHaSD5TtzPS3TrlRCYHVLeSWEPLvsBuoyZq1ZgHSI,1627
+QCodeSitter/cursors/tracked.py,sha256=KDpwbE1EdYnSQSnhWSHX3WjKgkcECBGLQsH42vQBkhI,3504
+QCodeSitter/integrations/__init__.py,sha256=Vp-GRSU_mu_GcyvUUZElZdkuHNfKKlRJclHwRfZwRJY,58
+QCodeSitter/integrations/preditor_interface.py,sha256=0hFyXmfOjjsiM3S4joSc57ClxzV7KZ5iwkVXYyZg4a4,16882
+QCodeSitter/languages/__init__.py,sha256=tLNi-mc32oeiw-mg0UFlQC92bWnMaVzQZvnMZgQ00cE,3227
+QCodeSitter/languages/base.py,sha256=S9Q4AzzBV4sBRBHciXoPkup6T4jeyLZ58QMJ_sy0ImI,2317
+QCodeSitter/languages/python.py,sha256=yvqekgHuMp2N4gior7PhUu41jeb84qgRzkMLWgS4ENw,4877
+QCodeSitter/languages/python_highlights.py,sha256=CYPisXS8sKxwc0SHESa_tnfJrOqcpK3P0DkqjwnGUoo,8942
+QCodeSitter/queries/__init__.py,sha256=rR-qVuwzxQXWvtOaS6WQ6gOpBLClEPFg3Sk1XX5j_4s,2448
+QCodeSitter/queries/predicates.py,sha256=L5Upo7ckUUDc5Hf6-z2Ow7lI9TyI_ue-MfOBnYxAdKw,5551
+qcodesitter-0.1.0.dist-info/licenses/LICENSE.txt,sha256=XXQgakqrJQxGWQswReIWcVZtUCuvnymgmuqPCZSL57w,1057
+qcodesitter-0.1.0.dist-info/METADATA,sha256=n3moGn42Et59TdET92-7jP_e_D4wo6Hm_rJMM4mLVzo,10316
+qcodesitter-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+qcodesitter-0.1.0.dist-info/entry_points.txt,sha256=7hsyL7EWMH_L4Za4fJxpeiDT-XXrmVAIhDl8a496EpQ,101
+qcodesitter-0.1.0.dist-info/top_level.txt,sha256=nDTbAjVeu-WCu_x7FIIs_tqR1jtl2lm_9yFDhtMJ8v4,12
+qcodesitter-0.1.0.dist-info/RECORD,,

qcodesitter-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qcodesitter-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[preditor.plug.editors]
+QCodeSitter = QCodeSitter.integrations.preditor_interface:CodeSitterTextEdit

qcodesitter-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2026 Tyler Fox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

qcodesitter-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+QCodeSitter