spiceditor 0.0.4__py3-none-any.whl

spiceditor-0.0.4.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.2
+Name: spiceditor
+Version: 0.0.4
+Summary: Spice is a Python IDE for students
+Home-page: https://github.com/dantard/coder
+Author: Danilo Tardioli
+Author-email: dantard@unizar.es
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyqt5
+Requires-Dist: pymupdf>=1.18.17
+Requires-Dist: autopep8
+Requires-Dist: scipy
+Requires-Dist: qtconsole
+Requires-Dist: termqt
+Requires-Dist: easyconfig2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# coder

spiceditor-0.0.4.dist-info/RECORD

@@ -0,0 +1,51 @@
+pyspice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyspice/dialogs.py,sha256=JBDQHtIRbZTy_Wn3Pw-0Jz9Yqm7ogpLehN62Q19papo,2594
+pyspice/editor_widget.py,sha256=kjP7sOObIgfXr-QfTc9RfoLOJYzGXhc5FjNUccXgahw,7136
+pyspice/file_browser.py,sha256=BFLySZLCOiaHa4R3wd-YfO0KZaoIscXDMurutR62WoI,5445
+pyspice/highlighter.py,sha256=YCvi766plweJFAkQy13v_C1_eMf473lszmaUTSTeDJU,3456
+pyspice/line_number_text_edit.py,sha256=Seu2UJMViSuVsC4BcVOmgMacu3HtToLjtA880HsWQDM,1957
+pyspice/magic_scrollbar.py,sha256=keB1CHyL84AuT6wK6USw4O330QtRJT3SqiVAR4Yw92I,317
+pyspice/main.py,sha256=lFG2SYqkGIq3OG2TThp8jemocPaS0w4XCBOPInQ8rbU,16555
+pyspice/resources.py,sha256=xKoh41jZmnzaFkc1nqBIkvTGzUVVHGNQp7mO7np7Jcw,62386
+pyspice/spice_console.py,sha256=fY226U4hvKhbfz-gMq0dZvmsK5jL1novXyuYr_vqkn8,8705
+pyspice/spice_magic_editor.py,sha256=lgZjaFQyLgkdDVQj84l3DHLvihhOQbCJP4qQoUcWOVY,13414
+pyspice/splitter.py,sha256=nNkkbjdZBUbe2BgYRVMo-lJ4LCxtovbTUB9rYyvxGR0,3959
+pyspice/term.py,sha256=nf-FK7ubYbd5kPM-iW8r82dKl_5bxPTw8isEqT5NqlM,2170
+pyspice/textract.py,sha256=G0J_c1Rh-ZNrn63rmqAIPv4YQn3A2U9Zt5KYelAKgxQ,20847
+pyspice/utils.py,sha256=oTgvP42KzMaEiu8HwpuM34A6TdBzs_IimkfAm8Kdqy0,1043
+spiceditor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiceditor/dialogs.py,sha256=JBDQHtIRbZTy_Wn3Pw-0Jz9Yqm7ogpLehN62Q19papo,2594
+spiceditor/editor_widget.py,sha256=kjP7sOObIgfXr-QfTc9RfoLOJYzGXhc5FjNUccXgahw,7136
+spiceditor/file_browser.py,sha256=BFLySZLCOiaHa4R3wd-YfO0KZaoIscXDMurutR62WoI,5445
+spiceditor/highlighter.py,sha256=YCvi766plweJFAkQy13v_C1_eMf473lszmaUTSTeDJU,3456
+spiceditor/line_number_text_edit.py,sha256=Seu2UJMViSuVsC4BcVOmgMacu3HtToLjtA880HsWQDM,1957
+spiceditor/magic_scrollbar.py,sha256=keB1CHyL84AuT6wK6USw4O330QtRJT3SqiVAR4Yw92I,317
+spiceditor/main.py,sha256=lFG2SYqkGIq3OG2TThp8jemocPaS0w4XCBOPInQ8rbU,16555
+spiceditor/resources.py,sha256=xKoh41jZmnzaFkc1nqBIkvTGzUVVHGNQp7mO7np7Jcw,62386
+spiceditor/spice_console.py,sha256=fY226U4hvKhbfz-gMq0dZvmsK5jL1novXyuYr_vqkn8,8705
+spiceditor/spice_magic_editor.py,sha256=lgZjaFQyLgkdDVQj84l3DHLvihhOQbCJP4qQoUcWOVY,13414
+spiceditor/splitter.py,sha256=nNkkbjdZBUbe2BgYRVMo-lJ4LCxtovbTUB9rYyvxGR0,3959
+spiceditor/term.py,sha256=nf-FK7ubYbd5kPM-iW8r82dKl_5bxPTw8isEqT5NqlM,2170
+spiceditor/textract.py,sha256=G0J_c1Rh-ZNrn63rmqAIPv4YQn3A2U9Zt5KYelAKgxQ,20847
+spiceditor/utils.py,sha256=oTgvP42KzMaEiu8HwpuM34A6TdBzs_IimkfAm8Kdqy0,1043
+spyce/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spyce/dialogs.py,sha256=JBDQHtIRbZTy_Wn3Pw-0Jz9Yqm7ogpLehN62Q19papo,2594
+spyce/editor_widget.py,sha256=kjP7sOObIgfXr-QfTc9RfoLOJYzGXhc5FjNUccXgahw,7136
+spyce/file_browser.py,sha256=BFLySZLCOiaHa4R3wd-YfO0KZaoIscXDMurutR62WoI,5445
+spyce/highlighter.py,sha256=YCvi766plweJFAkQy13v_C1_eMf473lszmaUTSTeDJU,3456
+spyce/line_number_text_edit.py,sha256=Seu2UJMViSuVsC4BcVOmgMacu3HtToLjtA880HsWQDM,1957
+spyce/magic_scrollbar.py,sha256=keB1CHyL84AuT6wK6USw4O330QtRJT3SqiVAR4Yw92I,317
+spyce/main.py,sha256=lFG2SYqkGIq3OG2TThp8jemocPaS0w4XCBOPInQ8rbU,16555
+spyce/resources.py,sha256=xKoh41jZmnzaFkc1nqBIkvTGzUVVHGNQp7mO7np7Jcw,62386
+spyce/spice_console.py,sha256=fY226U4hvKhbfz-gMq0dZvmsK5jL1novXyuYr_vqkn8,8705
+spyce/spice_magic_editor.py,sha256=lgZjaFQyLgkdDVQj84l3DHLvihhOQbCJP4qQoUcWOVY,13414
+spyce/splitter.py,sha256=nNkkbjdZBUbe2BgYRVMo-lJ4LCxtovbTUB9rYyvxGR0,3959
+spyce/term.py,sha256=nf-FK7ubYbd5kPM-iW8r82dKl_5bxPTw8isEqT5NqlM,2170
+spyce/textract.py,sha256=G0J_c1Rh-ZNrn63rmqAIPv4YQn3A2U9Zt5KYelAKgxQ,20847
+spyce/utils.py,sha256=oTgvP42KzMaEiu8HwpuM34A6TdBzs_IimkfAm8Kdqy0,1043
+spiceditor-0.0.4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+spiceditor-0.0.4.dist-info/METADATA,sha256=3260QlOYYk4kXBtyRhpwBWZ4pS1TQZhgj2sjBCq7Mnk,808
+spiceditor-0.0.4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+spiceditor-0.0.4.dist-info/entry_points.txt,sha256=k_0k6GoBCxu8EvSVHUfvYHaZg_PTLWLSVSIos9gSI2E,52
+spiceditor-0.0.4.dist-info/top_level.txt,sha256=V4z_TZf9P3ZulfhkBfljhrwZp6CkBDnCO5-lWkYvGm8,11
+spiceditor-0.0.4.dist-info/RECORD,,

spiceditor-0.0.4.dist-info/WHEEL

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

spiceditor-0.0.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+spiceditor = spiceditor.main:main

spiceditor-0.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+spiceditor

spyce/dialogs.py

@@ -0,0 +1,103 @@
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QPushButton, QTextEdit, QVBoxLayout, QDialog
+
+
+
+class Author(QDialog):
+    def __init__(self):
+        super().__init__()
+        self.setLayout(QVBoxLayout())
+        self.setMinimumSize(400, 350)
+        self.setWindowTitle("About")
+        textEdit = QTextEdit()
+        textEdit.setReadOnly(True)
+        textEdit.setHtml("""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>SPICE - About</title>
+    <style>
+        body {
+            font-family: 'Arial', sans-serif;
+            background-color: #f4f4f9;
+            color: #333;
+            margin: 0;
+            padding: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            text-align: center;
+        }
+
+        .container {
+            background-color: #ffffff;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+            width: 80%;
+            max-width: 600px;
+        }
+
+        h1 {
+            font-size: 3em;
+            color: #2c3e50;
+            margin-bottom: 20px;
+        }
+
+        p {
+            font-size: 1.2em;
+            line-height: 1.6;
+        }
+
+        ul {
+            list-style: none;
+            padding: 0;
+        }
+
+        ul li {
+            font-size: 1.1em;
+            margin: 5px 0;
+        }
+
+        .footer {
+            font-size: 1em;
+            color: #7f8c8d;
+            margin-top: 20px;
+        }
+
+        .footer p {
+            margin: 0;
+        }
+
+    </style>
+</head>
+<body>
+
+    <div class="container">
+        <h1>Spice</h1>
+        <h2><strong>Slides and Python for Interactive and Creative Education</strong></h2>
+
+        <h4><strong>Developed by:</strong></h4>
+            <h2>Danilo Tardioli</h2>
+            <h3>Email: <a href="mailto:dantard@unizar.es">dantard@unizar.es</a></h3>
+
+        <p><strong>Year:</strong> 2024</p>
+
+        <div class="footer">
+            <p><strong>Learn more at:</strong> <a href="https://github.com/dantard/coder">https://github.com/dantard/coder</a></p>
+        </div>
+    </div>
+
+</body>
+</html>
+
+        """)
+        self.layout().addWidget(textEdit)
+        close_button = QPushButton("Close")
+        close_button.setMaximumWidth(100)
+        # center the button
+        self.layout().addWidget(close_button)
+        self.layout().setAlignment(close_button, Qt.AlignRight)
+        close_button.clicked.connect(self.close)

spyce/editor_widget.py

@@ -0,0 +1,196 @@
+import os
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QFont, QIcon
+from PyQt5.QtWidgets import QVBoxLayout, QToolBar, QStatusBar, QWidget, QComboBox, QShortcut, QTabWidget, QFileDialog, \
+    QApplication, QDialog, QMessageBox
+from spiceditor import utils
+
+import spiceditor.resources  # noqa
+
+
+class DynamicComboBox(QComboBox):
+    def __init__(self, folder=None, parent=None):
+        super().__init__(parent)
+        self.folder = folder
+        self.populate()
+
+    def set_folder(self, folder):
+        self.folder = folder
+        self.populate()
+
+
+    def populate(self, item=None):
+        self.blockSignals(True)
+        self.clear()  # Clear the current items
+        self.addItem("[Free Coding]")
+        if self.folder is not None and os.path.exists(self.folder):
+            files = list(x for x in os.listdir(self.folder) if x.endswith(".py"))
+
+            files = [f for f in files if os.path.isfile(os.path.join(self.folder, f))]
+            files.sort()
+            self.addItems(files)
+            if item is not None:
+                index = self.findText(item)
+                if index >=0:
+                    self.setCurrentIndex(index)
+            self.blockSignals(False)
+
+
+
+class EditorWidget(QWidget):
+
+    def __init__(self, language_editor, console, config):
+        super().__init__()
+        self.path = None
+        self.config = config
+        editor = config.root().getSubSection("editor", pretty="Editor")
+        self.cfg_keep_code = editor.getCheckBox("keep_code",
+                            pretty="Keep Code on Run",
+                            default=False)
+        self.cfg_show_all = editor.getCheckBox("show_all",
+                            pretty="Show all Code on Open",
+                            default=False)
+        self.cfg_autocomplete = editor.getString("autocomplete",
+                                                  pretty="Autocomplete",
+                                                  default="")
+        self.cfg_delay = editor.getSlider("delay",
+                                           pretty="Delay",
+                                           min=0, max=100,
+                                           default=25,
+                                           den=1,
+                                           show_value=True,
+                                           suffix=" ms")
+
+        self.cfg_show_sb = editor.getCheckBox("show_tb",
+                                               pretty="Show Toolbar",
+                                               default=False)
+
+
+        self.language_editor = language_editor
+        self.console = console
+
+        # Left side layout
+        left_layout = QVBoxLayout()
+
+        self.language_editor.ctrl_enter.connect(self.execute_code)
+        self.language_editor.info.connect(self.update_status_bar)
+
+        bar = QToolBar()
+
+        a1 = bar.addAction("Play", self.execute_code)
+        a2 = bar.addAction("Clear", self.clear)
+        a3 = bar.addAction("Show", self.language_editor.show_code)
+
+        self.keep_banner = bar.addAction("Keep Code on Console")
+        self.keep_banner.setCheckable(True)
+        self.keep_banner.setChecked(False)
+
+        self.show_all =  bar.addAction("Show all Code on Load")
+        self.show_all.setIcon(QIcon(":/icons/radio-button.svg"))
+        self.show_all.setCheckable(True)
+
+        self.text_edit_group = [a1, a2, a3, self.keep_banner]
+        bar.addSeparator()
+
+        left_layout.addWidget(bar)
+        left_layout.addWidget(self.language_editor)
+
+        self.sb = QStatusBar()
+        left_layout.addWidget(self.sb)
+        left_layout.setSpacing(0)
+
+        self.setLayout(left_layout)
+        self.setLayout(left_layout)
+
+    def update_config(self):
+        self.keep_banner.setChecked(self.cfg_keep_code.get())
+        self.show_all.setChecked(self.cfg_show_all.get())
+        self.language_editor.append_autocomplete(self.cfg_autocomplete.get())
+        self.language_editor.set_delay(self.cfg_delay.get())
+        self.language_editor.set_font_size(self.config.font_size.get() + 10)
+
+    def set_font_size(self, font_size):
+        self.language_editor.set_font_size(font_size)
+        self.console.set_font_size(font_size)
+
+    def load_program(self, path, show_all=False):
+        self.path = path
+        with open(path) as f:
+            self.language_editor.set_code(f.read())
+            self.console.clear()
+
+        if self.show_all.isChecked() or show_all:
+            self.show_all_code()
+
+    def save_program(self, path, save_as):
+        if self.path is None or save_as:
+            ext = self.console.get_file_extension()
+            filename, ok = QFileDialog.getSaveFileName(self, "Save code", filter="Language files (*" + ext + ")",
+                                                       directory=path)
+            if not filename:
+                return
+
+            self.path = filename.replace(".py","") + ".py"
+
+        with open(self.path, "w") as f:
+            f.write(self.language_editor.toPlainText())
+
+        name = os.path.basename(self.path)
+        tab_wiget: QTabWidget = self.parent().parent()  # noqa
+        index = tab_wiget.indexOf(self)
+        tab_wiget.setTabText(index, name)
+        self.sb.showMessage("Saved in " + self.path, 2000)
+
+    def clear(self):
+        self.language_editor.clear()
+        # self.console_widget.clear()
+
+    def execute_code(self):
+        self.language_editor.format_code()
+        self.console.execute(self.language_editor.toPlainText(), not self.keep_banner.isChecked())
+
+    def set_dark_mode(self, dark):
+        self.language_editor.set_dark_mode(dark)
+        color = Qt.white if dark else Qt.black
+        a1, a2, a3, a4 = self.text_edit_group
+        a1.setIcon(QIcon(utils.color(":/icons/play.svg", color)))
+        a2.setIcon(QIcon(utils.color(":/icons/refresh.svg", color)))
+        a3.setIcon(QIcon(utils.color(":/icons/download.svg", color)))
+        a4.setIcon(QIcon(utils.color(":/icons/hash.svg", color)))
+
+    def get_text(self):
+        self.language_editor.format_code()
+        return self.language_editor.text_edit.toPlainText()
+
+    def get_font_size(self):
+        return self.language_editor.font().pixelSize()
+
+    def append_autocomplete(self, value, val):
+        self.language_editor.append_autocomplete(value, val)
+
+    def set_delay(self, value):
+        self.language_editor.set_delay(value)
+
+    def show_all_code(self):
+        self.language_editor.show_all_code()
+
+    def set_progs_path(self, path):
+        value = self.prog_cb.currentText()
+        self.prog_cb.set_folder(path)
+        self.populate_progs()
+        self.prog_cb.setCurrentIndex(self.prog_cb.findText(value))
+
+    def update_status_bar(self, x, diff, timeout):
+        if self.cfg_show_sb.get_value():
+            if timeout != 0:
+                x = "{:5d} | {}".format(diff, x)
+                self.sb.showMessage(x, 1000)
+            else:
+                self.sb.showMessage(x)
+
+            # red if diff is negative
+            if diff < 10:
+                self.sb.setStyleSheet("color: red")
+            else:
+                self.sb.setStyleSheet("color: black")

spyce/file_browser.py

@@ -0,0 +1,143 @@
+import os
+import shutil
+
+from PyQt5 import QtGui
+from PyQt5.QtCore import QObject, pyqtSignal, QDir, QItemSelectionModel, QModelIndex, Qt
+from PyQt5.QtWidgets import QWidget, QTreeView, QFileSystemModel, QVBoxLayout, QPushButton, QHBoxLayout, QLabel, QMenu, QMessageBox, QToolBar, QInputDialog
+
+
+class Tree(QTreeView):
+    delete_requested = pyqtSignal(str)
+
+    def filter_rows(self):
+        for i in range(self.model().rowCount(self.rootIndex())):
+            child_index = self.model().index(i, 0, self.rootIndex())  # Get index of each row
+            filename = self.model().data(child_index)  # Get file name
+            if filename == "__pycache__":
+                self.setRowHidden(i, self.rootIndex(), True)
+
+    def contextMenuEvent(self, a0: QtGui.QContextMenuEvent) -> None:
+        super().contextMenuEvent(a0)
+        indexes = self.selectedIndexes()
+        if indexes:
+            index = self.indexAt(a0.pos())
+            if index.isValid():
+                dirModel = self.model()
+                path = dirModel.fileInfo(index).absoluteFilePath()
+                menu = QMenu()
+                delete = menu.addAction("Delete")
+                res = menu.exec_(self.viewport().mapToGlobal(a0.pos()))
+                if res == delete:
+                    self.delete_requested.emit(path)
+
+
+class FileBrowser(QWidget):
+    class Signals(QObject):
+        file_selected = pyqtSignal(str)
+
+    def __init__(self, path, filters=None, hide_details=True):
+        super().__init__()
+        if filters is None:
+            filters = ["*.pdf"]
+        self.signals = self.Signals()
+        self.path = path
+        self.treeview = Tree()
+        self.treeview.delete_requested.connect(self.delete_requested)
+        self.dirModel = QFileSystemModel()
+        self.dirModel.directoryLoaded.connect(self.treeview.filter_rows)
+        self.dirModel.setNameFilters(filters)
+        self.dirModel.setNameFilterDisables(False)
+
+        self.treeview.setModel(self.dirModel)
+        self.treeview.setRootIndex(self.dirModel.setRootPath(path))
+
+        vlayout = QVBoxLayout(self)
+        vlayout.setSpacing(0)
+        vlayout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(vlayout)
+        #tb = QToolBar()
+        #tb.addAction("🗀", self.refresh)
+
+        #vlayout.addWidget(tb)
+
+        self.layout().addWidget(self.treeview)
+        self.treeview.selectionModel().selectionChanged.connect(self.on_current_changed)
+        self.treeview.doubleClicked.connect(self.on_double_clicked)
+
+        if hide_details:
+            for i in range(1, self.treeview.model().columnCount()):
+                self.treeview.header().hideSection(i)
+
+    def delete_requested(self, path):
+        if QMessageBox.question(self, "Delete", f"Are you sure you want to delete {path}?", QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
+            return
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        else:
+            os.remove(path)
+
+
+    def on_double_clicked(self, index):
+        # Map the proxy index to the source model index
+        path = self.dirModel.fileInfo(index).absoluteFilePath()
+        if os.path.isdir(path):
+            return
+        self.signals.file_selected.emit(path)
+
+    def btn_up_clicked(self):
+        index = self.treeview.rootIndex()
+        if index.isValid():
+            index = index.parent()
+            self.set_root_index(index)
+
+    def set_root(self, path):
+        self.treeview.setRootIndex(self.dirModel.setRootPath(path))
+
+    def set_root_index(self, index):
+        self.treeview.setRootIndex(index)
+        path = self.dirModel.fileInfo(index).absoluteFilePath()
+        self.label.setText(path)
+
+    def select(self, filename, emit=True):
+        if not emit:
+            self.treeview.selectionModel().blockSignals(True)
+        index = self.dirModel.index(filename)
+        indices = []
+        while index.isValid():
+            indices.append(index)
+            index = index.parent()
+
+        for index in reversed(indices):
+            self.treeview.setExpanded(index, True)
+
+        self.treeview.setCurrentIndex(index)
+        self.treeview.selectionModel().blockSignals(False)
+
+    def on_current_changed(self, selected, deselected):
+        pass
+        # if deselected.indexes():
+        #     print("deselected1", deselected.indexes())
+        #     # Check if the deselected index is valid
+        #     for index in deselected.indexes():
+        #         if not os.path.isfile(self.dirModel.filePath(index)):
+        #             self.treeview.clearSelection()
+        #             return
+        #
+        # if selected is None or len(selected.indexes()) < 1:
+        #     return
+        # path = self.dirModel.fileInfo(selected.indexes()[0]).absoluteFilePath()
+        # # self.listview.setRootIndex(self.fileModel.setRootPath(path))
+        # if os.path.isfile(path):
+        #     self.signals.file_selected.emit(path)
+
+    def new_folder(self):
+        current_path = self.dirModel.rootPath()
+
+        # If the toolbar refresh button was clicked with no arguments,
+        # show the folder creation dialog
+        folder_name, ok = QInputDialog.getText(self, "Folder Name", "Enter the folder name")
+        if ok and folder_name:
+            new_folder_path = os.path.join(self.path, folder_name)
+            os.makedirs(new_folder_path, exist_ok=True)
+            self.dirModel.setRootPath("")
+            self.dirModel.setRootPath(current_path)

spyce/highlighter.py

@@ -0,0 +1,74 @@
+from PyQt5.QtCore import Qt, QRegExp
+from PyQt5.QtGui import QSyntaxHighlighter, QTextCharFormat, QColor, QFont
+
+
+class SyntaxHighlighter(QSyntaxHighlighter):
+
+    def __init__(self, keywords):
+        super().__init__(None)
+        self.highlighting_rules = []
+        self.keywords = keywords
+        self.keyword_color = Qt.blue
+        self.apply_scheme()
+
+    def set_dark_mode(self, dark):
+        self.keyword_color = Qt.cyan if dark else Qt.blue
+        self.highlighting_rules.clear()
+        self.apply_scheme()
+
+    def apply_scheme(self):
+        keyword_format = QTextCharFormat()
+        keyword_format.setForeground(self.keyword_color)
+        keyword_format.setFontWeight(QFont.Bold)
+
+        self.highlighting_rules += [(f"\\b{k}\\b", keyword_format) for k in self.keywords]
+
+        string_format = QTextCharFormat()
+        string_format.setForeground(Qt.magenta)
+        self.highlighting_rules.append((r'".*"', string_format))
+        self.highlighting_rules.append((r"'.*'", string_format))
+
+        comment_format = QTextCharFormat()
+        comment_format.setForeground(QColor("green"))
+        comment_format.setFontItalic(True)
+        self.highlighting_rules.append((r"#.*", comment_format))
+
+    def highlightBlock(self, text):
+        for pattern, fmt in self.highlighting_rules:
+            expression = QRegExp(pattern)
+            index = expression.indexIn(text)
+            while index >= 0:
+                length = expression.matchedLength()
+                self.setFormat(index, length, fmt)
+                index = expression.indexIn(text, index + length)
+
+    def get_keywords(self):
+        return self.keywords
+
+
+class PythonHighlighter(SyntaxHighlighter):
+    def __init__(self, dark=False):
+        super().__init__(['return', 'nonlocal', 'elif', 'assert', 'or', 'yield', 'finally',
+                          'from', 'global', 'del', 'print', 'None', 'pass', 'class', 'as',
+                          'break', 'while', 'await', 'async', 'range', 'is', 'True', 'lambda',
+                          'False', 'in', 'import', 'except', 'continue', 'and', 'raise', 'with',
+                          'if', 'try', 'for', 'else', 'not', 'def', "input", "int", "float", "str",
+                          "list", "dict", "input", "print", "open", "read", "write", "close", "split",
+                          ])
+
+
+class PascalHighlighter(SyntaxHighlighter):
+    def __init__(self, dark=False):
+        super().__init__([
+            "and", "array", "asm", "begin", "case", "const", "constructor", "destructor",
+            "div", "do", "downto", "else", "end", "file", "for", "function", "goto", "if",
+            "implementation", "in", "inherited", "inline", "interface", "label", "mod", "nil",
+            "not", "object", "of", "or", "packed", "procedure", "program", "record", "repeat",
+            "set", "shl", "shr", "string", "then", "to", "type", "unit", "until", "uses",
+            "var", "while", "with", "xor", "AND", "ARRAY", "ASM", "BEGIN", "CASE", "CONST", "CONSTRUCTOR", "DESTRUCTOR",
+            "DIV", "DO", "DOWNTO", "ELSE", "END", "FILE", "FOR", "FUNCTION", "GOTO", "IF",
+            "IMPLEMENTATION", "IN", "INHERITED", "INLINE", "INTERFACE", "LABEL", "MOD", "NIL",
+            "NOT", "OBJECT", "OF", "OR", "PACKED", "PROCEDURE", "PROGRAM", "RECORD", "REPEAT",
+            "SET", "SHL", "SHR", "STRING", "THEN", "TO", "TYPE", "UNIT", "UNTIL", "USES",
+            "VAR", "WHILE", "WITH", "XOR"
+        ])

spyce/line_number_text_edit.py

@@ -0,0 +1,54 @@
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QTextCursor, QTextCharFormat, QColor, QTextBlockFormat
+from PyQt5.QtWidgets import QTextEdit
+
+from spiceditor.magic_scrollbar import MagicScrollBar
+
+
+class LineNumberTextEdit(QTextEdit):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.line_highlighter_color = QColor(255, 255, 255, 100)
+        self.setReadOnly(True)
+        self.setLineWrapMode(QTextEdit.NoWrap)
+        self.setHorizontalScrollBar(MagicScrollBar())
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
+
+
+    def highlight_line(self, line_number):
+        cursor = self.textCursor()
+        position = cursor.position()
+        cursor.movePosition(QTextCursor.Start)
+
+        # Select all text and reset formatting
+        cursor.select(QTextCursor.Document)
+        default_format = QTextCharFormat()  # Default format (no highlights)
+        cursor.setCharFormat(default_format)
+
+        cursor.movePosition(QTextCursor.Start)
+        for _ in range(line_number):
+            cursor.movePosition(QTextCursor.Down)
+
+        cursor.select(QTextCursor.LineUnderCursor)
+
+        highlight_format = QTextCharFormat()
+        highlight_format.setBackground(self.line_highlighter_color)
+        cursor.setCharFormat(highlight_format)
+        cursor.setPosition(position)
+
+        # blockFmt = QTextBlockFormat()
+        # blockFmt.setLineHeight(40, QTextBlockFormat.FixedHeight)
+        #
+        # theCursor = self.textCursor()
+        # theCursor.clearSelection()
+        # theCursor.select(QTextCursor.Document)
+        # theCursor.mergeBlockFormat(blockFmt)
+
+    def set_line_highlighter_color(self, color):
+        self.line_highlighter_color = color
+        self.update()
+
+    def set_dark_mode(self, dark):
+        self.set_line_highlighter_color(
+            QColor(0, 0, 0, 50) if not dark else QColor(255, 255, 255, 100))

spyce/magic_scrollbar.py

@@ -0,0 +1,11 @@
+from PyQt5.QtGui import QPainter
+from PyQt5.QtWidgets import QScrollBar
+
+
+class MagicScrollBar(QScrollBar):
+    def paintEvent(self, a0) -> None:
+        super().paintEvent(a0)
+        if self.maximum() == 0:
+            p = QPainter(self)
+            p.fillRect(self.rect(), self.parent().palette().base().color())
+