passlocker-tk 1.0.0__py3-none-any.whl

passlocker_tk/__init__.py

@@ -0,0 +1,3 @@
+from .gui import PassLockerGui
+
+__all__ = ["PassLockerGui"]

passlocker_tk/__main__.py

@@ -0,0 +1,8 @@
+from .gui import PassLockerGui
+
+def main() -> None:
+    app: PassLockerGui = PassLockerGui()
+    app.mainloop()
+
+if __name__ == "__main__":
+    main()

passlocker_tk/dialogs/__init__.py

@@ -0,0 +1,16 @@
+from .password_dialog import PasswordDialog
+from .accounts_table import AccountsTable
+from .new_password_account_dialog import NewPasswordAccountDialog
+from .new_otp_account_dialog import NewOTPAccountDialog
+from .new_totp_account_dialog import NewTOTPAccountDialog
+from .about_dialog import AboutDialog
+
+__all__ = [
+    "PasswordDialog",
+    "AccountsTable",
+    "NewPasswordAccountDialog",
+    "NewOTPAccountDialog",
+    "NewTOTPAccountDialog",
+    "AboutDialog",
+    "PasswordDialog",
+]

passlocker_tk/dialogs/about_dialog.py

@@ -0,0 +1,88 @@
+import customtkinter as ctk
+import webbrowser
+
+
+class AboutDialog(ctk.CTkToplevel):
+    def __init__(
+        self,
+        parent,
+        *,
+        title,
+        version,
+        author,
+        github_url,
+        description,
+    ):
+        super().__init__(parent)
+
+        self.title("About")
+        self.resizable(False, False)
+
+        # Modal
+        self.transient(parent)
+        self.grab_set()
+
+        self._build_ui(
+            title=title,
+            version=version,
+            author=author,
+            github_url=github_url,
+            description=description,
+        )
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self.destroy())
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self, *, title, version, author, github_url, description):
+        frame = ctk.CTkFrame(self)
+        frame.pack(padx=24, pady=24)
+
+        # Title
+        ctk.CTkLabel(frame, text=title, font=ctk.CTkFont(size=20, weight="bold")).pack(
+            anchor="w"
+        )
+
+        # Version / Author
+        ctk.CTkLabel(frame, text=f"Version {version}\n{author}", justify="left").pack(
+            anchor="w", pady=(4, 12)
+        )
+
+        # Description
+        ctk.CTkLabel(frame, text=description, justify="left", wraplength=420).pack(
+            anchor="w", pady=(0, 12)
+        )
+
+        # GitHub link
+        self._link(frame, text="Source code on GitHub", url=github_url).pack(
+            anchor="w", pady=(0, 6)
+        )
+
+        # License link
+        self._link(
+            frame,
+            text="Licensed under CC-BY-NC-SA-4.0",
+            url="https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode",
+        ).pack(anchor="w", pady=(0, 16))
+
+        # Close button
+        ctk.CTkButton(frame, text="Close", width=120, command=self.destroy).pack(
+            anchor="e"
+        )
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _link(self, parent, *, text, url):
+        lbl = ctk.CTkLabel(parent, text=text, text_color="#4ea1ff", cursor="hand2")
+        lbl.bind("<Button-1>", lambda _: webbrowser.open(url))
+        return lbl
+
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")

passlocker_tk/dialogs/account_display_dialog.py

@@ -0,0 +1,138 @@
+import customtkinter as ctk
+import tkinter as tk
+from hashlib import sha256
+from secrets import token_bytes
+
+from passlocker.models.account import Account
+
+
+class AccountDisplayDialog(ctk.CTkToplevel):
+    def __init__(self, parent, *, account: Account):
+        super().__init__(parent)
+
+        self.title("Password Record")
+        self.resizable(False, False)
+
+        self.account: Account = account
+
+        self._revealed = False
+        self.iv: bytes = b""
+        self.passhash: str = ""
+
+        # Modal behavior
+        self.transient(parent)
+        self.wait_visibility()
+        self.grab_set()
+
+        self._build_ui()
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self.destroy())
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self):
+        container: ctk.CTkFrame = ctk.CTkFrame(self)
+        container.pack(padx=10, pady=10)
+
+        # Account
+        ctk.CTkLabel(container, text="Account").grid(
+            row=0, column=0, sticky="w", padx=5
+        )
+        ctk.CTkLabel(
+            container, text=self.account.account, font=ctk.CTkFont(weight="bold")
+        ).grid(row=0, column=1, sticky="w")
+
+        # Username
+        ctk.CTkLabel(container, text="Username").grid(
+            row=1, column=0, sticky="w", padx=5
+        )
+        ctk.CTkLabel(container, text=self.account.username).grid(
+            row=1, column=1, sticky="w"
+        )
+
+        # Created on
+        ctk.CTkLabel(container, text="Created").grid(
+            row=2, column=0, sticky="w", padx=5
+        )
+        ctk.CTkLabel(container, text=self.account.created_on).grid(
+            row=2, column=1, sticky="w"
+        )
+
+        # Password
+        ctk.CTkLabel(container, text="Password").grid(
+            row=3, column=0, sticky="w", padx=5
+        )
+
+        self.password_var: ctk.StringVar = ctk.StringVar(value="••••••••")
+        self.password_label: ctk.CTkLabel = ctk.CTkLabel(
+            container, textvariable=self.password_var, font=ctk.CTkFont(size=14)
+        )
+        self.password_label.grid(row=3, column=1, sticky="w")
+
+        # Buttons
+        btn_frame: ctk.CTkFrame = ctk.CTkFrame(container, fg_color="transparent")
+        btn_frame.grid(row=4, column=1, sticky="w", pady=(10, 0))
+
+        self.reveal_btn: ctk.CTkButton = ctk.CTkButton(
+            btn_frame, text="Show Password", width=100, command=self.toggle_reveal
+        )
+        self.reveal_btn.grid(row=0, column=0, padx=(0, 10))
+
+        self.copy_btn: ctk.CTkButton = ctk.CTkButton(
+            btn_frame, text="Copy to Clipboard", width=100, command=self.copy_password
+        )
+        self.copy_btn.grid(row=0, column=1)
+
+        container.grid_columnconfigure(1, weight=1)
+
+    # --------------------
+    # Actions
+    # --------------------
+    def toggle_reveal(self):
+        self._revealed = not self._revealed
+
+        if self._revealed:
+            password: bytes = self.account.get_active_password()
+            self.password_var.set(password.decode("utf-8"))
+            self.reveal_btn.configure(text="Hide")
+        else:
+            self.password_var.set("••••••••")
+            self.reveal_btn.configure(text="Reveal")
+
+    def copy_password(self):
+        self.clipboard_clear()
+        password: bytes = self.account.get_active_password()
+        self.iv: bytes = token_bytes(16)
+        self.passhash: str = sha256(self.iv + password).hexdigest()
+        self.clipboard_append(password.decode("utf-8"))
+        self.update()  # ensure clipboard is updated
+        self._schedule_clipboard_clear()
+
+    def _schedule_clipboard_clear(self, delay_ms=15000):
+        self.after(delay_ms, self._clear_clipboard)
+
+    def _clear_clipboard(self):
+        try:
+            checkhash: str = sha256(
+                self.iv + self.clipboard_get().encode("utf-8")
+            ).hexdigest()
+            if checkhash == self.passhash:
+                self.clipboard_clear()
+        except tk.TclError:
+            pass
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _center(self, parent):
+        self.update_idletasks()
+        x: int = (
+            parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        )
+        y: int = (
+            parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        )
+        self.geometry(f"+{x}+{y}")

passlocker_tk/dialogs/accounts_table.py

@@ -0,0 +1,65 @@
+import customtkinter as ctk
+import tkinter as tk
+from tkinter import ttk
+from passlocker.models.account import Account
+from .account_display_dialog import AccountDisplayDialog
+
+
+class AccountsTable(ctk.CTkFrame):
+    def __init__(self, parent: ctk.CTk) -> None:
+        super().__init__(parent)
+
+        columns = ("account", "username", "type")
+
+        self.tree: ttk.Treeview = ttk.Treeview(
+            self, columns=columns, show="headings", height=10
+        )
+
+        # Column definitions
+        self.tree.heading("account", text="Account")
+        self.tree.heading("username", text="Username")
+        self.tree.heading("type", text="Type")
+
+        self.tree.column("account", anchor="w", width=200)
+        self.tree.column("username", anchor="w", width=180)
+        self.tree.column("type", anchor="center", width=80)
+
+        # Scrollbar
+        scrollbar = ttk.Scrollbar(self, orient="vertical", command=self.tree.yview)
+        self.tree.configure(yscrollcommand=scrollbar.set)
+
+        # Layout
+        self.tree.grid(row=0, column=0, sticky="nsew")
+        scrollbar.grid(row=0, column=1, sticky="ns")
+
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+
+        self.tree.bind("<Double-1>", self.on_open_account)
+        self._accounts_by_id: dict[int, Account] = {}
+
+    # --------------------
+    # Public API
+    # --------------------
+    def populate(self, accounts: list[Account]) -> None:
+        """
+        accounts: iterable of objects or dicts
+        expected fields: account, username, type
+        """
+        self.tree.delete(*self.tree.get_children())
+
+        for acc in accounts:
+            self.tree.insert(
+                "", "end", iid=id(acc), values=(acc.account, acc.username, acc.type)
+            )
+        self._accounts_by_id: dict[int, Account] = {id(acc): acc for acc in accounts}
+
+    def on_open_account(self, event: tk.Event) -> None:
+        selected = self.tree.selection()
+        if not selected:
+            return
+        item_id = int(selected[0])
+        account = self._accounts_by_id.get(item_id)
+        if account is None:
+            return
+        _ = AccountDisplayDialog(self, account=account)

passlocker_tk/dialogs/generate_password_dialog.py

@@ -0,0 +1,209 @@
+import customtkinter as ctk
+from tkinter import ttk
+import secrets
+
+
+class GeneratePasswordDialog(ctk.CTkToplevel):
+    def __init__(self, parent) -> None:
+        super().__init__(parent)
+
+        self.title("Generate Password")
+        self.resizable(False, False)
+
+        self.result: str | None = None
+
+        # Modal behavior
+        self.transient(parent)
+        self.wait_visibility()
+        self.grab_set()
+
+        self._build_ui()
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self._cancel())
+
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self) -> None:
+        root = ctk.CTkFrame(self)
+        root.pack(padx=20, pady=20)
+
+        # ---- Controls ----
+        controls = ctk.CTkFrame(root)
+        controls.pack(fill="x")
+
+        # Algorithm selector
+        ctk.CTkLabel(controls, text="Algorithm").grid(row=0, column=0, sticky="w")
+
+        self.algorithm_var = ctk.StringVar(value="random")
+        self.algorithm_menu = ctk.CTkOptionMenu(
+            controls,
+            variable=self.algorithm_var,
+            values=["random", "memorable", "numeric"],
+            width=140,
+        )
+        self.algorithm_menu.grid(row=0, column=1, padx=(10, 20))
+
+        # Length selector
+        ctk.CTkLabel(controls, text="Length").grid(row=0, column=2, sticky="w")
+
+        self.length_var = ctk.IntVar(value=16)
+        self.length_slider = ctk.CTkSlider(
+            controls, from_=8, to=64, number_of_steps=56, command=self._on_length_change
+        )
+        self.length_slider.set(16)
+        self.length_slider.grid(row=0, column=3, padx=(10, 10))
+
+        self.length_label = ctk.CTkLabel(controls, text="16", width=32, anchor="e")
+        self.length_label.grid(row=0, column=4)
+
+        controls.grid_columnconfigure(3, weight=1)
+
+        # Generate button
+        self.generate_btn = ctk.CTkButton(root, text="Generate", command=self._generate)
+        self.generate_btn.pack(pady=(10, 10))
+
+        # ---- Table ----
+        table_frame = ctk.CTkFrame(root)
+        table_frame.pack()
+
+        self.tree = ttk.Treeview(
+            table_frame, columns=("password",), show="headings", height=10
+        )
+        self.tree.heading("password", text="Generated Password")
+        self.tree.column("password", anchor="w", width=320)
+
+        scrollbar = ttk.Scrollbar(
+            table_frame, orient="vertical", command=self.tree.yview
+        )
+        self.tree.configure(yscrollcommand=scrollbar.set)
+
+        self.tree.grid(row=0, column=0, sticky="nsew")
+        scrollbar.grid(row=0, column=1, sticky="ns")
+
+        table_frame.grid_rowconfigure(0, weight=1)
+        table_frame.grid_columnconfigure(0, weight=1)
+
+        # Double-click selection
+        self.tree.bind("<Double-1>", self._on_select)
+
+    # --------------------
+    # Actions
+    # --------------------
+    def _on_length_change(self, value):
+        self.length_label.configure(text=str(int(value)))
+
+    def _generate(self):
+        algorithm = self.algorithm_var.get()
+        length = self.length_var.get()
+
+        passwords = self.generate_passwords(algorithm, length, count=10)
+        self.tree.delete(*self.tree.get_children())
+
+        for pw in passwords:
+            self.tree.insert("", "end", values=(pw,))
+
+    def _on_select(self, event):
+        selection = self.tree.selection()
+        if not selection:
+            return
+
+        self.result = self.tree.item(selection[0], "values")[0]
+        self.destroy()
+
+    def _cancel(self):
+        self.result = None
+        self.destroy()
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")
+
+    def generate_passwords(
+        self, algorithm: str, length: int, count: int = 10
+    ) -> list[str]:
+        if algorithm == "memorable":
+            return [self.generate_memorable(length) for _ in range(count)]
+        elif algorithm == "random":
+            return [self.generate_random(length) for _ in range(count)]
+        elif algorithm == "numeric":
+            return [self.generate_numbers(length) for _ in range(count)]
+        else:
+            raise Exception(f"Unknown generation algorithm: {algorithm}")
+
+    def generate_memorable(self, length: int) -> str:
+        if length <= 8:
+            maxnum = 100
+            special = 0
+        elif length <= 16:
+            maxnum = 1000
+            special = 1
+        elif length <= 24:
+            maxnum = 10000
+            special = 2
+        else:
+            maxnum = 100000
+            special = 3
+
+        random_int: int = secrets.randbelow(maxnum)
+        random_special: str = "".join(
+            secrets.choice(
+                [
+                    "!",
+                    "@",
+                    "#",
+                    "$",
+                    "%",
+                    "^",
+                    "&",
+                    "*",
+                    "(",
+                    ")",
+                    "-",
+                    "_",
+                    "+",
+                    "=",
+                    "{",
+                    "}",
+                    "[",
+                    "]",
+                    ":",
+                    ";",
+                    "<",
+                    ">",
+                    ".",
+                    ",",
+                    "?",
+                    "/",
+                    "~",
+                    "`",
+                ]
+            )
+            for i in range(special)
+        )
+
+        secret_sauce = f"{random_int}{random_special}"
+        password: str = ""
+
+        with open("/usr/share/dict/words") as f:
+            words: list[str] = [word.strip() for word in f]
+            genlen: int = 0
+            while genlen != length:
+                password = secret_sauce.join(secrets.choice(words) for _ in range(2))
+                genlen = len(password)
+
+        return password
+
+    def generate_random(self, length: int) -> str:
+        return secrets.token_urlsafe(32)[0:length]
+
+    def generate_numbers(self, length: int) -> str:
+        return "".join([str(secrets.choice(range(10))) for i in range(length)])

passlocker_tk/dialogs/new_otp_account_dialog.py

@@ -0,0 +1,94 @@
+import customtkinter as ctk
+
+
+class NewOTPAccountDialog(ctk.CTkToplevel):
+    def __init__(self, parent):
+        super().__init__(parent)
+
+        self.title("New Account")
+        self.resizable(False, False)
+
+        self.result = None
+
+        # Modal behavior
+        self.transient(parent)
+        self.grab_set()
+
+        self._build_ui()
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self._cancel())
+        self.bind("<Return>", lambda _: self._ok())
+
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self):
+        frame = ctk.CTkFrame(self)
+        frame.pack(padx=20, pady=20)
+
+        # Variables
+        self.account_var = ctk.StringVar()
+        self.username_var = ctk.StringVar()
+
+        # Account name
+        ctk.CTkLabel(frame, text="Account").grid(row=0, column=0, sticky="w")
+        self.account_entry = ctk.CTkEntry(
+            frame, textvariable=self.account_var, width=260
+        )
+        self.account_entry.grid(row=0, column=1, pady=5)
+        self.account_entry.focus()
+
+        # Username
+        ctk.CTkLabel(frame, text="Username").grid(row=1, column=0, sticky="w")
+        ctk.CTkEntry(frame, textvariable=self.username_var, width=260).grid(
+            row=1, column=1, pady=5
+        )
+
+        # Password
+        ctk.CTkLabel(frame, text="Passwords").grid(row=2, column=0, sticky="w")
+        self.password_entry = ctk.CTkTextbox(frame, width=260, height=112)
+        self.password_entry.grid(row=2, column=1, pady=5)
+
+        # Buttons
+        btn_frame = ctk.CTkFrame(frame, fg_color="transparent")
+        btn_frame.grid(row=3, column=1, pady=(15, 0), sticky="e")
+
+        ctk.CTkButton(btn_frame, text="Cancel", width=100, command=self._cancel).grid(
+            row=0, column=0, padx=(0, 10)
+        )
+
+        self.ok_btn = ctk.CTkButton(btn_frame, text="OK", width=100, command=self._ok)
+        self.ok_btn.grid(row=0, column=1)
+
+        frame.grid_columnconfigure(1, weight=1)
+
+    def _ok(self):
+        account = self.account_var.get().strip()
+        username = self.username_var.get().strip()
+        password = self.password_entry.get("0.0", ctk.END)
+
+        if not account or not password:
+            return  # minimal validation; extend as needed
+
+        self.result = {
+            "account": account,
+            "username": username,
+            "password": password,
+        }
+        self.destroy()
+
+    def _cancel(self):
+        self.result = None
+        self.destroy()
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")

passlocker_tk/dialogs/new_password_account_dialog.py

@@ -0,0 +1,126 @@
+import customtkinter as ctk
+from .generate_password_dialog import GeneratePasswordDialog
+
+
+class NewPasswordAccountDialog(ctk.CTkToplevel):
+    def __init__(self, parent):
+        super().__init__(parent)
+
+        self.title("New Account")
+        self.resizable(False, False)
+
+        self.result = None
+
+        # Modal behavior
+        self.transient(parent)
+        self.wait_visibility()
+        self.grab_set()
+
+        self._build_ui()
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self._cancel())
+        self.bind("<Return>", lambda _: self._ok())
+
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self):
+        frame = ctk.CTkFrame(self)
+        frame.pack(padx=20, pady=20)
+
+        # Variables
+        self.account_var = ctk.StringVar()
+        self.username_var = ctk.StringVar()
+        self.password_var = ctk.StringVar()
+
+        # Account name
+        ctk.CTkLabel(frame, text="Account").grid(row=0, column=0, sticky="w")
+        self.account_entry = ctk.CTkEntry(
+            frame, textvariable=self.account_var, width=260
+        )
+        self.account_entry.grid(row=0, column=1, pady=5)
+        self.account_entry.focus()
+
+        # Username
+        ctk.CTkLabel(frame, text="Username").grid(row=1, column=0, sticky="w")
+        ctk.CTkEntry(frame, textvariable=self.username_var, width=260).grid(
+            row=1, column=1, pady=5
+        )
+
+        # Password
+        ctk.CTkLabel(frame, text="Password").grid(row=2, column=0, sticky="w")
+        self.password_entry = ctk.CTkEntry(
+            frame, textvariable=self.password_var, show="•", width=260
+        )
+        self.password_entry.grid(row=2, column=1, pady=5)
+
+        self.reveal_btn = ctk.CTkButton(
+            frame, text="Reveal", width=80, command=self._toggle_reveal
+        )
+        self.reveal_btn.grid(row=2, column=2, padx=(5, 0))
+
+        # Buttons
+        btn_frame = ctk.CTkFrame(frame, fg_color="transparent")
+        btn_frame.grid(row=3, column=1, pady=(15, 0), sticky="e")
+
+        ctk.CTkButton(btn_frame, text="Cancel", width=100, command=self._cancel).grid(
+            row=0, column=0, padx=(0, 10)
+        )
+
+        self.ok_btn = ctk.CTkButton(btn_frame, text="OK", width=100, command=self._ok)
+        self.ok_btn.grid(row=0, column=1)
+
+        self.generate_btn = ctk.CTkButton(
+            btn_frame, text="Generate", width=100, command=self._generate
+        )
+        self.generate_btn.grid(row=0, column=2)
+
+        frame.grid_columnconfigure(1, weight=1)
+
+    # --------------------
+    # Actions
+    # --------------------
+    def _toggle_reveal(self):
+        if self.password_entry.cget("show"):
+            self.password_entry.configure(show="")
+            self.reveal_btn.configure(text="Hide")
+        else:
+            self.password_entry.configure(show="•")
+            self.reveal_btn.configure(text="Reveal")
+
+    def _ok(self):
+        account = self.account_var.get().strip()
+        username = self.username_var.get().strip()
+        password = self.password_var.get()
+
+        if not account or not password:
+            return  # minimal validation; extend as needed
+
+        self.result = {
+            "account": account,
+            "username": username,
+            "password": password,
+        }
+        self.destroy()
+
+    def _cancel(self) -> None:
+        self.result = None
+        self.destroy()
+
+    def _generate(self) -> None:
+        dlg = GeneratePasswordDialog(self)
+        password: str | None = dlg.result
+        if password is not None:
+            self.password_var.set(password)
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")

passlocker_tk/dialogs/new_totp_account_dialog.py

@@ -0,0 +1,147 @@
+# otpauth://totp/ACME%20Co:john.doe@email.com?secret=HXDMVJECJJWSRB3HWIZR4IFUGFTMXBOZ&issuer=ACME%20Co&algorithm=SHA1&digits=6&period=30
+import customtkinter as ctk
+from urllib.parse import urlparse, parse_qs, unquote
+
+
+class NewTOTPAccountDialog(ctk.CTkToplevel):
+    DEFAULTS = {
+        "algorithm": "SHA1",
+        "period": 30,
+        "digits": 6,
+    }
+
+    def __init__(self, parent):
+        super().__init__(parent)
+
+        self.title("New TOTP Account")
+        self.resizable(False, False)
+
+        self.result = None
+
+        # Modal
+        self.transient(parent)
+        self.grab_set()
+
+        self._build_ui()
+        self._center(parent)
+
+        self.bind("<Return>", lambda _: self._ok())
+        self.bind("<Escape>", lambda _: self._cancel())
+
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self):
+        frame = ctk.CTkFrame(self)
+        frame.pack(padx=20, pady=20)
+
+        ctk.CTkLabel(frame, text="otpauth:// URL", anchor="w").grid(
+            row=0, column=0, sticky="w"
+        )
+
+        self.url_var = ctk.StringVar()
+
+        self.entry = ctk.CTkEntry(frame, textvariable=self.url_var, width=420)
+        self.entry.grid(row=1, column=0, columnspan=2, pady=(5, 0))
+        self.entry.focus()
+
+        self.error_label = ctk.CTkLabel(frame, text="", text_color="red")
+        self.error_label.grid(row=2, column=0, columnspan=2, pady=(5, 0), sticky="w")
+
+        # Buttons
+        btn_frame = ctk.CTkFrame(frame, fg_color="transparent")
+        btn_frame.grid(row=3, column=1, pady=(15, 0), sticky="e")
+
+        ctk.CTkButton(btn_frame, text="Cancel", width=100, command=self._cancel).grid(
+            row=0, column=0, padx=(0, 10)
+        )
+
+        ctk.CTkButton(btn_frame, text="OK", width=100, command=self._ok).grid(
+            row=0, column=1
+        )
+
+        frame.grid_columnconfigure(0, weight=1)
+
+    # --------------------
+    # Actions
+    # --------------------
+    def _ok(self):
+        url = self.url_var.get().strip()
+
+        try:
+            self.result = self._parse_otpauth_url(url)
+        except ValueError as e:
+            self.error_label.configure(text=str(e))
+            return
+
+        self.destroy()
+
+    def _cancel(self):
+        self.result = None
+        self.destroy()
+
+    # --------------------
+    # Parsing / Validation
+    # --------------------
+    def _parse_otpauth_url(self, url: str) -> dict[str, str | int]:
+        parsed = urlparse(url)
+
+        if parsed.scheme != "otpauth":
+            raise ValueError("URL must start with otpauth://")
+
+        if parsed.netloc.lower() != "totp":
+            raise ValueError("Only otpauth://totp/ URLs are supported")
+
+        # Path: /AccountName:Username
+        label = unquote(parsed.path.lstrip("/"))
+        if ":" not in label:
+            raise ValueError("URL must include account name and username")
+
+        account_name, username = label.split(":", 1)
+        if not account_name or not username:
+            raise ValueError("Account name and username must be non-empty")
+
+        params: dict[str, list[str]] = parse_qs(parsed.query)
+
+        if "secret" not in params:
+            raise ValueError("URL is missing secret parameter")
+
+        secret = params["secret"][0]
+        if not secret:
+            raise ValueError("Secret must be non-empty")
+
+        # Optional parameters
+        algorithm: str = params.get("algorithm", [self.DEFAULTS["algorithm"]])[
+            0
+        ].upper()  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+        period: int = int(params.get("period", [self.DEFAULTS["period"]])[0])
+        digits: int = int(params.get("digits", [self.DEFAULTS["digits"]])[0])
+
+        if algorithm not in {"SHA1", "SHA256", "SHA512"}:
+            raise ValueError(f"Unsupported algorithm: {algorithm}")
+
+        if period <= 0:
+            raise ValueError("Period must be a positive integer")
+
+        if digits not in {6, 8}:
+            raise ValueError("Digits must be 6 or 8")
+
+        return {
+            "account": account_name,
+            "username": username,
+            "secret": secret.upper(),
+            "algorithm": algorithm.lower(),
+            "period": period,
+            "digits": digits,
+        }
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")

passlocker_tk/dialogs/password_dialog.py

@@ -0,0 +1,48 @@
+import customtkinter as ctk
+
+
+class PasswordDialog(ctk.CTkToplevel):
+    def __init__(self, parent, title="Enter Password"):
+        super().__init__(parent)
+
+        self.title(title)
+        self.resizable(False, False)
+
+        self.password = None
+
+        # Make dialog modal
+        self.transient(parent)
+        self.wait_visibility()
+        self.grab_set()
+
+        # Layout
+        self.label = ctk.CTkLabel(self, text="Password:")
+        self.label.pack(padx=20, pady=(20, 5))
+
+        self.var = ctk.StringVar()
+        self.entry = ctk.CTkEntry(self, textvariable=self.var, show="•", width=220)
+        self.entry.pack(padx=20, pady=5)
+        self.entry.focus()
+
+        self.button = ctk.CTkButton(self, text="OK", command=self.on_ok)
+        self.button.pack(padx=20, pady=(10, 20))
+
+        # Keyboard bindings
+        self.bind("<Return>", lambda _: self.on_ok())
+        self.bind("<Escape>", lambda _: self.destroy())
+
+        # Center on parent
+        self._center(parent)
+
+        # Wait until dialog is closed
+        self.wait_window()
+
+    def on_ok(self):
+        self.password = self.var.get()
+        self.destroy()
+
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")

passlocker_tk/gui.py

@@ -0,0 +1,217 @@
+import tkinter as tk
+from tkinter import ttk
+from tkinter import Menu
+from tkinter.ttk import Style
+import customtkinter as ctk
+
+from debounce import debounce
+from passlocker.passlocker import PassLocker
+from passlocker.models.account import Account
+from .dialogs import (
+    AboutDialog,
+    AccountsTable,
+    NewOTPAccountDialog,
+    NewPasswordAccountDialog,
+    NewTOTPAccountDialog,
+    PasswordDialog,
+)
+
+from datetime import date
+
+ctk.set_window_scaling(1.5)  # UI scale
+ctk.set_widget_scaling(2.0)  # font + spacing scale
+ctk.set_appearance_mode("dark")
+ctk.set_default_color_theme("dark-blue")
+
+
+class PassLockerGui(ctk.CTk):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.pl: PassLocker = PassLocker(self.get_master_password)
+
+        self.set_style()
+        self.title("PassLocker GUI")
+        self.geometry("800x400")
+        self.default_font: ctk.CTkFont = ctk.CTkFont("Arial", size=14)
+
+        self.pnl: ctk.CTkFrame = ctk.CTkFrame(self)
+        label: ctk.CTkLabel = ctk.CTkLabel(
+            self.pnl, text="Search ", font=self.default_font
+        )
+
+        self.searchField: ctk.CTkEntry = ctk.CTkEntry(self.pnl, font=self.default_font)
+        self.searchField.bind("<KeyRelease>", self.search_changed)
+
+        label.pack(side=tk.LEFT)
+        self.searchField.pack(fill=tk.X)
+        self.pnl.pack(fill=tk.X)
+
+        self.create_menu()
+        self.list_passwords()
+        # self.createStatusBar()
+        # self.setStatusText("Welcome to PassLocker GUI!")
+
+    def set_style(self) -> None:
+        ctk.set_appearance_mode("dark")
+        ctk.set_default_color_theme("dark-blue")
+
+        # ui_font = tkfont.Font(family="Verdana", size=13)
+        style: Style = ttk.Style()
+        style.theme_use("default")
+        style.tk.call("tk", "scaling", 2.0)
+
+        style.configure(
+            "Treeview",
+            background="#242424",
+            fieldbackground="#242424",
+            foreground="#ffffff",
+            bordercolor="#444444",
+            borderwidth=0,
+            rowheight=32,
+            font=("Arial", 12),
+        )
+
+        style.configure(
+            "Treeview.Heading",
+            background="#1f1f1f",
+            foreground="#ffffff",
+            font=("Arial", 12, "bold"),
+        )
+
+        style.map(
+            "Treeview",
+            background=[("selected", "#1f6aa5")],
+            foreground=[("selected", "#ffffff")],
+        )
+
+    def get_master_password(
+        self, prompt: str
+    ) -> bytes:  # pyright: ignore[reportReturnType]
+        password: str | None = None
+        while password is None:
+            dlg: PasswordDialog = PasswordDialog(self, prompt)
+            password: str | None = dlg.password
+            if password:
+                return password.encode("utf-8")
+
+    def create_menu(self) -> None:
+        menubar: Menu = tk.Menu(
+            self,
+            background="#242424",
+            foreground="#ffffff",
+            activebackground="#1f6aa5",
+            activeforeground="#ffffff",
+            font=("Verdana", 14),
+        )
+        file_menu: Menu = tk.Menu(
+            menubar,
+            tearoff=0,
+            background="#242424",
+            foreground="#ffffff",
+            activebackground="#1f6aa5",
+            activeforeground="#ffffff",
+            font=("Verdana", 14),
+        )
+        help_menu: Menu = tk.Menu(
+            menubar,
+            tearoff=0,
+            background="#242424",
+            foreground="#ffffff",
+            activebackground="#1f6aa5",
+            activeforeground="#ffffff",
+            font=("Verdana", 14),
+        )
+
+        file_menu.add_command(
+            label="New Password Entry", command=self.on_new_password_entry
+        )
+        file_menu.add_command(label="New OTP Entry", command=self.on_new_otp_entry)
+        file_menu.add_command(label="New TOTP Entry", command=self.on_new_totp_entry)
+
+        menubar.add_cascade(label="File", menu=file_menu)
+
+        help_menu.add_command(label="About", command=self.on_about)
+
+        menubar.add_cascade(label="Help", menu=help_menu)
+        _ = self.config(menu=menubar)
+
+    def on_new_password_entry(self):
+        dlg: NewPasswordAccountDialog = NewPasswordAccountDialog(self)
+        account_data: dict[str, str] | None = dlg.result
+        if account_data:
+            created_on: str = date.today().strftime("%Y-%m-%d")
+            acc: Account = Account(
+                account_data["account"], account_data["username"], created_on
+            )
+            acc._passlocker = self.pl
+            acc.add_password(account_data["password"])
+            acc.save()
+
+    def on_new_otp_entry(self):
+        dlg: NewOTPAccountDialog = NewOTPAccountDialog(self)
+        account_data: dict[str, str] | None = dlg.result
+        if account_data:
+            created_on: str = date.today().strftime("%Y-%m-%d")
+            acc: Account = Account(
+                account_data["account"],
+                account_data["username"],
+                created_on,
+                type="otp",
+            )
+            acc._passlocker = self.pl
+            passwords: list[str] = account_data["password"].split("\n")
+            for password in passwords:
+                acc.add_password(password)
+            acc.save()
+
+    def on_new_totp_entry(self):
+        dlg: NewTOTPAccountDialog = NewTOTPAccountDialog(self)
+        account_data: dict[str, str | int] | None = dlg.result
+        created_on: str = date.today().strftime("%Y-%m-%d")
+        if account_data:
+            acc: Account = Account(
+                account=str(account_data["account"]),
+                username=str(account_data["username"]),
+                created_on=created_on,
+                active=0,
+                type="totp",
+                totp_epoch_start=0,
+                totp_time_interval=int(account_data["period"]),
+                totp_num_digits=int(account_data["digits"]),
+                totp_hash_algorithm=str(
+                    account_data["algorithm"]
+                ),  # pyright: ignore[reportArgumentType]
+            )
+            acc._passlocker = self.pl
+            acc.add_password(str(account_data["secret"]))
+            acc.save()
+
+    def on_about(self):
+        _ = AboutDialog(
+            parent=self,
+            title="Passlocker-Tk",
+            version="1.0.0",
+            author="© 2026 C L",
+            github_url="https://github.com/chrislee35/passlocker-tk",
+            description=(
+                "Passlocker is a secure, offline-first password and OTP manager "
+                "designed for transparency, control, and local ownership of secrets."
+            ),
+        )
+
+    @debounce(wait=0.3)
+    def search_changed(self, event: tk.Event):
+        filt: str = self.searchField.get()
+        accounts: list[Account] = [
+            acc
+            for acc in self.pl.accounts()
+            if filt in acc.account or filt in acc.username
+        ]
+        self.table.populate(accounts)
+
+    def list_passwords(self) -> None:
+        self.table: AccountsTable = AccountsTable(self)
+        self.table.pack(fill="both", expand=True, padx=10, pady=10)
+        accounts: list[Account] = [acc for acc in self.pl.accounts()]
+        self.table.populate(accounts)

passlocker_tk-1.0.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: passlocker-tk
+Version: 1.0.0
+Summary: Password Encryption GUI
+Author-email: Chris Lee <github@chrislee.dhs.org>
+License: CC-BY-NC-SA-4.0
+Project-URL: Homepage, https://github.com/chrislee35/passlocker-tk
+Keywords: encryption,passwords,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: passlocker>=1.0.2
+Requires-Dist: customtkinter>=5.2.2
+Requires-Dist: py-debounce>=0.1.2
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Dynamic: license-file
+
+# Overview
+
+PassLocker-Tk provides a Tkinter interface around using [Passlocker](https://github.com/chrislee35/passlocker), a local-first password management program.
+
+## Screenshot
+
+![Screenshot of Passlocker-Tk](imgs/screenshot-001.png)
+

passlocker_tk-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+passlocker_tk/__init__.py,sha256=fKkVqrrEEwG0GOF9LpJ2FE5NBi7MxWDnKg1jQ8qpQgo,59
+passlocker_tk/__main__.py,sha256=rRT1jqVsDqw56iLVj1t4pxF3XQUD2TpOK4vHbek17_Y,150
+passlocker_tk/gui.py,sha256=BQLba75OfO_0RS0ew-aNQ-uaSmNLxCI9GO00d5XyqnA,7237
+passlocker_tk/dialogs/__init__.py,sha256=Uy2-JWV-lB8JKyd_zRj5v8dMCkm2hafPM4vBRJ86dQ8,490
+passlocker_tk/dialogs/about_dialog.py,sha256=eHbroi1KqqgswhiQK3nKeeSAVO-61fhvej1BLPdSWEE,2451
+passlocker_tk/dialogs/account_display_dialog.py,sha256=5WRDIhxR7ifNd9CgDBqEl0wfgLweFhnwQkqxB-Lg0hM,4440
+passlocker_tk/dialogs/accounts_table.py,sha256=xKyRr3O5QUWroQv2Ocm9_buklK0AZ2QxvoFh6tbbqu0,2205
+passlocker_tk/dialogs/generate_password_dialog.py,sha256=_u0jh-VDYbsCExl3-ig5csbIIt0VPKv_8-Wb5l6vRso,6370
+passlocker_tk/dialogs/new_otp_account_dialog.py,sha256=AAdWKr0CTJEb4NEe9_9ze59e2UFOOJBLYtFfRgI-y2I,2865
+passlocker_tk/dialogs/new_password_account_dialog.py,sha256=QBBZrPTjEjzoSK07rEPjEWtgqsb5RJEeNvAAJetErJc,3971
+passlocker_tk/dialogs/new_totp_account_dialog.py,sha256=5lE6y6OFlJQ-3jA8xnFVUjxkjoWrdMrumFc2kKnv1Q0,4617
+passlocker_tk/dialogs/password_dialog.py,sha256=1yyOs9685GkU424r23-AxvJH0X153xgXT69BT23YyEc,1424
+passlocker_tk-1.0.0.dist-info/licenses/LICENSE,sha256=QpSZvCTowu2-PPT037J3-vehh3zhzqaLNuewDC_Pmq8,1180
+tests/create_demo.py,sha256=1bPehKcO29PR0Okfv4u8X6MkzGsVI-NAmHcSd5b2Zmk,480
+passlocker_tk-1.0.0.dist-info/METADATA,sha256=FreKef83PrLcFRY3dPCXPm582YNK5Xdt1565r6-RyUw,1064
+passlocker_tk-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+passlocker_tk-1.0.0.dist-info/entry_points.txt,sha256=soxCksphAO0Lh5BszrgWCpImbxAia5971pjn3WAS_C0,62
+passlocker_tk-1.0.0.dist-info/top_level.txt,sha256=C20iyX3dKT0W5juAHxbFC21sxoS46v08XDKYXxFUfTI,20
+passlocker_tk-1.0.0.dist-info/RECORD,,

passlocker_tk-1.0.0.dist-info/WHEEL

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

passlocker_tk-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+passlocker-tk = passlocker_tk.__main__:main

passlocker_tk-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License ("Public License").
+
+You may not use the material for commercial purposes.
+
+You are free to:
+- Share — copy and redistribute the material in any medium or format
+- Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+- Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made.
+- NonCommercial — You may not use the material for commercial purposes.
+- ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
+- No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
+
+For the full license text, see: https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
+
+SPDX-License-Identifier: CC-BY-NC-SA-4.0

passlocker_tk-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+passlocker_tk
+tests

tests/create_demo.py

@@ -0,0 +1,18 @@
+from passlocker_tk import PassLockerGui
+from passlocker.models.account import Account
+from generator_emails import GeneratorEmails
+
+app: PassLockerGui = PassLockerGui()
+accounts: list[Account] = []
+generator: GeneratorEmails = GeneratorEmails()
+created_on = "2026-01-01"
+for _ in range(10000):
+    accounts.append(
+        Account(
+            "MyService",
+            generator.generate_email(),
+            created_on
+        )
+    )
+app.table.populate(accounts)
+app.mainloop()