suplemon-editor 0.3.0__py3-none-any.whl

suplemon/module_loader.py

@@ -0,0 +1,98 @@
+# -*- encoding: utf-8
+"""
+Addon module loader.
+"""
+import os
+import logging
+import importlib.util
+
+
+class ModuleLoader:
+    def __init__(self, app=None):
+        self.app = app
+        self.logger = logging.getLogger(__name__)
+        # The app root directory
+        self.curr_path = os.path.dirname(os.path.realpath(__file__))
+        # The modules subdirectory
+        self.module_path = os.path.join(self.curr_path, "modules" + os.sep)
+        # Module instances
+        self.modules = {}
+
+    def load(self):
+        """Find and load available modules."""
+        self.logger.debug("Loading modules...")
+        names = self.get_module_names()
+        for name in names:
+            module = self.load_single(name)
+            if module:
+                # Load and store the module instance
+                inst = self.load_instance(module)
+                if inst:
+                    self.modules[module[0]] = inst
+
+    def get_module_names(self):
+        """Get names of loadable modules."""
+        names = []
+        dirlist = os.listdir(self.module_path)
+        for item in dirlist:
+            # Skip 'hidden' dot files and files beginning with and underscore
+            if item.startswith((".", "_")):
+                continue
+            parts = item.split(".")
+            if len(parts) < 2:
+                # Can't find file extension
+                continue
+            name = parts[0]
+            ext = parts[-1]
+            # only load .py modules
+            if ext != "py":
+                continue
+            names.append(name)
+        return names
+
+    def load_instance(self, module):
+        """Initialize a module."""
+        try:
+            inst = module[1]["class"](self.app, module[0], module[1])  # Store the module instance
+            return inst
+        except Exception:
+            self.logger.error("Initializing module failed: {0}".format(module[0]), exc_info=True)
+        return False
+
+    def load_single(self, name):
+        """Load single module file."""
+        path = os.path.join(self.module_path, name+".py")
+        try:
+            spec = importlib.util.spec_from_file_location(name, path)
+            mod = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(mod)
+        except Exception:
+            self.logger.error("Failed loading module: {0}".format(name), exc_info=True)
+            return False
+        if "module" not in dir(mod):
+            return False
+        if "status" not in mod.module.keys():
+            mod.module["status"] = False
+        return name, mod.module
+
+    def extract_docs(self):
+        """Get names and docs of runnable modules and print as markdown."""
+        names = sorted(self.get_module_names())
+        for name in names:
+            name, module = self.load_single(name)
+            # Skip modules that can't be run expicitly
+            if module["class"].run.__module__ == "suplemon.suplemon_module":
+                continue
+            # Skip undocumented modules
+            if not module["class"].__doc__:
+                continue
+            docstring = module["class"].__doc__
+            docstring = "\n    " + docstring.strip()
+
+            doc = " * {0}\n{1}\n".format(name, docstring)
+            print(doc)
+
+
+if __name__ == "__main__":
+    ml = ModuleLoader()
+    ml.extract_docs()

suplemon/modules/application_state.py

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8
+
+
+import hashlib
+
+from suplemon.suplemon_module import Module
+
+
+class ApplicationState(Module):
+    """
+    Stores the state of open files when exiting the editor and restores when files are reopened.
+
+    Cursor positions and scroll position are stored and restored.
+    """
+
+    def init(self):
+        self.init_logging(__name__)
+        self.bind_event_after("app_loaded", self.on_load)
+        self.bind_event_before("app_exit", self.on_exit)
+
+    def on_load(self, event):
+        """Runs when suplemon is fully loaded."""
+        self.restore_states()
+
+    def on_exit(self, event):
+        """Runs before suplemon is exits."""
+        self.store_states()
+
+    def get_file_states(self):
+        """Get the state of currently opened files. Returns a dict with the file path as key and file state as value."""
+        states = {}
+        for file in self.app.get_files():
+            states[file.get_path()] = self.get_file_state(file)
+        return states
+
+    def get_file_state(self, file):
+        """Get the state of a single file."""
+        editor = file.get_editor()
+        state = {
+            "cursors": [cursor.tuple() for cursor in editor.cursors],
+            "scroll_pos": editor.scroll_pos,
+            "hash": self.get_hash(editor),
+        }
+        return state
+
+    def get_hash(self, editor):
+        # We don't need cryptographic security so we just use md5
+        h = hashlib.md5()
+        for line in editor.lines:
+            h.update(line.get_data().encode("utf-8"))
+        return h.hexdigest()
+
+    def set_file_state(self, file, state):
+        """Set the state of a file."""
+        cursor = file.editor.get_cursor()
+        # Don't set the cursor pos if it's not the default 0,0
+        if cursor.x or cursor.y:
+            return
+        file.editor.set_cursors(state["cursors"])
+        file.editor.scroll_pos = state["scroll_pos"]
+
+    def store_states(self):
+        """Store the states of opened files."""
+        states = self.get_file_states()
+        for path in states.keys():
+            self.storage[path] = states[path]
+        self.storage.store()
+
+    def restore_states(self):
+        """Restore the states of files that are currently open."""
+        for file in self.app.get_files():
+            path = file.get_path()
+            if path in self.storage.get_data().keys():
+                state = self.storage[path]
+                if "hash" not in state:
+                    self.set_file_state(file, state)
+                elif state["hash"] == self.get_hash(file.get_editor()):
+                    self.set_file_state(file, state)
+
+
+module = {
+    "class": ApplicationState,
+    "name": "application_state",
+}

suplemon/modules/autocomplete.py

@@ -0,0 +1,114 @@
+# -*- encoding: utf-8
+
+import re
+
+from suplemon import helpers
+from suplemon.suplemon_module import Module
+
+
+class AutoComplete(Module):
+    """
+    A simple autocompletion module.
+
+    This adds autocomplete support for the tab key. It uses a word
+    list scanned from all open files for completions. By default it suggests
+    the shortest possible match. If there are no matches, the tab action is
+    run normally.
+    """
+
+    def init(self):
+        self.word_list = []
+        self.bind_event("tab", self.auto_complete)
+        self.bind_event_after("app_loaded", self.build_word_list)
+        self.bind_event_after("save_file", self.build_word_list)
+        self.bind_event_after("save_file_as", self.build_word_list)
+
+    def get_separators(self):
+        """Return list of word separators obtained from app config.
+
+        :return: String with all separators.
+        :rtype: str
+        """
+        separators = self.app.config["editor"]["punctuation"]
+        # Support words with underscores
+        separators = separators.replace("_", "")
+        return separators
+
+    def build_word_list(self, *args):
+        """Build the word list based on contents of open files."""
+        word_list = []
+        # Membership is tracked in a set. Checking "word not in word_list"
+        # scans the whole list for every word in every open file, which is
+        # what made opening a large file take minutes.
+        seen = set()
+        for file in self.app.files:
+            data = file.get_editor().get_data()
+            words = helpers.multisplit(data, self.get_separators())
+            for word in words:
+                # Discard undesired whitespace
+                word = word.strip()
+                # Must be longer than 1 and not yet in word_list
+                if len(word) > 1 and word not in seen:
+                    seen.add(word)
+                    word_list.append(word)
+        self.word_list = word_list
+        return False
+
+    def get_match(self, word):
+        """Find a completable match for word.
+
+        :param word: The partial word to complete
+        :return: The completion to add to the partial word
+        :rtype: str
+        """
+        if not word:
+            return False
+        # Build list of suitable matches
+        candidates = []
+        for candidate in self.word_list:
+            if candidate.startswith(word) and len(candidate) > len(word):
+                candidates.append(candidate)
+        # Find the shortest match
+        # TODO: implement cycling through matches
+        shortest = ""
+        for candidate in candidates:
+            if not shortest:
+                shortest = candidate
+                continue
+            if len(candidate) < len(shortest):
+                shortest = candidate
+        if shortest:
+            return shortest[len(word):]
+        return False
+
+    def run(self, app, editor, args):
+        """Run the autocompletion."""
+        self.auto_complete()
+
+    def auto_complete(self, event):
+        """Attempt to autocomplete at each cursor position.
+
+        This callback runs before the tab action and tries to autocomplete
+        the current word. If a match is found the tab action is inhibited.
+
+        :param event: The event object.
+        :return: True if a match is found.
+        """
+        editor = self.app.get_editor()
+        pattern = "|".join(map(re.escape, self.get_separators()))
+        matched = False
+        for cursor in editor.cursors:
+            line = editor.lines[cursor.y][:cursor.x]
+            words = re.split(pattern, line)
+            last_word = words[-1]
+            match = self.get_match(last_word)
+            if match:
+                matched = True
+                editor.type_at_cursor(cursor, match)
+        return matched
+
+
+module = {
+    "class": AutoComplete,
+    "name": "autocomplete",
+}

suplemon/modules/autodocstring.py

@@ -0,0 +1,142 @@
+# -*- encoding: utf-8
+
+from suplemon import helpers
+from suplemon.suplemon_module import Module
+
+
+class AutoDocstring(Module):
+    """
+    Simple module for adding docstring placeholders.
+
+    This module is intended to generate docstrings for Python functions.
+    It adds placeholders for descriptions, arguments and return data.
+    Function arguments are crudely parsed from the function definition
+    and return statements are scanned from the function body.
+    """
+
+    def init(self):
+        self.init_logging(__name__)
+        self.default_values = {
+            "short_desc": "Short description.",
+            "long_desc": "Long description.",
+            "args": "",
+            "returns": "",
+        }
+        self.docstring_template = "{short_desc}\n" + \
+            "\n" + \
+            "{long_desc}\n" + \
+            "\n" + \
+            "{args}" + \
+            "{returns}"
+
+    def run(self, app, editor, args):
+        """Run the autosphinx command."""
+        cursor = editor.get_cursor()
+        line = editor.get_line(cursor.y)
+        line_data = line.get_data()
+        if not line_data.strip().startswith("def "):
+            app.set_status("Current line isn't a function definition.")
+            return False
+
+        func_args = self.get_function_args(line_data)
+        func_returns = self.get_function_returns(editor, cursor.y)
+        docstring = self.get_docstring(func_args=func_args, func_returns=func_returns)
+
+        indent = self.get_docstring_indent(line_data)
+        indent = indent * self.app.config["editor"]["tab_width"] * " "
+        self.insert_docstring(editor, cursor.y+1, indent, docstring)
+
+    def insert_docstring(self, editor, line_number, indent, docstring):
+        """Insert a docstring at a specific line.
+
+        Inserts the given docstring into editor at a specific
+        line and indentation.
+
+        :param editor: The editor to insert into
+        :param int line_number: The first line number
+        :param str indent: How much the docstring
+        :param str docstring: The actual docstring
+        """
+        docstring = '"""{0}"""'.format(docstring)
+        raw_lines = docstring.split("\n")
+        lines = []
+        for line in raw_lines:
+            if not line.strip():
+                lines.append("")
+            else:
+                lines.append(indent+line)
+        editor.insert_lines_at(lines, line_number)
+
+    def get_docstring_indent(self, line_data):
+        """Get indent amount for docstring.
+
+        Gets the indentation of the function definiton line, and
+        adds +1 to account for the function body.
+
+        :param line_data: The line of the function definition.
+        """
+        tab = self.app.config["editor"]["tab_width"]
+        wspace = helpers.whitespace(line_data)
+        indent = int(wspace/tab)+1
+        return indent
+
+    def get_docstring(self, **values):
+        for key in self.default_values.keys():
+            if key not in values.keys():
+                values[key] = self.default_values[key]
+
+        args = ""
+        for arg in values["func_args"]:
+            args += ":param {0}:\n".format(arg)
+        values["args"] = args
+
+        if values["func_returns"]:
+            values["returns"] = ":return:\n"
+
+        doc = self.docstring_template
+        doc = doc.format(**values)
+        return doc
+
+    def get_function_name(self, line_data):
+        """Get the name of function defined in line_data.
+
+        :param str line_data: The line containing the function definition.
+        """
+        return helpers.get_string_between("def ", "(", line_data)
+
+    def get_function_args(self, line_data):
+        """Get list of arguments for function
+
+        Parses a function definition in line_data and returns argument list.
+
+        :param str line_data: The line containing the function definition.
+        """
+        func_name = self.get_function_name(line_data)
+        raw_args = helpers.get_string_between(func_name+"(", "):", line_data)
+        parts = raw_args.split(",")
+        args = [part.strip() for part in parts]
+        if "self" in args:
+            args.pop(args.index("self"))
+        return args
+
+    def get_function_returns(self, editor, line_number):
+        """Returns True if function at line_number returns something.
+
+        :param editor: Editor instance to get lines from.
+        :param line_number: Line number of the function definition.
+        :return: Boolean indicating wether the function something.
+        """
+        for i in range(line_number+1, len(editor.lines)):
+            line = editor.get_line(i)
+            data = line.get_data().strip()
+            if data.startswith("def "):
+                break
+            if data.startswith("return "):
+                return True
+        return False
+
+
+module = {
+    "class": AutoDocstring,
+    "name": "autodocstring",
+}

suplemon/modules/battery.py

@@ -0,0 +1,118 @@
+# -*- encoding: utf-8
+
+import os
+import time
+import subprocess
+
+from suplemon import helpers
+from suplemon.suplemon_module import Module
+
+
+class Battery(Module):
+    """Shows remaining battery capacity in the top status bar if available."""
+
+    def init(self):
+        self.last_value = -1
+        self.checked = time.time()
+        self.interval = 60  # Seconds to wait until polling again
+
+    def value(self):
+        """Get the battery charge percent and cache it."""
+        if self.last_value == -1:
+            state = self.battery_status()
+        elif time.time()-self.checked > self.interval:
+            state = self.battery_status()
+        else:
+            return self.last_value
+        self.last_value = state
+        return state
+
+    def value_str(self):
+        """Return formatted value string to show in the UI."""
+        val = self.value()
+        if val:
+            if self.app.config["app"]["use_unicode_symbols"]:
+                return "\u26A1{0}%".format(str(val))
+            else:
+                return "BAT {0}%".format(str(val))
+        return ""
+
+    def get_status(self):
+        """Called by app when showing status bar contents."""
+        return self.value_str()
+
+    def battery_status(self):
+        """Attempts to get the battery charge percent."""
+        value = None
+        methods = [
+            self.battery_status_read,
+            self.battery_status_acpi,
+            self.battery_status_upower
+        ]
+        for m in methods:
+            value = m()
+            if value is not None:
+                break
+        return value
+
+    def battery_status_read(self):
+        """Get the battery status via proc/acpi."""
+        try:
+            path_info = self.readf("/proc/acpi/battery/BAT0/info")
+            path_state = self.readf("/proc/acpi/battery/BAT0/state")
+        except OSError:
+            return None
+        try:
+            max_cap = float(helpers.get_string_between("last full capacity:", "mWh", path_info))
+            cur_cap = float(helpers.get_string_between("remaining capacity:", "mWh", path_state))
+            return int(cur_cap / max_cap * 100)
+        except (TypeError, ValueError):
+            return None
+
+    def battery_status_acpi(self):
+        """Get the battery status via acpi."""
+        try:
+            fnull = open(os.devnull, "w")
+            raw_str = subprocess.check_output(["acpi"], stderr=fnull)
+            fnull.close()
+        except (OSError, subprocess.CalledProcessError):
+            return None
+        raw_str = raw_str.decode("utf-8")
+        part = helpers.get_string_between(",", "%", raw_str)
+        if part:
+            try:
+                return int(part)
+            except ValueError:
+                return None
+        return None
+
+    def battery_status_upower(self):
+        """Get the battery status via upower."""
+        path = "/org/freedesktop/UPower/devices/battery_BAT0"
+        try:
+            raw_str = subprocess.check_output(["upower", "-i", path])
+        except (OSError, subprocess.CalledProcessError):
+            return None
+        raw_str = raw_str.decode("utf-8")
+        raw_str = raw_str.splitlines()[0]
+        part = helpers.get_string_between("percentage:", "%", raw_str)
+        if part:
+            try:
+                return int(part)
+            except ValueError:
+                return None
+        return None
+
+    def readf(self, path):
+        """Read and return file contents at path."""
+        f = open(path)
+        data = f.read()
+        f.close()
+        return data
+
+
+module = {
+    "class": Battery,
+    "name": "battery",
+    "status": "top",
+}

suplemon/modules/bulk_delete.py

@@ -0,0 +1,75 @@
+# -*- encoding: utf-8
+
+from suplemon.suplemon_module import Module
+
+
+class BulkDelete(Module):
+    """
+    Bulk delete lines and characters.
+    Asks what direction to delete in by default.
+
+    Add 'up' to delete lines above highest cursor.
+    Add 'down' to delete lines below lowest cursor.
+    Add 'left' to delete characters to the left of all cursors.
+    Add 'right' to delete characters to the right of all cursors.
+    """
+
+    def init(self):
+        self.directions = ["up", "down", "left", "right"]
+
+    def handler(self, prompt, event):
+        # Get arrow keys from prompt
+        if event.key_name in self.directions:
+            prompt.set_data(event.key_name)
+            prompt.on_ready()
+        return True  # Disable normal key handling
+
+    def run(self, app, editor, args):
+        direction = args.lower()
+        if not direction:
+            direction = app.ui.query_filtered("Press arrow key in direction to delete:", handler=self.handler)
+
+        if direction not in self.directions:
+            app.set_status("Invalid direction.")
+            return False
+
+        # Delete entire lines
+        if direction == "up":
+            pos = editor.get_first_cursor()
+            length = len(editor.lines)
+            editor.lines = editor.lines[pos.y:]
+            delta = length - len(editor.lines)
+            # If lines were removed, move the cursors up the same amount
+            if delta:
+                editor.move_cursors((0, -delta))
+
+        elif direction == "down":
+            pos = editor.get_last_cursor()
+            editor.lines = editor.lines[:pos.y+1]
+
+        # Delete from start or end of lines
+        else:
+            # Select min/max function based on direction
+            func = min if direction == "left" else max
+            # Get all lines with cursors
+            line_indices = editor.get_lines_with_cursors()
+            for line_no in line_indices:
+                # Get all cursors for the line
+                line_cursors = editor.get_cursors_on_line(line_no)
+                # Get the leftmost of rightmost x coordinate
+                x = func(line_cursors, key=lambda c: c.x).x
+
+                # Delete correct part of the line
+                line = editor.lines[line_no]
+                if direction == "left":
+                    line.data = line.data[x:]
+                    # Also move cursors appropriately when deleting left side
+                    [c.move_left(x) for c in line_cursors]
+                else:
+                    line.data = line.data[:x]
+
+
+module = {
+    "class": BulkDelete,
+    "name": "bulk_delete",
+}

suplemon/modules/clock.py

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8
+
+import time
+
+from suplemon.suplemon_module import Module
+
+
+class Clock(Module):
+    """Shows a clock in the top status bar."""
+
+    def get_status(self):
+        s = time.strftime("%H:%M")
+        if self.app.config["app"]["use_unicode_symbols"]:
+            return "\u231A" + s
+        return s
+
+
+module = {
+    "class": Clock,
+    "name": "clock",
+    "status": "top",
+}