tklive 0.1.0__tar.gz

tklive-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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.

tklive-0.1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: tklive
+Version: 0.1.0
+Summary: Live hot-reload for tkinter and customtkinter apps
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/tklive
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: watchdog>=3.0.0
+Dynamic: license-file
+
+# tklive
+
+Live hot-reload für tkinter und customtkinter Apps.  
+Speichere deine Datei → UI updated sich sofort ohne das Fenster zu schließen.
+
+## Installation
+
+```bash
+pip install tklive
+```
+
+## Verwendung
+
+Füge **zwei Zeilen** zu deinem Projekt hinzu:
+
+```python
+import tkinter as tk
+from tklive import live
+
+root = tk.Tk()
+
+# ... dein gesamter normaler Code bleibt unverändert ...
+
+live(root, __file__)  # ← eine Zeile ans Ende
+root.mainloop()
+```
+
+Speichere die Datei → UI reloaded live. Oder **Ctrl+R** für manuellen Reload.
+
+## Features
+
+- ✅ Fenster bleibt offen – kein Neustart
+- ✅ State-Erhalt (Entry, Text, Tabs, Scrollposition, Fenstergröße)
+- ✅ customtkinter Support (CTkEntry, CTkTextbox, CTkSlider, CTkTabview ...)
+- ✅ ttk Support (Notebook, Treeview, Combobox ...)
+- ✅ Multi-File Support
+
+## Mehrere Dateien beobachten
+
+```python
+live(root, __file__, watch_files=["ui.py", "components.py"])
+```
+
+## Lizenz
+
+MIT

tklive-0.1.0/README.md

@@ -0,0 +1,46 @@
+# tklive
+
+Live hot-reload für tkinter und customtkinter Apps.  
+Speichere deine Datei → UI updated sich sofort ohne das Fenster zu schließen.
+
+## Installation
+
+```bash
+pip install tklive
+```
+
+## Verwendung
+
+Füge **zwei Zeilen** zu deinem Projekt hinzu:
+
+```python
+import tkinter as tk
+from tklive import live
+
+root = tk.Tk()
+
+# ... dein gesamter normaler Code bleibt unverändert ...
+
+live(root, __file__)  # ← eine Zeile ans Ende
+root.mainloop()
+```
+
+Speichere die Datei → UI reloaded live. Oder **Ctrl+R** für manuellen Reload.
+
+## Features
+
+- ✅ Fenster bleibt offen – kein Neustart
+- ✅ State-Erhalt (Entry, Text, Tabs, Scrollposition, Fenstergröße)
+- ✅ customtkinter Support (CTkEntry, CTkTextbox, CTkSlider, CTkTabview ...)
+- ✅ ttk Support (Notebook, Treeview, Combobox ...)
+- ✅ Multi-File Support
+
+## Mehrere Dateien beobachten
+
+```python
+live(root, __file__, watch_files=["ui.py", "components.py"])
+```
+
+## Lizenz
+
+MIT

tklive-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tklive"
+version = "0.1.0"
+description = "Live hot-reload for tkinter and customtkinter apps"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+dependencies = ["watchdog>=3.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/tklive"

tklive-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tklive-0.1.0/tklive/__init__.py

@@ -0,0 +1,4 @@
+from .core import live
+
+__version__ = "0.1.0"
+__all__ = ["live"]

tklive-0.1.0/tklive/core.py

@@ -0,0 +1,151 @@
+import os
+import sys
+import time
+import traceback
+import tkinter as tk
+
+from .state import save_state, restore_state
+
+try:
+    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEventHandler
+    HAS_WATCHDOG = True
+except ImportError:
+    HAS_WATCHDOG = False
+
+
+class _FileHandler(FileSystemEventHandler):
+    def __init__(self, paths, callback):
+        self._paths = [os.path.abspath(p) for p in paths]
+        self._callback = callback
+        self._last = 0
+
+    def on_modified(self, event):
+        if not event.is_directory and event.src_path.endswith(".py"):
+            if os.path.abspath(event.src_path) in self._paths or not self._paths:
+                now = time.time()
+                if now - self._last > 0.5:
+                    self._last = now
+                    self._callback()
+
+
+def _clear_widgets(root):
+    for w in root.winfo_children():
+        w.destroy()
+
+
+def live(root: tk.Tk, script_path: str, watch_files: list = None, auto: bool = True):
+    """
+    Aktiviert live-reload für ein tkinter Script.
+
+    Verwendung:
+        live(root, __file__)
+
+    Mehrere Dateien beobachten:
+        live(root, __file__, watch_files=["ui.py", "components.py"])
+
+    Parameter:
+        root          tkinter Root-Fenster
+        script_path   Pfad zum Hauptscript (__file__ übergeben)
+        watch_files   Weitere Dateien die beobachtet werden sollen (optional)
+        auto          Automatisch neu laden wenn Datei gespeichert wird
+    """
+    abs_path = os.path.abspath(script_path)
+    folder = os.path.dirname(abs_path)
+
+    # Alle zu beobachtenden Dateien sammeln
+    all_files = [abs_path]
+    if watch_files:
+        for f in watch_files:
+            p = os.path.abspath(f)
+            if p not in all_files:
+                all_files.append(p)
+
+    def do_reload():
+        try:
+            state = save_state(root)
+            root.after(0, lambda: _do_rebuild(state))
+        except Exception:
+            traceback.print_exc()
+
+    def _do_rebuild(state):
+        try:
+            _clear_widgets(root)
+
+            script_globals = {
+                "__file__": abs_path,
+                "__name__": "__tkinter_reload__",
+                "__builtins__": __builtins__,
+            }
+
+            import tkinter as _tk
+            original_tk = _tk.Tk
+
+            class _FakeTk:
+                def __new__(cls, *args, **kwargs):
+                    return root
+
+            _tk.Tk = _FakeTk
+
+            # customtkinter CTk ebenfalls patchen
+            try:
+                import customtkinter as _ctk
+                original_ctk = _ctk.CTk
+                class _FakeCTk:
+                    def __new__(cls, *args, **kwargs):
+                        return root
+                _ctk.CTk = _FakeCTk
+            except ImportError:
+                original_ctk = None
+                _ctk = None
+
+            original_mainloop = root.mainloop
+            root.mainloop = lambda: None
+
+            try:
+                with open(abs_path, "r", encoding="utf-8") as f:
+                    source = f.read()
+                exec(compile(source, abs_path, "exec"), script_globals)
+            finally:
+                _tk.Tk = original_tk
+                root.mainloop = original_mainloop
+                if _ctk and original_ctk:
+                    _ctk.CTk = original_ctk
+
+            restore_state(root, state)
+
+        except Exception:
+            _clear_widgets(root)
+            tb = traceback.format_exc()
+            tk.Label(root, text="Fehler beim Reload", fg="red",
+                     font=("Arial", 14, "bold")).pack(pady=20)
+            t = tk.Text(root, width=80, height=20, bg="#1e1e1e", fg="#ff6b6b",
+                        font=("Courier", 9))
+            t.pack(padx=10)
+            t.insert("1.0", tb)
+
+    root.bind_all("<Control-r>", lambda e: do_reload())
+
+    if auto:
+        if not HAS_WATCHDOG:
+            return
+
+        handler = _FileHandler(all_files, do_reload)
+        observer = Observer()
+
+        # Alle relevanten Ordner beobachten
+        watched_folders = set()
+        for f in all_files:
+            watched_folders.add(os.path.dirname(f))
+
+        for watched_folder in watched_folders:
+            observer.schedule(handler, watched_folder, recursive=False)
+
+        observer.daemon = True
+        observer.start()
+
+        def on_close():
+            observer.stop()
+            root.destroy()
+
+        root.protocol("WM_DELETE_WINDOW", on_close)

tklive-0.1.0/tklive/state.py

@@ -0,0 +1,257 @@
+"""
+Speichert und stellt Widget-Zustände wieder her.
+Unterstützt: tkinter, ttk, customtkinter, ttkbootstrap
+"""
+
+import tkinter as tk
+
+try:
+    from tkinter import ttk
+    HAS_TTK = True
+except ImportError:
+    HAS_TTK = False
+
+try:
+    import customtkinter as ctk
+    HAS_CTK = True
+except ImportError:
+    HAS_CTK = False
+
+
+def save_state(root: tk.Tk) -> dict:
+    state = {
+        "widgets": {},
+        "window": {
+            "geometry": root.geometry(),
+            "title": root.title(),
+        }
+    }
+    _collect(root, state["widgets"])
+    return state
+
+
+def restore_state(root: tk.Tk, state: dict):
+    if not state:
+        return
+
+    # Fenstergröße und Position wiederherstellen
+    if "window" in state:
+        try:
+            root.geometry(state["window"]["geometry"])
+            root.title(state["window"]["title"])
+        except Exception:
+            pass
+
+    if "widgets" in state:
+        _apply(root, state["widgets"])
+
+
+def _widget_key(widget) -> str:
+    name = str(widget).split(".")[-1]
+    return str(widget) if not name else f"{type(widget).__name__}:{str(widget)}"
+
+
+def _collect(widget, state: dict):
+    key = _widget_key(widget)
+
+    try:
+        # ── tkinter Standard ──────────────────────────────
+        if isinstance(widget, tk.Entry):
+            state[key] = ("entry", widget.get())
+
+        elif isinstance(widget, tk.Text):
+            state[key] = ("text", widget.get("1.0", tk.END), widget.yview()[0])
+
+        elif isinstance(widget, tk.Scale):
+            state[key] = ("scale", widget.get())
+
+        elif isinstance(widget, tk.Spinbox):
+            state[key] = ("spinbox", widget.get())
+
+        elif isinstance(widget, tk.Listbox):
+            selected = list(widget.curselection())
+            scroll = widget.yview()[0]
+            state[key] = ("listbox", selected, scroll)
+
+        elif isinstance(widget, tk.BooleanVar):
+            state[key] = ("boolvar", widget.get())
+
+        elif isinstance(widget, (tk.Checkbutton, tk.Radiobutton)):
+            try:
+                var = widget.cget("variable")
+                if var:
+                    state[key] = ("varname", str(var))
+            except Exception:
+                pass
+
+        # ── ttk ──────────────────────────────────────────
+        if HAS_TTK:
+            if isinstance(widget, ttk.Combobox):
+                state[key] = ("combobox", widget.get())
+
+            elif isinstance(widget, ttk.Entry):
+                state[key] = ("entry", widget.get())
+
+            elif isinstance(widget, ttk.Notebook):
+                state[key] = ("notebook", widget.index("current"))
+
+            elif isinstance(widget, ttk.Treeview):
+                selected = widget.selection()
+                state[key] = ("treeview", selected)
+
+            elif isinstance(widget, ttk.Scale):
+                state[key] = ("scale", widget.get())
+
+            elif isinstance(widget, ttk.Spinbox):
+                state[key] = ("spinbox", widget.get())
+
+        # ── customtkinter ─────────────────────────────────
+        if HAS_CTK:
+            if isinstance(widget, ctk.CTkEntry):
+                state[key] = ("ctk_entry", widget.get())
+
+            elif isinstance(widget, ctk.CTkTextbox):
+                state[key] = ("ctk_text", widget.get("1.0", tk.END))
+
+            elif isinstance(widget, ctk.CTkComboBox):
+                state[key] = ("ctk_combo", widget.get())
+
+            elif isinstance(widget, ctk.CTkSlider):
+                state[key] = ("ctk_slider", widget.get())
+
+            elif isinstance(widget, ctk.CTkCheckBox):
+                state[key] = ("ctk_check", widget.get())
+
+            elif isinstance(widget, ctk.CTkSwitch):
+                state[key] = ("ctk_switch", widget.get())
+
+            elif isinstance(widget, ctk.CTkSegmentedButton):
+                state[key] = ("ctk_segmented", widget.get())
+
+            elif isinstance(widget, ctk.CTkTabview):
+                try:
+                    state[key] = ("ctk_tab", widget.get())
+                except Exception:
+                    pass
+
+    except Exception:
+        pass
+
+    # Rekursiv durch alle Kinder
+    try:
+        children = widget.winfo_children()
+    except Exception:
+        children = []
+
+    for child in children:
+        _collect(child, state)
+
+
+def _apply(widget, state: dict):
+    key = _widget_key(widget)
+
+    try:
+        if key in state:
+            entry = state[key]
+            kind = entry[0]
+
+            # ── tkinter Standard ──────────────────────────
+            if kind == "entry" and isinstance(widget, tk.Entry):
+                widget.delete(0, tk.END)
+                widget.insert(0, entry[1])
+
+            elif kind == "text" and isinstance(widget, tk.Text):
+                widget.delete("1.0", tk.END)
+                widget.insert("1.0", entry[1].rstrip("\n"))
+                widget.yview_moveto(entry[2])
+
+            elif kind == "scale" and isinstance(widget, tk.Scale):
+                widget.set(entry[1])
+
+            elif kind == "spinbox" and isinstance(widget, tk.Spinbox):
+                widget.delete(0, tk.END)
+                widget.insert(0, entry[1])
+
+            elif kind == "listbox" and isinstance(widget, tk.Listbox):
+                widget.selection_clear(0, tk.END)
+                for i in entry[1]:
+                    widget.selection_set(i)
+                widget.yview_moveto(entry[2])
+
+            # ── ttk ───────────────────────────────────────
+            elif kind == "combobox" and HAS_TTK and isinstance(widget, ttk.Combobox):
+                widget.set(entry[1])
+
+            elif kind == "entry" and HAS_TTK and isinstance(widget, ttk.Entry):
+                widget.delete(0, tk.END)
+                widget.insert(0, entry[1])
+
+            elif kind == "notebook" and HAS_TTK and isinstance(widget, ttk.Notebook):
+                try:
+                    widget.select(entry[1])
+                except Exception:
+                    pass
+
+            elif kind == "treeview" and HAS_TTK and isinstance(widget, ttk.Treeview):
+                try:
+                    widget.selection_set(entry[1])
+                except Exception:
+                    pass
+
+            elif kind == "scale" and HAS_TTK and isinstance(widget, ttk.Scale):
+                widget.set(entry[1])
+
+            elif kind == "spinbox" and HAS_TTK and isinstance(widget, ttk.Spinbox):
+                widget.delete(0, tk.END)
+                widget.insert(0, entry[1])
+
+            # ── customtkinter ─────────────────────────────
+            elif kind == "ctk_entry" and HAS_CTK and isinstance(widget, ctk.CTkEntry):
+                widget.delete(0, tk.END)
+                widget.insert(0, entry[1])
+
+            elif kind == "ctk_text" and HAS_CTK and isinstance(widget, ctk.CTkTextbox):
+                widget.delete("1.0", tk.END)
+                widget.insert("1.0", entry[1].rstrip("\n"))
+
+            elif kind == "ctk_combo" and HAS_CTK and isinstance(widget, ctk.CTkComboBox):
+                widget.set(entry[1])
+
+            elif kind == "ctk_slider" and HAS_CTK and isinstance(widget, ctk.CTkSlider):
+                widget.set(entry[1])
+
+            elif kind == "ctk_check" and HAS_CTK and isinstance(widget, ctk.CTkCheckBox):
+                if entry[1]:
+                    widget.select()
+                else:
+                    widget.deselect()
+
+            elif kind == "ctk_switch" and HAS_CTK and isinstance(widget, ctk.CTkSwitch):
+                if entry[1]:
+                    widget.select()
+                else:
+                    widget.deselect()
+
+            elif kind == "ctk_segmented" and HAS_CTK and isinstance(widget, ctk.CTkSegmentedButton):
+                try:
+                    widget.set(entry[1])
+                except Exception:
+                    pass
+
+            elif kind == "ctk_tab" and HAS_CTK and isinstance(widget, ctk.CTkTabview):
+                try:
+                    widget.set(entry[1])
+                except Exception:
+                    pass
+
+    except Exception:
+        pass
+
+    # Rekursiv durch alle Kinder
+    try:
+        children = widget.winfo_children()
+    except Exception:
+        children = []
+
+    for child in children:
+        _apply(child, state)

tklive-0.1.0/tklive.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: tklive
+Version: 0.1.0
+Summary: Live hot-reload for tkinter and customtkinter apps
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/tklive
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: watchdog>=3.0.0
+Dynamic: license-file
+
+# tklive
+
+Live hot-reload für tkinter und customtkinter Apps.  
+Speichere deine Datei → UI updated sich sofort ohne das Fenster zu schließen.
+
+## Installation
+
+```bash
+pip install tklive
+```
+
+## Verwendung
+
+Füge **zwei Zeilen** zu deinem Projekt hinzu:
+
+```python
+import tkinter as tk
+from tklive import live
+
+root = tk.Tk()
+
+# ... dein gesamter normaler Code bleibt unverändert ...
+
+live(root, __file__)  # ← eine Zeile ans Ende
+root.mainloop()
+```
+
+Speichere die Datei → UI reloaded live. Oder **Ctrl+R** für manuellen Reload.
+
+## Features
+
+- ✅ Fenster bleibt offen – kein Neustart
+- ✅ State-Erhalt (Entry, Text, Tabs, Scrollposition, Fenstergröße)
+- ✅ customtkinter Support (CTkEntry, CTkTextbox, CTkSlider, CTkTabview ...)
+- ✅ ttk Support (Notebook, Treeview, Combobox ...)
+- ✅ Multi-File Support
+
+## Mehrere Dateien beobachten
+
+```python
+live(root, __file__, watch_files=["ui.py", "components.py"])
+```
+
+## Lizenz
+
+MIT

tklive-0.1.0/tklive.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+tklive/__init__.py
+tklive/core.py
+tklive/state.py
+tklive.egg-info/PKG-INFO
+tklive.egg-info/SOURCES.txt
+tklive.egg-info/dependency_links.txt
+tklive.egg-info/requires.txt
+tklive.egg-info/top_level.txt

tklive-0.1.0/tklive.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tklive-0.1.0/tklive.egg-info/requires.txt

@@ -0,0 +1 @@
+watchdog>=3.0.0

tklive-0.1.0/tklive.egg-info/top_level.txt

@@ -0,0 +1 @@
+tklive