readymade 0.0.1__py3-none-any.whl

readymade/__init__.py

@@ -0,0 +1,11 @@
+"""readymade: Visual Basic style forms for Python and Tkinter."""
+
+from readymade.events import doevents, in_thread, pause, while_running
+from readymade.dialogs import (color_dialog, folder_dialog, font_dialog, inputbox, msgbox, open_file_dialog,
+                             save_file_dialog)
+from readymade.form import Form, app_path
+
+__all__ = [
+    "Form", "app_path", "color_dialog", "doevents", "folder_dialog", "font_dialog", "in_thread", "inputbox", "msgbox",
+    "open_file_dialog", "pause", "save_file_dialog", "while_running",
+]

readymade/appearance.py

@@ -0,0 +1,96 @@
+"""How controls look, in readymade's own terms: colors, fonts, alignment and mouse
+cursors, and what they become in Tk.
+
+Colors are "#rrggbb" strings, with "" for the usual color. A font is a string like
+"Arial, 12, bold" (family, size in points, then any of bold, italic and underline),
+or the same as a tuple, ("Arial", 12, "bold"); empty parts mean the usual font's.
+"""
+
+from __future__ import annotations
+
+import re
+
+ALIGNMENTS = ("left", "center", "right")
+VALIGNMENTS = ("top", "middle", "bottom")
+FONT_STYLES = ("bold", "italic", "underline")
+# Mouse cursors by readymade name, and Tk's names for them (which Tk maps to each system's own).
+CURSORS = {
+    "default": "",  # the control's usual cursor (a text box's is "text")
+    "arrow": "arrow",
+    "hand": "hand2",
+    "text": "xterm",
+    "cross": "crosshair",
+    "wait": "watch",
+    "move": "fleur",
+    "help": "question_arrow",
+    "resize_ew": "sb_h_double_arrow",
+    "resize_ns": "sb_v_double_arrow",
+}
+
+_HEX = re.compile(r"#[0-9a-fA-F]{6}")
+
+
+def check_color(value):
+    """value as a "#rrggbb" color (or "" for the usual); ValueError if it isn't one."""
+    value = "" if value is None else str(value).strip()
+    if value and not _HEX.fullmatch(value):
+        raise ValueError(f"{value!r} isn't a color; use \"#rrggbb\", like \"#ff0000\" for red (or \"\" for the usual color)")
+    return value.lower()
+
+
+def lighter(color, amount=0.2):
+    """A "#rrggbb" color mixed with some white (for a hovered button)."""
+    channels = [int(color[i:i + 2], 16) for i in (1, 3, 5)]
+    return "#" + "".join(f"{round(c + (255 - c) * amount):02x}" for c in channels)
+
+
+def parse_font(value):
+    """(family, size, styles) from a font string or tuple; "" and 0 mean the usual."""
+    if value is None or value == "":
+        return "", 0, ()
+    parts = [p.strip() for p in value.split(",")] if isinstance(value, str) else [str(p).strip() for p in value]
+    family = parts[0] if parts else ""
+    size = 0
+    if len(parts) > 1 and parts[1]:
+        try:
+            size = int(float(parts[1]))
+        except ValueError:
+            raise ValueError(f"{value!r}: the font's size, after the first comma, must be a number") from None
+        if size < 0:
+            raise ValueError(f"{value!r}: the font's size can't be negative")
+    styles = []
+    for word in " ".join(parts[2:]).lower().split():
+        if word not in FONT_STYLES:
+            raise ValueError(f"{value!r}: {word!r} isn't a font style; use bold, italic or underline")
+        if word not in styles:
+            styles.append(word)
+    return family, size, tuple(s for s in FONT_STYLES if s in styles)
+
+
+def format_font(value):
+    """The tidy string form of a font: "Arial, 12, bold"; "" for the usual font."""
+    family, size, styles = parse_font(value)
+    parts = [family, str(size) if size else "", " ".join(styles)]
+    while parts and not parts[-1]:
+        parts.pop()
+    return ", ".join(parts)
+
+
+def tk_font(value, usual):
+    """A Tk font description for a font, filling empty parts from usual (a dict like
+    tkinter.font.Font.actual() gives)."""
+    family, size, styles = parse_font(value)
+    return (family or usual["family"], size or usual["size"], *styles)
+
+
+def anchor(alignment, valignment="middle"):
+    """Tk's compass-point anchor for an alignment pair: ("left", "top") is "nw"."""
+    across = {"left": "w", "center": "", "right": "e"}[alignment]
+    down = {"top": "n", "middle": "", "bottom": "s"}[valignment]
+    return (down + across) or "center"
+
+
+def check_choice(name, value, choices):
+    if value not in choices:
+        raise ValueError(f"{name} must be one of: {', '.join(choices)}")
+    return value

readymade/codegen.py

@@ -0,0 +1,104 @@
+"""Small source edits on a form's .py module: adding, finding and renaming handlers.
+
+These work on lines and regular expressions rather than the ast, so they keep
+working while the code has a syntax error in it, which is most of the time
+during editing.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+INDENT = "    "
+
+
+class CodeGenError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class Edit:
+    """Replace lines [start, end) (0-based) with text."""
+
+    start: int
+    end: int
+    text: str
+    method_line: int  # 1-based line of the new def once the edit is applied
+
+    def apply(self, source):
+        lines = source.splitlines(keepends=True)
+        return "".join(lines[: self.start]) + self.text + "".join(lines[self.end :])
+
+
+def new_module(class_name):
+    return (
+        "from readymade import Form\n"
+        "\n"
+        "\n"
+        f"class {class_name}(Form):\n"
+        f"{INDENT}pass\n"
+        "\n"
+        "\n"
+        'if __name__ == "__main__":\n'
+        f"{INDENT}{class_name}.run()\n"
+    )
+
+
+def defined_methods(source):
+    return set(re.findall(r"^[ \t]+(?:async[ \t]+)?def[ \t]+(\w+)[ \t]*\(", source, re.M))
+
+
+def find_method(source, name):
+    """The 1-based line of `def name(`, or None."""
+    m = re.search(rf"^[ \t]+(?:async[ \t]+)?def[ \t]+{re.escape(name)}[ \t]*\(", source, re.M)
+    return source.count("\n", 0, m.start()) + 1 if m else None
+
+
+def add_method(source, class_name, name, params=()):
+    """An Edit that adds an empty method at the end of the class."""
+    lines = source.splitlines(keepends=True)
+    class_re = re.compile(rf"class[ \t]+{re.escape(class_name)}\b")
+    start = next((i for i, line in enumerate(lines) if class_re.match(line)), None)
+    if start is None:
+        raise CodeGenError(f"Couldn't find 'class {class_name}' in the code.")
+
+    # The class body runs until the first non-blank, non-comment line at column 0.
+    last = start
+    for i in range(start + 1, len(lines)):
+        line = lines[i]
+        if not line.strip() or line.lstrip().startswith("#"):
+            continue
+        if line[0] not in " \t":
+            break
+        last = i
+
+    body = [i for i in range(start + 1, last + 1) if lines[i].strip() and not lines[i].lstrip().startswith("#")]
+    indent = INDENT
+    if body:
+        first = lines[body[0]]
+        indent = first[: len(first) - len(first.lstrip())]
+    signature = ", ".join(("self", *params))
+    method = f"{indent}def {name}({signature}):\n{indent}{indent}pass\n"
+
+    # A new class holds only a placeholder `pass`; replace it.
+    if len(body) == 1 and lines[body[0]].strip() == "pass":
+        return Edit(body[0], body[0] + 1, method, method_line=body[0] + 1)
+
+    insert_at = last + 1
+    prefix = "" if lines[last].endswith("\n") else "\n"
+    return Edit(insert_at, insert_at, prefix + "\n" + method, method_line=insert_at + 2)
+
+
+def rename_control(source, old, new, events):
+    """Rename a control's handlers and its `self.old` references."""
+    if events:
+        names = "|".join(re.escape(e) for e in events)
+        pattern = rf"^([ \t]+(?:async[ \t]+)?def[ \t]+){re.escape(old)}_({names})(?=[ \t]*\()"
+        source = re.sub(pattern, rf"\g<1>{new}_\g<2>", source, flags=re.M)
+    return re.sub(rf"\bself\.{re.escape(old)}\b", f"self.{new}", source)
+
+
+def rename_class(source, old, new):
+    """Rename the form class everywhere it appears as a whole word."""
+    return re.sub(rf"\b{re.escape(old)}\b", new, source)