CTkFileDialog-plus 2.1.1__py3-none-any.whl

CTkFileDialog/core/__init__.py

@@ -0,0 +1,13 @@
+"""Core non-UI logic: filesystem, sorting, search."""
+from .filesystem import create_folder, get_file_info, list_directory, prompt_create_folder
+from .search import filter_by_query
+from .sorting import sort_files
+
+__all__ = [
+    "list_directory",
+    "create_folder",
+    "prompt_create_folder",
+    "get_file_info",
+    "sort_files",
+    "filter_by_query",
+]

CTkFileDialog/core/filesystem.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python
+"""Filesystem operations used by the dialogs."""
+from __future__ import annotations
+
+import os
+import time
+from typing import Any, Callable, List, Optional
+
+from CTkMessagebox import CTkMessagebox
+
+from ..system.platform import find_owner
+
+
+def list_directory(
+    path: str,
+    *,
+    method: str,
+    hidden: bool = False,
+    filetypes: Optional[List[str]] = None,
+) -> List[str]:
+    """Return names of entries in *path* filtered by dialog mode and options.
+
+    Directories are always included (unless hidden).  Files are included
+    unless the method is a pure directory-picker, and must match *filetypes*
+    when provided.
+    """
+    dir_only = method in ("askdirectory", "askdirectories")
+    result: List[str] = []
+    try:
+        for entry in os.scandir(path):
+            if entry.name.startswith(".") and not hidden:
+                continue
+            if entry.is_dir():
+                result.append(entry.name)
+            elif not dir_only and entry.is_file():
+                if not filetypes or any(entry.name.endswith(ext) for ext in filetypes):
+                    result.append(entry.name)
+    except (PermissionError, FileNotFoundError, OSError):
+        raise
+    return result
+
+
+def create_folder(parent: str, name: str) -> Optional[str]:
+    """Create a new folder under *parent*.
+
+    Returns the new path on success, or ``None`` on failure (after showing
+    a message box).  Raises nothing — errors are reported via UI.
+    """
+    name = (name or "").strip()
+    if not name:
+        return None
+    new_path = os.path.join(parent, name)
+    try:
+        os.makedirs(new_path, exist_ok=False)
+        return new_path
+    except FileExistsError:
+        CTkMessagebox(
+            message="A file or folder with that name already exists!",
+            title="Error",
+            icon="cancel",
+        )
+    except PermissionError:
+        CTkMessagebox(message="Permission denied!", title="Error", icon="cancel")
+    except OSError as e:
+        CTkMessagebox(
+            message=f"Could not create folder: {e}",
+            title="Error",
+            icon="cancel",
+        )
+    return None
+
+
+def get_file_info(path: str) -> str:
+    """Return a multi-line tooltip string for *path*."""
+    try:
+        st = os.stat(path)
+        owner = find_owner(path)
+        fecha = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(st.st_ctime))
+        return (
+            f"File: {os.path.basename(path)}\n"
+            f"    creation: {fecha}\n"
+            f"    owner: {owner}\n"
+            f"    path: {path}\n"
+            f"                    "
+        )
+    except Exception as e:
+        return f"Error getting info: {e}"
+
+
+def prompt_create_folder(parent_path: str, on_success: Optional[Callable[[], Any]] = None) -> None:
+    """Show an input dialog, create the folder, then call *on_success*."""
+    import customtkinter as ctk
+
+    dialog = ctk.CTkInputDialog(text="Enter new folder name:", title="New Folder")
+    name = dialog.get_input()
+    if create_folder(parent_path, name or "") and on_success:
+        on_success()

CTkFileDialog/core/search.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+"""Search / filter helpers."""
+from __future__ import annotations
+
+from typing import List
+
+
+def filter_by_query(files: List[str], query: str) -> List[str]:
+    """Case-insensitive substring filter on file names."""
+    q = (query or "").lower().strip()
+    if not q:
+        return list(files)
+    return [f for f in files if q in f.lower()]

CTkFileDialog/core/sorting.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+"""File sorting helpers."""
+from __future__ import annotations
+
+import os
+from typing import List
+
+
+def sort_files(files: List[str], current_path: str, sort_by: str = "name") -> List[str]:
+    """Sort *files* (names relative to *current_path*).
+
+    Directories always sort before files.  *sort_by* may be one of
+    ``name``, ``date``, ``type``, ``size``, ``modified``.
+    """
+
+    def info(filename: str) -> dict:
+        full = os.path.join(current_path, filename)
+        try:
+            st = os.stat(full)
+            return {
+                "name": filename.lower(),
+                "date": st.st_mtime,
+                "modified": st.st_mtime,
+                "type": os.path.splitext(filename)[1].lower(),
+                "size": st.st_size,
+                "is_dir": os.path.isdir(full),
+            }
+        except OSError:
+            return {
+                "name": filename.lower(),
+                "date": 0,
+                "modified": 0,
+                "type": "",
+                "size": 0,
+                "is_dir": os.path.isdir(full),
+            }
+
+    return sorted(
+        files,
+        key=lambda f: (not info(f)["is_dir"], info(f).get(sort_by, 0)),
+    )

CTkFileDialog/preview/__init__.py

@@ -0,0 +1,4 @@
+"""Media preview helpers (image / video). Extensible for future formats."""
+from .media import get_video_frame, is_image, is_video, thumbnail_image
+
+__all__ = ["is_image", "is_video", "get_video_frame", "thumbnail_image"]

CTkFileDialog/preview/media.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+"""Image and video detection / frame extraction.
+
+Architecture is ready for future PDF / audio preview plugins:
+register additional checkers via the same pattern (is_* + extract).
+"""
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+from PIL import Image
+
+_IMAGE_EXTENSIONS = frozenset(
+    {
+        ".bmp",
+        ".dib",
+        ".gif",
+        ".ico",
+        ".im",
+        ".jpg",
+        ".jpeg",
+        ".jpe",
+        ".pcx",
+        ".png",
+        ".ppm",
+        ".pbm",
+        ".pgm",
+        ".tif",
+        ".tiff",
+        ".webp",
+    }
+)
+
+_VIDEO_EXTENSIONS = frozenset(
+    {
+        ".avi",
+        ".mp4",
+        ".mov",
+        ".mkv",
+        ".webm",
+        ".flv",
+        ".wmv",
+        ".mpg",
+        ".mpeg",
+        ".3gp",
+        ".m4v",
+    }
+)
+
+
+def is_image(path: str) -> bool:
+    if not path or not os.path.isfile(path):
+        return False
+    if os.path.splitext(path)[1].lower() not in _IMAGE_EXTENSIONS:
+        return False
+    try:
+        with Image.open(path) as img:
+            img.verify()
+        return True
+    except Exception:
+        return False
+
+
+def is_video(path: str) -> bool:
+    if not path or not os.path.isfile(path):
+        return False
+    if os.path.splitext(path)[1].lower() not in _VIDEO_EXTENSIONS:
+        return False
+    try:
+        import cv2
+
+        cap = cv2.VideoCapture(path)
+        valid = cap.isOpened()
+        cap.release()
+        return valid
+    except Exception:
+        return False
+
+
+def get_video_frame(path: str, frame_number: int = 0) -> Optional[Image.Image]:
+    """Return a PIL Image of a single video frame, or None."""
+    if not path or not os.path.isfile(path):
+        return None
+
+    try:
+        import cv2
+    except ImportError:
+        return None
+
+    try:
+        cap = cv2.VideoCapture(path)
+        if not cap.isOpened():
+            return None
+
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+        if total_frames > 0:
+            if frame_number < 0:
+                frame_number = max(total_frames // 2, 0)
+            elif frame_number >= total_frames:
+                frame_number = max(total_frames - 1, 0)
+        else:
+            frame_number = 0
+
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+        ret, frame = cap.read()
+        cap.release()
+        if not ret or frame is None:
+            return None
+
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        return Image.fromarray(frame)
+    except Exception:
+        return None
+
+
+def thumbnail_image(path: str, size: tuple[int, int] = (32, 32)) -> Optional[Image.Image]:
+    """Open an image and return a thumbnail, or None on failure."""
+    if not path or not os.path.isfile(path):
+        return None
+    try:
+        with Image.open(path) as img:
+            img.thumbnail(size, Image.Resampling.LANCZOS)
+            return img.copy()
+    except Exception:
+        return None

CTkFileDialog/resources/__init__.py

@@ -0,0 +1,14 @@
+"""Static resources (icons)."""
+from .icons import (
+    EXTENSION_ICONS,
+    icon_for_extension,
+    load_default_icons,
+    load_mini_icons,
+)
+
+__all__ = [
+    "EXTENSION_ICONS",
+    "load_default_icons",
+    "load_mini_icons",
+    "icon_for_extension",
+]

CTkFileDialog/resources/icons.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+"""Icon loading for Default and Mini dialogs."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict
+
+import customtkinter as ctk
+from PIL import Image
+import tkinter as tk
+
+# Package root (CTkFileDialog/)
+_PACKAGE_DIR = Path(__file__).resolve().parent.parent
+_ICON_DIR = _PACKAGE_DIR / "icons"
+_MINI_ICON_DIR = _ICON_DIR / "_IconsMini"
+
+# Extension → icon key mapping used by Default dialog
+EXTENSION_ICONS: Dict[str, str] = {
+    ".webp": "webp",
+    ".awk": "bash",
+    ".mp4": "video",
+    ".mvk": "video",
+    ".sh": "bash",
+    ".zsh": "bash",
+    ".py": "python",
+    ".png": "image",
+    ".jpg": "image",
+    ".jpeg": "image",
+    ".txt": "text",
+    ".js": "javascript",
+    ".md": "markdown",
+    ".php": "php",
+    ".html": "html",
+    ".css": "css",
+    ".ini": "ini",
+    ".conf": "conf",
+    ".json": "json",
+    ".odt": "odt",
+    ".pdf": "pdf",
+    ".exe": "exe",
+    ".gz": "gz",
+}
+
+# Filename (without path) → logical name for Default CTkImage icons
+_DEFAULT_ICON_FILES = {
+    "folder": "folder.png",
+    "bash": "bash.png",
+    "image": "image.png",
+    "python": "python.png",
+    "text": "text.png",
+    "markdown": "markdown.png",
+    "javascript": "javascript.png",
+    "php": "php.png",
+    "html": "html.png",
+    "css": "css.png",
+    "ini": "ini.png",
+    "conf": "conf.png",
+    "exe": "exe.png",
+    "odt": "odt.png",
+    "pdf": "pdf.png",
+    "json": "json.png",
+    "gz": "gz.png",
+    "video": "video.png",
+    "awk": "bash.png",
+    "webp": "image.png",
+    "default": "text.png",
+}
+
+
+def load_default_icons(size: tuple[int, int] = (40, 40)) -> Dict[str, ctk.CTkImage]:
+    """Load all Default-dialog CTkImage icons."""
+    icons: Dict[str, ctk.CTkImage] = {}
+    for key, filename in _DEFAULT_ICON_FILES.items():
+        path = _ICON_DIR / filename
+        icons[key] = ctk.CTkImage(Image.open(path), size=size)
+    return icons
+
+
+def load_mini_icons() -> tuple[tk.PhotoImage, tk.PhotoImage]:
+    """Return (folder_image, file_image) for Mini dialog Treeview."""
+    folder = tk.PhotoImage(file=str(_MINI_ICON_DIR / "folder.png"))
+    file_img = tk.PhotoImage(file=str(_MINI_ICON_DIR / "file.png"))
+    return folder, file_img
+
+
+def icon_for_extension(ext: str, icons: Dict[str, ctk.CTkImage]) -> ctk.CTkImage:
+    """Resolve a CTkImage for a file extension."""
+    key = EXTENSION_ICONS.get(ext.lower(), "default")
+    return icons.get(key, icons["default"])

CTkFileDialog/system/__init__.py

@@ -0,0 +1,4 @@
+"""System / platform helpers."""
+from .platform import System, find_owner
+
+__all__ = ["System", "find_owner"]

CTkFileDialog/system/platform.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+"""Platform-specific utilities (owner lookup, path helpers)."""
+from __future__ import annotations
+
+import os
+import platform
+from pathlib import Path
+
+
+def find_owner(path) -> str:
+    """Return the owner of *path* (Unix or Windows)."""
+    system = platform.system()
+    path = str(path)
+
+    if system == "Windows":
+        return _get_windows_owner(path)
+    return _get_unix_owner(path)
+
+
+def _get_unix_owner(path: str) -> str:
+    try:
+        return Path(path).owner()
+    except Exception:
+        return "unknown:unknown"
+
+
+def _get_windows_owner(path: str) -> str:
+    import ctypes
+    from ctypes import wintypes
+
+    GetNamedSecurityInfoW = ctypes.windll.advapi32.GetNamedSecurityInfoW
+    LookupAccountSidW = ctypes.windll.advapi32.LookupAccountSidW
+    LocalFree = ctypes.windll.kernel32.LocalFree
+
+    OWNER_SECURITY_INFORMATION = 0x00000001
+    SE_FILE_OBJECT = 1
+
+    pSidOwner = ctypes.c_void_p()
+    pSD = ctypes.c_void_p()
+
+    result = GetNamedSecurityInfoW(
+        ctypes.c_wchar_p(path),
+        SE_FILE_OBJECT,
+        OWNER_SECURITY_INFORMATION,
+        ctypes.byref(pSidOwner),
+        None, None, None,
+        ctypes.byref(pSD),
+    )
+
+    if result != 0:
+        return "unknown"
+
+    name = ctypes.create_unicode_buffer(256)
+    domain = ctypes.create_unicode_buffer(256)
+    name_size = wintypes.DWORD(len(name))
+    domain_size = wintypes.DWORD(len(domain))
+    sid_name_use = wintypes.DWORD()
+
+    success = LookupAccountSidW(
+        None,
+        pSidOwner,
+        name,
+        ctypes.byref(name_size),
+        domain,
+        ctypes.byref(domain_size),
+        ctypes.byref(sid_name_use),
+    )
+
+    LocalFree(pSD)
+
+    if not success:
+        return "unknown"
+
+    return f"{name.value}"
+
+
+class System:
+    """Thin path helpers used by both Default and Mini dialogs."""
+
+    @staticmethod
+    def get_path(path=None) -> str:
+        if path is None:
+            path = os.getcwd()
+        return f"{path}" if path == os.getenv("HOME") else path
+
+    @staticmethod
+    def parse_path(path: str) -> str:
+        return os.path.abspath(os.path.expanduser(os.path.expandvars(path)))

CTkFileDialog/ui/__init__.py

@@ -0,0 +1,5 @@
+"""UI layer: Default and Mini dialogs."""
+from .default_dialog import DrawApp, _DrawApp
+from .mini_dialog import MiniDialog, _MiniDialog
+
+__all__ = ["DrawApp", "_DrawApp", "MiniDialog", "_MiniDialog"]