dprojectstools 0.0.26__tar.gz → 0.0.28__tar.gz

{dprojectstools-0.0.26/src/dprojectstools.egg-info → dprojectstools-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dprojectstools
-Version: 0.0.26
+Version: 0.0.28
 Summary: A set of development tools
 Author-email: Marc Delos <marcdp@dprojects.com>
 Project-URL: Homepage, https://github.com/marcdp/dprojectstools
@@ -23,6 +23,7 @@ Requires-Dist: sqlalchemy>=2.0.38
 Requires-Dist: websocat>=1.13.0
 Requires-Dist: json5>=0.13.0
 Requires-Dist: PyYAML>=6.0.3
+Requires-Dist: pyodbc>=5.2.0
 Dynamic: license-file
 
 
@@ -83,3 +84,5 @@ cd dprojectstools
 MIT License
 
 See the LICENSE file for details.
+
+

{dprojectstools-0.0.26 → dprojectstools-0.0.28}/README.md

@@ -55,4 +55,6 @@ cd dprojectstools
 
 MIT License
 
-See the LICENSE file for details.
+See the LICENSE file for details.
+
+

{dprojectstools-0.0.26 → dprojectstools-0.0.28}/pyproject.toml

@@ -10,7 +10,7 @@ where = ["src"]
 
 [project]
 name = "dprojectstools"
-version = "0.0.26"
+version = "0.0.28"
 authors = [
   { name="Marc Delos", email="marcdp@dprojects.com" },
 ]
@@ -26,7 +26,8 @@ dependencies = [
     "sqlalchemy>=2.0.38",
     "websocat>=1.13.0",
     "json5>=0.13.0",
-    "PyYAML>=6.0.3"
+    "PyYAML>=6.0.3",
+    "pyodbc>=5.2.0"
 ]
 description = "A set of development tools"
 readme = "README.md"

{dprojectstools-0.0.26 → dprojectstools-0.0.28}/src/dprojectstools/backups/restic.py

@@ -81,6 +81,7 @@ class Restic:
             iexclude: Annotated[list[str], "Include"] = None,
             verify = False,
             delete = False,
+            verbose = False,
             no_same_owner = False,
             no_same_permissions = False
         ):
@@ -101,6 +102,8 @@ class Restic:
             command += " --verify"
         if delete:
             command += " --delete"
+        if verbose:
+            command += " --verbose"
         if iexclude != None:
             for iexclude in iexclude:
                 command += " --iexclude " + iexclude

{dprojectstools-0.0.26 → dprojectstools-0.0.28}/src/dprojectstools/console/read_password.py

@@ -1,6 +1,6 @@
 import sys
 
-def read_password(prompt: str = "", mask: str = "*") -> str:
+def read_password(prompt: str = "Enter password: ", mask: str = "*") -> str:
     print(prompt, end="", flush=True)
     chars = []
 

dprojectstools-0.0.28/src/dprojectstools/xeditor/hightlight_env.py

@@ -0,0 +1,112 @@
+import re
+from dataclasses import dataclass
+from typing import List, Optional
+from dprojectstools.console import Sequences
+
+# ---- Token model ----
+@dataclass(frozen=True)
+class Token:
+    kind: str   # "indent" | "comment" | "key" | "eq" | "value" | "enc" | "ws" | "other"
+    text: str
+
+# ---- Regexes (simple, not quote-aware) ----
+
+_RX_COMMENT_LINE = re.compile(r"^\s*#.*$")
+_RX_ASSIGN = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)(\s*)=(\s*)(.*)$")
+_RX_ENC = re.compile(r"\benc(?::v\d+)?:")  # enc: or enc:v1: etc.
+
+def tokenize_env_line(line: str) -> List[Token]:
+    """
+    Mini-tokenizer for .env lines.
+    Goals:
+      - Identify KEY=VALUE assignments
+      - Identify full-line comments
+      - Highlight the first enc marker within the value
+    Non-goals:
+      - Perfect handling of quoted values / escaped # / export prefix
+      - Multiline values
+
+    Returns list[Token].
+    """
+    # Preserve newline as part of the last token if present
+    nl = ""
+    if line.endswith("\n"):
+        line, nl = line[:-1], "\n"
+
+    # Full-line comment
+    if _RX_COMMENT_LINE.match(line):
+        return [Token("comment", line + nl)]
+
+    m = _RX_ASSIGN.match(line)
+    if not m:
+        # Not an assignment; treat as "other"
+        return [Token("other", line + nl)]
+
+    indent, key, pre_eq_ws, post_eq_ws, rhs = m.groups()
+
+    tokens: List[Token] = []
+    if indent:
+        tokens.append(Token("indent", indent))
+    tokens.append(Token("key", key))
+    if pre_eq_ws:
+        tokens.append(Token("ws", pre_eq_ws))
+    tokens.append(Token("eq", "="))
+    if post_eq_ws:
+        tokens.append(Token("ws", post_eq_ws))
+
+    # Best-effort inline comment: split on first " #" or "\t#"
+    comment_idx: Optional[int] = None
+    for pat in (" #", "\t#"):
+        idx = rhs.find(pat)
+        if idx != -1 and (comment_idx is None or idx < comment_idx):
+            comment_idx = idx + 1  # keep the leading whitespace before '#'
+
+    if comment_idx is None:
+        value_part = rhs
+        comment_part = ""
+    else:
+        value_part = rhs[:comment_idx]
+        comment_part = rhs[comment_idx:]
+
+    # Tokenize value_part with enc marker (first occurrence only)
+    m_enc = _RX_ENC.search(value_part)
+    if not m_enc:
+        tokens.append(Token("value", value_part))
+    else:
+        a, b = m_enc.span()
+        if a > 0:
+            tokens.append(Token("value", value_part[:a]))
+        tokens.append(Token("enc", value_part[a:b]))
+        if b < len(value_part):
+            tokens.append(Token("value", value_part[b:]))
+
+    if comment_part:
+        tokens.append(Token("comment", comment_part))
+
+    if nl:
+        # Attach newline to the last token so rendering preserves lines
+        last = tokens[-1]
+        tokens[-1] = Token(last.kind, last.text + nl)
+
+    return tokens
+
+
+def tokenize_env(text: str) -> List[List[Token]]:
+    """Tokenize a whole .env file into tokens per line."""
+    return [tokenize_env_line(line) for line in text.splitlines(keepends=True)]
+
+def hightlight_env(line: str) -> str:
+    result = []
+    for token in tokenize_env_line(line):
+        # "indent" | "comment" | "key" | "eq" | "value" | "enc" | "ws" | "other"
+        if token.kind == "comment":
+            result.append(Sequences.FG_BRIGHT_GREEN + token.text + Sequences.RESET)
+        elif token.kind == "key":
+            result.append(Sequences.FG_CYAN + token.text + Sequences.RESET)
+        elif token.kind == "enc":
+            result.append(Sequences.FG_BRIGHT_BLUE + token.text)
+        elif token.kind == "value":
+            result.append(token.text + Sequences.RESET)
+        else:
+            result.append(token.text)
+    return "".join(result)

dprojectstools-0.0.28/src/dprojectstools/xeditor/hightlight_md.py

@@ -0,0 +1,191 @@
+import re
+from dataclasses import dataclass
+from typing import List, Optional
+from dprojectstools.console import Sequences
+
+# ---- Token model ----
+@dataclass(frozen=True)
+class Token:
+    kind: str   # "text" | "heading" | "frontmatter_delim" | "frontmatter_key" | "fence" | "code" | "enc" | "comment"
+    text: str
+
+# ---- Regexes ----
+_RX_HEADING = re.compile(r"^(\s{0,3})(#{1,6})(\s+)(.*)$")
+_RX_FENCE   = re.compile(r"^(\s{0,3})(```+)(\s*)(.*)$")  # ```lang
+_RX_FM_DELIM = re.compile(r"^\s*---\s*$")               # YAML frontmatter delimiter
+_RX_FM_XVAULT = re.compile(r"^(\s*)(_xvault)(\s*:\s*)(.*)$")
+_RX_ENC = re.compile(r"\benc(?::v\d+)?:")               # enc: or enc:v1: etc.
+
+def _split_enc(text: str, base_kind: str = "text") -> List[Token]:
+    """Split a string into tokens highlighting all enc markers."""
+    out: List[Token] = []
+    last = 0
+    for m in _RX_ENC.finditer(text):
+        a, b = m.span()
+        if a > last:
+            out.append(Token(base_kind, text[last:a]))
+        out.append(Token("enc", text[a:b]))
+        last = b
+    if last < len(text):
+        out.append(Token(base_kind, text[last:]))
+    return out
+
+@dataclass
+class MdState:
+    in_frontmatter: bool = False
+    frontmatter_possible: bool = True   # only at top of file until first non-empty non-frontmatter line
+    in_fence: bool = False
+    fence_lang: str = ""
+
+def tokenize_md_line(line: str, state: MdState) -> List[Token]:
+    """
+    Mini-tokenizer for Markdown lines with state.
+    - Detects YAML frontmatter only at the top of file.
+    - Detects fenced blocks ```lang (multi-line).
+    - Highlights headings and enc markers.
+    - Highlights inline code spans `...` (simple: not nested).
+    """
+    # Preserve newline as part of last token (same style as your env tokenizer)
+    nl = ""
+    if line.endswith("\n"):
+        line, nl = line[:-1], "\n"
+
+    tokens: List[Token] = []
+
+    # --- FRONTMATTER detection (only at top) ---
+    if state.frontmatter_possible:
+        if not state.in_frontmatter:
+            if _RX_FM_DELIM.match(line):
+                state.in_frontmatter = True
+                tokens.append(Token("frontmatter_delim", line + nl))
+                return tokens
+            # If first meaningful line is not '---', stop considering frontmatter
+            if line.strip() != "":
+                state.frontmatter_possible = False
+        else:
+            # we are inside frontmatter
+            if _RX_FM_DELIM.match(line):
+                state.in_frontmatter = False
+                state.frontmatter_possible = False
+                tokens.append(Token("frontmatter_delim", line + nl))
+                return tokens
+
+            # highlight _xvault: line specially
+            mfm = _RX_FM_XVAULT.match(line)
+            if mfm:
+                indent, key, sep, rest = mfm.groups()
+                if indent:
+                    tokens.append(Token("text", indent))
+                tokens.append(Token("frontmatter_key", key))
+                tokens.append(Token("text", sep))
+                # highlight enc markers inside value part
+                tokens.extend(_split_enc(rest, base_kind="text"))
+                if nl:
+                    last = tokens[-1]
+                    tokens[-1] = Token(last.kind, last.text + nl)
+                return tokens
+
+            # otherwise treat as frontmatter text (optionally highlight enc)
+            tokens.extend(_split_enc(line, base_kind="text"))
+            if nl:
+                last = tokens[-1]
+                tokens[-1] = Token(last.kind, last.text + nl)
+            return tokens
+
+    # --- FENCE detection (toggle in_fence) ---
+    mf = _RX_FENCE.match(line)
+    if mf:
+        indent, ticks, sp, lang = mf.groups()
+        # Toggle fence on/off
+        if not state.in_fence:
+            state.in_fence = True
+            state.fence_lang = lang.strip()
+        else:
+            state.in_fence = False
+            state.fence_lang = ""
+
+        # Tokenize fence line
+        if indent:
+            tokens.append(Token("text", indent))
+        tokens.append(Token("fence", ticks))
+        tokens.append(Token("text", sp + lang))
+        if nl:
+            last = tokens[-1]
+            tokens[-1] = Token(last.kind, last.text + nl)
+        return tokens
+
+    # --- Inside fenced block ---
+    if state.in_fence:
+        # For xvault blocks, highlight enc markers aggressively
+        if state.fence_lang.startswith("xvault"):
+            tokens.extend(_split_enc(line, base_kind="code"))
+        else:
+            tokens.append(Token("code", line))
+        if nl:
+            last = tokens[-1]
+            tokens[-1] = Token(last.kind, last.text + nl)
+        return tokens
+
+    # --- Headings ---
+    mh = _RX_HEADING.match(line)
+    if mh:
+        indent, hashes, sp, rest = mh.groups()
+        if indent:
+            tokens.append(Token("text", indent))
+        tokens.append(Token("heading", hashes))
+        tokens.append(Token("text", sp))
+        # highlight enc markers in heading text if any (rare but fine)
+        tokens.extend(_split_enc(rest, base_kind="heading"))
+        if nl:
+            last = tokens[-1]
+            tokens[-1] = Token(last.kind, last.text + nl)
+        return tokens
+
+    # --- Inline code spans: split by backticks (simple) ---
+    # This is not a full Markdown inline parser; it's good enough for highlighting secrets in `...`.
+    parts = line.split("`")
+    if len(parts) == 1:
+        tokens.extend(_split_enc(line, base_kind="text"))
+    else:
+        for i, part in enumerate(parts):
+            if i % 2 == 0:
+                tokens.extend(_split_enc(part, base_kind="text"))
+            else:
+                # inside code span
+                tokens.append(Token("code", "`"))
+                tokens.extend(_split_enc(part, base_kind="code"))
+                tokens.append(Token("code", "`"))
+
+    if nl:
+        last = tokens[-1]
+        tokens[-1] = Token(last.kind, last.text + nl)
+
+    return tokens
+
+
+def tokenize_md(text: str) -> List[List[Token]]:
+    """Tokenize a whole markdown text into tokens per line."""
+    state = MdState()
+    out: List[List[Token]] = []
+    for line in text.splitlines(keepends=True):
+        out.append(tokenize_md_line(line, state))
+    return out
+
+
+
+def hightlight_md(line: str) -> str:
+    result = []
+    state = MdState()
+    for token in tokenize_md_line(line, state):
+        # "text" | "heading" | "frontmatter_delim" | "frontmatter_key" | "fence" | "code" | "enc" | "comment"
+        if token.kind == "comment":
+            result.append(Sequences.FG_BRIGHT_GREEN + token.text + Sequences.RESET)
+        elif token.kind == "heading":
+            result.append(Sequences.FG_CYAN + token.text + Sequences.RESET)
+        elif token.kind == "code":
+            result.append(Sequences.FG_RED + token.text + Sequences.RESET)
+        elif token.kind == "enc":
+            result.append(Sequences.FG_BRIGHT_BLUE + token.text + Sequences.RESET)        
+        else:
+            result.append(token.text)
+    return "".join(result)

dprojectstools-0.0.28/src/dprojectstools/xeditor/hightlight_none.py

@@ -0,0 +1,3 @@
+
+def hightlight_none(line: str) -> str:
+    return line

{dprojectstools-0.0.26 → dprojectstools-0.0.28}/src/dprojectstools/xeditor/xeditor.py

@@ -1,3 +1,4 @@
+import re
 from ..console import Sequences, Keys, readKey
 from ..crypto import aes_decrypt, aes_encrypt
 from ..clipboard import copy
@@ -8,12 +9,17 @@ import json
 import json5
 import yaml
 
-# read correctly ESCAPE sequence key in linux
+
+from .hightlight_none import  hightlight_none
+from .hightlight_env import  hightlight_env
+from .hightlight_md import  hightlight_md
+
+
 # undo + redo
 
 # constants
 TAB_SPACES = 4
-
+    
 # class
 class XEditor:
   
@@ -71,7 +77,7 @@ class XEditor:
         try:
             self.load(filename)
         except ValueError as e:
-            print("error: invalid password")
+            print("error: " + str(e))
             return False
         # dump
         if dump:
@@ -301,7 +307,7 @@ class XEditor:
             line = line[:self._cursor_x] + key + line[self._cursor_x:]
             self._lines[self._cursor_y] = line            
             self._setCursor(self._cursor_x + 1, self._cursor_y)
-            self._printHeader(flush = False)            
+            self._printFooter(flush = False)            
             self._printLine(self._cursor_y, flush = False)
             self._printCursor()
         else:
@@ -309,7 +315,7 @@ class XEditor:
             line = line[:self._cursor_x] + key + line[self._cursor_x + 1:]
             self._lines[self._cursor_y] = line            
             self._setCursor(self._cursor_x + 1, self._cursor_y)
-            self._printHeader(flush = False)
+            self._printFooter(flush = False)
             self._printLine(self._cursor_y)        
     
     def enter(self):
@@ -324,7 +330,7 @@ class XEditor:
             self._lines[self._cursor_y] = line_before
             self._lines.insert(self._cursor_y + 1, line_after)
             self._setCursor(0, self._cursor_y + 1)
-            self._printHeader(flush = False)
+            self._printFooter(flush = False)
             self._printLines(flush = False)
             self._printCursor()
         
@@ -364,8 +370,8 @@ class XEditor:
                     self._select_x = 0
                     self._select_y = y1                
             # print 
-            self._printHeader(flush = False)
             self._printLines(flush = False)
+            self._printFooter(flush = False)
             self._printCursor()
 
     def untab(self):
@@ -380,8 +386,8 @@ class XEditor:
                 self._setCursor(self._cursor_x - TAB_SPACES, self._cursor_y)
                 if self._select_x != None:
                     self._select_x -= TAB_SPACES
-                self._printHeader(flush = False)
                 self._printLines(flush = False)
+                self._printFooter(flush = False)
                 self._printCursor()
         else:
             # multime lines selected (unindent as a block)
@@ -402,8 +408,8 @@ class XEditor:
                     line = line[len(spaces):]
                     self._lines[y] = line
             # print 
-            self._printHeader(flush = False)
             self._printLines(flush = False)
+            self._printFooter(flush = False)
             self._printCursor()
 
     def backspace(self):
@@ -419,15 +425,15 @@ class XEditor:
                 self._lines[self._cursor_y - 1] = line
                 self._lines.pop(self._cursor_y)
                 self._setCursor(len(line_prev), self._cursor_y - 1)
-                self._printHeader(flush = False)
                 self._printLines(flush = False)
+                self._printFooter(flush = False)
                 self._printCursor()
         else:
             self._dirty = True
             line = line[:self._cursor_x - 1] + line[self._cursor_x:]
             self._lines[self._cursor_y] = line            
             self._setCursor(self._cursor_x - 1, self._cursor_y)
-            self._printHeader(flush = False)
+            self._printFooter(flush = False)
             self._printLine(self._cursor_y)
 
     def delete(self):
@@ -441,20 +447,20 @@ class XEditor:
                 line += self._lines[self._cursor_y + 1]
                 self._lines[self._cursor_y] = line            
                 self._lines.pop(self._cursor_y + 1)
-                self._printHeader(flush = False)
                 self._printLines(flush = False)
+                self._printFooter(flush = False)
                 self._printCursor()
         else:
             self._dirty = True
             line = line[:self._cursor_x] + line[self._cursor_x + 1:]
             self._lines[self._cursor_y] = line            
-            self._printHeader(flush = False)
+            self._printFooter(flush = False)
             self._printLine(self._cursor_y)
 
     def insert(self):
         # insert
         self._insert = not self._insert
-        self._printHeader(flush = False)
+        self._printFooter(flush = False)
         self._printCursor()
 
     def escape(self):
@@ -491,8 +497,8 @@ class XEditor:
                 self._lines[y] = line
         # print
         self._setCursor(x, y)
-        self._printHeader(flush = False)
         self._printLines(flush = False)
+        self._printFooter(flush = False)
         self._printCursor()
 
     def getSelectedText(self):
@@ -576,8 +582,8 @@ class XEditor:
         self._select_x = 0
         self._select_y = 0
         self._setCursor(len(self._lines[-1]), len(self._lines) -1 )
-        self._printHeader(flush = False)
         self._printLines(flush = False)
+        self._printFooter(flush = False)
         self._printCursor()
 
     def help(self):
@@ -600,7 +606,7 @@ class XEditor:
         self._lines = [""]
         self._newline = os.linesep
         if os.path.exists(filename):
-            with open(filename,"r") as file:
+            with open(filename, "r", encoding="utf-8") as file:
                 text = file.read()
                 # decrypt
                 if self._password != None:
@@ -628,7 +634,7 @@ class XEditor:
         if self._filename == None:
             self._result = self._newline.join(self._lines)
         else:
-            with open(self._filename,"w") as file:
+            with open(self._filename,"w", encoding="utf-8") as file:
                 file.write(text)
         # print
         self._dirty = False
@@ -699,7 +705,7 @@ class XEditor:
         if self._cursor_y >= self._offset_y + self._rows - 1:
             self._setOffset(self._offset_x, self._cursor_y - self._rows + 1 + 1)
 
-        self._printHeader(flush = False)
+        self._printFooter(flush = False)
         self._printCursor()
     
     def autodetect_newline(self, text: str) -> str:
@@ -715,11 +721,11 @@ class XEditor:
         self._stdout.flush()
 
     def _printAll(self):
-        self._printHeader(flush = False)
         self._printLines(flush = False)        
+        self._printFooter(flush = False)
         self._printCursor()
         
-    def _printHeader(self, flush:bool = True, message: str = None):
+    def _printFooter(self, flush:bool = True, message: str = None):
         filename = ""
         if self._filename != None:
             filename = self._filename 
@@ -736,7 +742,8 @@ class XEditor:
 
         # print
         self._stdout.write(Sequences.CURSOR_HIDE)
-        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1,1))
+        
+        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, self._rows))
         self._stdout.write(Sequences.BG_WHITE + Sequences.FG_BLACK)
         self._stdout.write(header)
         self._stdout.write(Sequences.RESET)
@@ -745,7 +752,7 @@ class XEditor:
             self._stdout.flush()
 
     def _printCursor(self, flush = True):
-        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1 + self._cursor_x - self._offset_x, 1 + 1 + self._cursor_y - self._offset_y))
+        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1 + self._cursor_x - self._offset_x, 1 + self._cursor_y - self._offset_y))
         if flush:
             self._stdout.flush()
 
@@ -761,7 +768,7 @@ class XEditor:
         line_len = len(line)
 
         self._stdout.write(Sequences.CURSOR_HIDE)
-        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, 1 + 1 + self._cursor_y - self._offset_y))
+        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, 1 + self._cursor_y - self._offset_y))
 
         # selected
         if self._select_x != None:
@@ -771,14 +778,18 @@ class XEditor:
             line += " " * (self._cols - line_len)
         if self._cursor_y == self._rows - 1 - 1:
             line = line[:line_len - 1]
-
+        
+        # highlight
+        line = self._hightlight(line)
+        
+        # print
         self._stdout.write(line)
         self._stdout.write(Sequences.CURSOR_SHOW)
         self._printCursor(flush = flush)
 
     def _printLines(self, flush = True):
         self._stdout.write(Sequences.CURSOR_HIDE)
-        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1,2))
+        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1,1))
         self._stdout.write(Sequences.RESET)
         for y in range(self._rows - 1):
             line = None
@@ -811,8 +822,13 @@ class XEditor:
             # write 
             if y == self._rows - 1 - 1:
                 line = line[:len(line) - 1]
+
+            # hightlight
+            line = self._hightlight(line)  
+
             # write line
             self._stdout.write(line)
+
         self._printCursor(flush = False)
         self._stdout.write(Sequences.CURSOR_SHOW)
         if flush:
@@ -820,10 +836,10 @@ class XEditor:
 
     def _question(self, message: str) -> str:
         self._stdout.write(Sequences.BG_WHITE + Sequences.FG_BLACK)
-        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, 1))
+        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, self._rows))
         self._stdout.write(" " * self._cols)
 
-        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, 1))
+        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, self._rows))
         self._stdout.write(Sequences.BG_WHITE + Sequences.FG_BLACK)
         result = None
         try:
@@ -836,19 +852,21 @@ class XEditor:
 
     def _questionYesNo(self, message: str) -> str:
         self._stdout.write(Sequences.BG_WHITE + Sequences.FG_BLACK)
-        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, 1))
-        self._stdout.write(" " * self._cols)
-        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, 1))
+        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, self._rows))
+        self._stdout.write(" " * (self._cols - 1))
+        self._stdout.write(Sequences.SET_CURSOR_POSITION_X_Y.format(1, self._rows))
         self._stdout.write(Sequences.BG_WHITE + Sequences.FG_BLACK)
         result = None
         print(" " + message + " ", end='', flush=True)
         key = ""
         while True:
             key = readKey()
-            print(key)
             if key == Keys.CTRL_C:
                 result = None
                 break
+            if key == Keys.ESCAPE:
+                result = None
+                break
             key = key.lower()
             if key == "y" or key == "n":
                 result = key
@@ -858,7 +876,7 @@ class XEditor:
         return result
 
     def _show_error(self, message: str) -> str:
-        self._printHeader(message = message )
+        self._printFooter(message = message )
         self._printCursor()
 
     def _colorizeLine(self, line, index):
@@ -956,6 +974,13 @@ class XEditor:
     def _loop(self):
         # clear
         self._clear()
+        # highlighter
+        if self._format == "env":
+            self._hightlight = hightlight_env
+        elif self._format == "md":
+            self._hightlight = hightlight_md
+        else:
+            self._hightlight = hightlight_none
         # set cursor style
         self._stdout.write(Sequences.CURSOR_SHAPE_BLINKING_BLOCK)
         # prepare
@@ -964,8 +989,8 @@ class XEditor:
         # loop
         while not self._stop:
             # read key
-            key = readKey()
-            
+            key = readKey()            
+
             # check for size changed
             current_size = os.get_terminal_size()            
             if self._rows != current_size.lines or self._cols != current_size.columns:
@@ -987,6 +1012,7 @@ class XEditor:
                 self.undo()
             elif key == Keys.CTRL_Y:
                 self.redo()
+
             # arrows
             elif key == Keys.RIGHT_ARROW:
                 self.right()
@@ -1037,7 +1063,6 @@ class XEditor:
                 self.home(True)
             elif key == Keys.SHIFT_END_ARROW:
                 self.end(True)
-
             elif key == Keys.CTRL_SHIFT_RIGHT_ARROW:
                 self.rightWord(True)
             elif key == Keys.CTRL_SHIFT_LEFT_ARROW:

{dprojectstools-0.0.26 → dprojectstools-0.0.28/src/dprojectstools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dprojectstools
-Version: 0.0.26
+Version: 0.0.28
 Summary: A set of development tools
 Author-email: Marc Delos <marcdp@dprojects.com>
 Project-URL: Homepage, https://github.com/marcdp/dprojectstools
@@ -23,6 +23,7 @@ Requires-Dist: sqlalchemy>=2.0.38
 Requires-Dist: websocat>=1.13.0
 Requires-Dist: json5>=0.13.0
 Requires-Dist: PyYAML>=6.0.3
+Requires-Dist: pyodbc>=5.2.0
 Dynamic: license-file
 
 
@@ -83,3 +84,5 @@ cd dprojectstools
 MIT License
 
 See the LICENSE file for details.
+
+

{dprojectstools-0.0.26 → dprojectstools-0.0.28}/src/dprojectstools.egg-info/SOURCES.txt

@@ -51,4 +51,7 @@ src/dprojectstools/utils/versions.py
 src/dprojectstools/utils/xml.py
 src/dprojectstools/xeditor/__init__.py
 src/dprojectstools/xeditor/__main__.py
+src/dprojectstools/xeditor/hightlight_env.py
+src/dprojectstools/xeditor/hightlight_md.py
+src/dprojectstools/xeditor/hightlight_none.py
 src/dprojectstools/xeditor/xeditor.py

{dprojectstools-0.0.26 → dprojectstools-0.0.28}/src/dprojectstools.egg-info/requires.txt

@@ -10,3 +10,4 @@ sqlalchemy>=2.0.38
 websocat>=1.13.0
 json5>=0.13.0
 PyYAML>=6.0.3
+pyodbc>=5.2.0