pic-select 1.0.1__py3-none-any.whl

pic_select/__main__.py

@@ -0,0 +1,9 @@
+from .pic_select import start
+
+
+
+def main():
+    start()
+
+if __name__ == "__main__":
+    main()

pic_select/gui/app.py

@@ -0,0 +1,115 @@
+import tkinter as tk
+
+from ..logic.input.UserInput import UserInput
+from ..logic.input.userInputHandler import UserInputHandler
+from ..logic.load.loader import Loader
+from ..logic.load.loaderThread import LoaderThread
+from ..logic.selector import Selector
+
+from .frames.displayFrame import DisplayFrame
+from .frames.displays.imageViewFrame import ImageViewFrame
+
+from .selectFile import ask_file_name
+
+
+
+_PADDING_PERCENT = 0.15
+
+_MIN_WINDOW_DIM =  int(25 / _PADDING_PERCENT) + 1
+
+
+
+class App(tk.Tk):
+
+    def __init__(
+            self,
+            title: str,
+            input_handler: UserInputHandler,
+            loader: Loader,
+            loader_thread: LoaderThread,
+            selector: Selector,
+            fullscreen = True):
+        super().__init__()
+
+        self.title(title)
+
+        self.minsize(_MIN_WINDOW_DIM, _MIN_WINDOW_DIM)
+        self.state("zoomed")
+        self.focus_force()
+        self.lift()
+
+        self.bind("<Left>", self._on_left_arrow)
+        self.bind("<Right>", self._on_right_arrow)
+        self.bind("<space>", self._on_space)
+        self.bind("<Control-c>", self._on_strg_c)
+        self.bind("<Control-C>", self._on_strg_c)
+        self.bind("<Control-a>", self._on_strg_a)
+        self.bind("<Control-A>", self._on_strg_a)
+        self.bind("<Control-t>", self._on_strg_t)
+        self.bind("<Control-T>", self._on_strg_t)
+        self.bind("<Control-o>", self._on_strg_o)
+        self.bind("<Control-O>", self._on_strg_o)
+        self.bind("<Escape>", self._on_escape)
+        self.bind("<F11>", self._on_f_11)
+
+        self._is_fullscreen = fullscreen
+        if self._is_fullscreen:
+            self.enter_fullscreen()
+
+        self._input_handler = input_handler
+
+        self._display_frame = DisplayFrame(master=self, loader_controller=loader_thread, selector=selector)
+        self._display_frame.pack(fill="both", expand=True)
+        self._display_frame.setup_displays(selector=selector, loader=loader)
+        self._display_frame.show_select_image()
+
+    @property
+    def display_frame(self) -> DisplayFrame:
+        return self._display_frame
+    
+    @property
+    def image_view_frame(self) -> ImageViewFrame:
+        return self._display_frame.image_view_frame
+
+    def _on_right_arrow(self, event) -> None:
+        self._input_handler.handle_input(input=UserInput.FORWARD)
+
+    def _on_left_arrow(self, event) -> None:
+        self._input_handler.handle_input(input=UserInput.BACKWARD)
+
+    def _on_space(self, event) -> None:
+        self._input_handler.handle_input(input=UserInput.SELECT)
+
+    def _on_strg_c(self, evetn) -> None:
+        self._input_handler.handle_input(input=UserInput.COPY)
+
+    def _on_strg_a(self, event) -> None:
+        self._input_handler.handle_input(input=UserInput.SELECT_ALL)
+    
+    def _on_escape(self, event) -> None:
+        self._input_handler.handle_input(input=UserInput.UNSELECT_ALL)
+
+    def _on_strg_t(self, event) -> None:
+        self.quit()
+
+    def _on_f_11(self, event) -> None:
+        self.toggle_fullscreen()
+
+    def _on_strg_o(self, event) -> None:
+        file = ask_file_name(parent=self)
+        self._input_handler.handle_input(input=UserInput.OPEN, file=file)
+
+    def toggle_fullscreen(self) -> None:
+        self._is_fullscreen = not self._is_fullscreen
+        self.attributes("-fullscreen", self._is_fullscreen)
+    
+    def enter_fullscreen(self) -> None:
+        self.attributes("-fullscreen", True)
+        self._is_fullscreen = True
+
+    def exit_fullscreen(self) -> None:
+        self.attributes("-fullscreen", False)
+        self._is_fullscreen = False
+
+    def quit(self) -> None:
+        self.destroy()

pic_select/gui/frames/components/borderedImageFrame.py

@@ -0,0 +1,35 @@
+import tkinter as tk
+from PIL import ImageTk
+
+from .paddedImageFrame import PaddedImageFrame
+
+
+
+class BorderedImageFrame(tk.Frame):
+
+    def __init__(self, master: tk.Widget, image: ImageTk.PhotoImage, padding: int, borderwidth: int):
+        full_width = image.width() + (padding * 2) + (borderwidth * 2)
+        full_height = image.height() + (padding * 2) + (borderwidth * 2)
+
+        super().__init__(master, width = full_width, height = full_height, borderwidth=0, highlightthickness=0)
+
+        self._border_frame = tk.Frame(master=self,
+                                      background="blue",
+                                      width=full_width,
+                                      height=full_height,
+                                      borderwidth=0,
+                                      highlightthickness=0)
+
+        self._padded_frame = PaddedImageFrame(master=self._border_frame, image=image, padding=padding)
+
+        self._padded_frame.place(x=borderwidth, y=borderwidth)
+        self._border_frame.place(x=0, y=0)
+
+        self.pack_propagate(False)
+
+
+
+
+
+
+

pic_select/gui/frames/components/imageFrame.py

@@ -0,0 +1,61 @@
+import tkinter as tk
+from PIL import Image, ImageTk
+from typing import Tuple
+import math
+
+from .borderedImageFrame import BorderedImageFrame
+
+
+
+_GAP_SIZE = 5
+_BORDER_SIZE = 7
+
+
+
+class ImageFrame(tk.Frame):
+
+    def __init__(self, master: tk.Widget, display_size: Tuple[int, int], image: Image.Image, selected: bool = False):
+        super().__init__(master=master, width=display_size[0], height=display_size[1])
+
+        image_bounds = display_size[0] - (_GAP_SIZE * 2) - (_BORDER_SIZE * 2), display_size[1] - (_GAP_SIZE * 2) - (_BORDER_SIZE * 2)
+        image_size = ImageFrame.calculate_max_inbound_size(image_bounds=image_bounds, full_size=(image.width, image.height))
+        resized_image = image.resize(image_size, resample=Image.Resampling.LANCZOS)
+        self._image = ImageTk.PhotoImage(image=resized_image)
+        resized_image.close()
+        
+        self._borderedFrame = BorderedImageFrame(master=self, image=self._image, padding=_GAP_SIZE, borderwidth=_BORDER_SIZE)
+        self._borderedFrame.place(relx=0.5, rely=0.5, anchor="center")
+
+        self._selected = selected
+
+        if self._selected:
+            self.select()
+        else:
+            self.unselect()
+
+        self.pack_propagate(False)
+
+    @staticmethod
+    def calculate_max_inbound_size(image_bounds: Tuple[int, int], full_size: Tuple[int, int]) -> Tuple[int, int]:
+        width_factor = image_bounds[0] / full_size[0]
+        height_factor = image_bounds[1] / full_size[1]
+        factor = min(width_factor, height_factor)
+        return (int(math.floor(full_size[0] * factor)), int(math.floor(full_size[1] * factor)))
+
+    @property
+    def selected(self) -> bool:
+        return self._selected
+
+    def select(self) -> None:
+        self._selected = True
+        self._borderedFrame._border_frame.configure(background="blue")
+
+    def unselect(self) -> None:
+        self._selected = False
+        self._borderedFrame._border_frame.configure(background="SystemButtonFace")
+
+    def toggle(self) -> None:
+        if self.selected:
+            self.unselect()
+        else:
+            self.select()

pic_select/gui/frames/components/paddedImageFrame.py

@@ -0,0 +1,24 @@
+import tkinter as tk
+from PIL import ImageTk
+
+
+
+class PaddedImageFrame(tk.Frame):
+
+    def __init__(self, master: tk.Widget, image: ImageTk.PhotoImage, padding: int):
+        full_width = image.width() + (padding * 2)
+        full_height =image.height() + (padding * 2)
+
+        super().__init__(master, width = full_width, height = full_height, borderwidth=0, highlightthickness=0)
+
+        self._pad_Frame = tk.Frame(master=self, width = full_width, height=full_height, borderwidth=0, highlightthickness=0)
+        self._image_label = tk.Label(master=self._pad_Frame, image=image, borderwidth=0, highlightthickness=0, padx=0, pady=0)
+
+        self._image_label.place(x=padding, y=padding)
+        self._pad_Frame.place(x=0, y=0)
+
+        self.pack_propagate(False)
+
+
+
+

pic_select/gui/frames/displayFrame.py

@@ -0,0 +1,90 @@
+import tkinter as tk
+from tkinter import ttk
+from typing import Tuple
+from pathlib import Path
+
+from ...logic.load.loaderThread import LoaderThread
+from ...logic.load.loader import Loader
+from ...logic.selector import Selector
+
+from .displays.selectImageFrame import SelectImageFrame
+from .displays.imageViewFrame import ImageViewFrame
+
+
+
+_PADDING_PIXELS = 70
+
+
+
+class DisplayFrame(ttk.Frame):
+
+    def __init__(self, master: tk.Widget, loader_controller: LoaderThread, selector: Selector):
+        super().__init__(master=master)
+
+        loader_controller.subscribe_on_busy(callback=self._on_loader_busy)
+        loader_controller.subscribe_on_idle(callback=self._on_loader_idle)
+
+        selector.subscribe_on_select(callback=self._on_select)
+
+        self._selection_count: tk.StringVar = tk.StringVar(self, f"{0:05}")
+        self._selection_count_label: tk.Label = tk.Label(master=self,
+                                                        textvariable=self._selection_count,
+                                                        font=("Arial", -20))
+        self._selection_count_label.place(relx=0, rely=0, anchor="nw")
+
+        self._loader_busy: tk.StringVar = tk.StringVar(self, "")
+        self._busy_indicator_label: tk.Label = tk.Label(master=self,
+                                                        textvariable=self._loader_busy,
+                                                        font=("Arial", -20))
+        self._busy_indicator_label.place(relx=0, rely=1, anchor="sw")
+
+        self._image_name: tk.StringVar = tk.StringVar(self, "")
+        self._image_name_label: tk.Label = tk.Label(master=self,
+                                                    textvariable=self._image_name,
+                                                    font=("Arial", -20))
+        self._image_name_label.place(relx=0.5, rely=1, anchor="s")
+
+        self._select_image_frame: SelectImageFrame = None
+        self._image_view_frame: ImageViewFrame = None
+
+    @property
+    def image_view_frame(self) -> ImageViewFrame:
+        return self._image_view_frame
+                
+    def _on_loader_busy(self) -> None:
+        self._loader_busy.set("Loading ...")
+
+    def _on_loader_idle(self) -> None:
+        self._loader_busy.set("")
+
+    def _on_new_image(self, path: Path) -> None:
+        self.show_image(path=path)
+
+    def _on_select(self, path: Path, selected: bool, count: int) -> None:
+        self._selection_count.set(f"{count:05}")
+
+    def setup_displays(self, selector: Selector, loader: Loader) -> None:
+        self.master.update_idletasks()
+
+        self._image_view_frame = ImageViewFrame(master=self, display_size=self.display_size(), selector=selector, loader=loader)
+        self._image_view_frame.place(relx=0.5, rely=0.5, anchor="center")
+        
+        self._select_image_frame = SelectImageFrame(master=self, display_size=self.display_size())
+        self._select_image_frame.place(relx=0.5, rely=0.5, anchor="center")
+
+    def display_size(self) -> Tuple[int, int]:
+        width, height = self.winfo_width(), self.winfo_height()
+        return width - _PADDING_PIXELS, height -_PADDING_PIXELS
+
+    def show_image(self, path: Path) -> None:
+        self._image_name.set(path.name)
+        self._image_view_frame.display_image_frame(path=path)
+        self._image_view_frame.tkraise()
+        self._image_view_frame.focus()
+
+    def show_select_image(self) -> None:
+        self._select_image_frame.tkraise()
+        self._select_image_frame.focus()
+
+    def set_image_name(self, path: Path) -> None:
+        self._image_name.set(path.name)

pic_select/gui/frames/displays/imageViewFrame.py

@@ -0,0 +1,108 @@
+import tkinter as tk
+from typing import Tuple, Dict, Self
+from pathlib import Path
+from collections.abc import Mapping
+from PIL import Image
+
+from ....logic.selector import Selector
+from ....logic.load.loader import Loader
+
+from ..components.imageFrame import ImageFrame
+from ..displays.loadFrame import LoadFrame
+
+
+
+class ImageViewFrame(tk.Frame, Mapping):
+
+    def __init__(self, master: tk.Widget, display_size: Tuple[int, int], selector: Selector, loader: Loader):
+        super().__init__(master=master, width=display_size[0], height=display_size[1])
+
+        self.pack_propagate(False)
+
+        loader.subscribe_on_load(callback=self._on_load)
+        loader.subscribe_on_unload(callback=self._on_unload)
+
+        selector.subscribe_on_select(callback=self._on_select)
+        
+        self._selector = selector
+
+        self._image_frames: Dict[Path, ImageFrame] = {}
+
+        self._current_image_path: Path = None
+
+        self._load_frame: LoadFrame = LoadFrame(master=self, display_size=display_size)
+        self._load_frame.place(relx=0.5, rely=0.5, anchor="center", )
+
+    def __getitem__(self, path: Path):
+        if path not in self._images:
+            raise KeyError(f"{path} is not framed")
+        return self._image_frames[path]
+
+    def __setitem__(self, path: Path, image: Image.Image):
+        raise RuntimeError("use ImageViewFrame.create_image_frame()")
+
+    def __delitem__(self, path: Path):
+        raise RuntimeError("use ImageViewFrame.remove_image_frame()")
+
+    def __contains__(self, path: Path):
+        return path in self._image_frames
+
+    def __iter__(self):
+        return iter(self._image_frames)
+
+    def __len__(self):
+        return len(self._image_frames)
+
+    def _on_load(self, path: Path, image: Image.Image) -> None:
+        self._create_image_frame(path=path, image=image)
+        if self._current_image_path == path:
+            self.display_image_frame(path=path)
+    
+    def _on_unload(self, unloaded: Path) -> None:
+        if unloaded is not None:
+            self.remove_image_frame(path=unloaded)
+
+    def _on_select(self, path: Path, selected: bool, count: int) -> None:
+        if path not in self._image_frames:
+            return None
+        if selected:
+            self._image_frames[path].select()
+        else:
+            self._image_frames[path].unselect()
+
+    def _create_image_frame(self, path: Path, image: Image.Image) -> Self:
+        self._image_frames[path] = ImageFrame(master=self,
+                                              display_size=(self.winfo_width(), self.winfo_height()),
+                                              image=image,
+                                              selected=self._selector.is_selected(path=path))
+        self._image_frames[path].place(relx=0.5, rely=0.5, anchor="center")
+
+        if self._current_image_path in self:
+            self._image_frames[self._current_image_path].tkraise()
+        else:
+            self._load_frame.tkraise()
+
+    @property
+    def current_image_path(self) -> Path:
+        return self._current_image_path
+
+    def remove_image_frame(self, path: Path) -> None:
+        self._image_frames.pop(path)
+
+    def display_image_frame(self, path: Path) -> None:
+        if path not in self:
+            self._load_frame.set_text(name=path.name)
+            self._load_frame.tkraise()
+        else:
+            self._image_frames[path].tkraise()
+        self._current_image_path = path
+
+    def select_all(self, unselect = False):
+        for frame in self._image_frames.values():
+            if unselect:
+                frame.unselect()
+            else:
+                frame.select()
+
+    def is_waiting_on_loader(self) -> bool:
+        return self._current_image_path not in self

pic_select/gui/frames/displays/loadFrame.py

@@ -0,0 +1,20 @@
+import tkinter as tk
+from typing import Tuple
+
+
+
+class LoadFrame(tk.Frame):
+
+    def __init__(self, master: tk.Widget, display_size: Tuple[int, int]):
+        super().__init__(master=master, width=display_size[0], height=display_size[1])
+
+        self.pack_propagate(False)
+
+        self._text: tk.StringVar = tk.StringVar(self)
+        self._label: tk.Label = tk.Label(master=self,
+                                         textvariable=self._text,
+                                         font=("Arial, 18"))
+        self._label.place(relx=0.5, rely=0.5, anchor=tk.CENTER)
+
+    def set_text(self, name: str) -> None:
+        self._text.set(f"loading image '{name}'")

pic_select/gui/frames/displays/selectImageFrame.py

@@ -0,0 +1,16 @@
+import tkinter as tk
+from typing import Tuple
+
+
+
+class SelectImageFrame(tk.Frame):
+
+    def __init__(self, master: tk.Widget, display_size: Tuple[int, int]):
+        super().__init__(master=master, width=display_size[0], height=display_size[1])
+
+        self.pack_propagate(False)
+        
+        self._label: tk.Label = tk.Label(master=self,
+                                         text="Select a file (Strg + O)",
+                                         font=("Arial, 18"))
+        self._label.place(relx=0.5, rely=0.5, anchor=tk.CENTER)

pic_select/gui/selectFile.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+import tkinter as tk
+from tkinter import filedialog
+
+
+
+def ask_file_name(parent: tk.Tk) -> Path:
+    path = filedialog.askopenfilename(parent=parent)
+    return Path(path)

pic_select/log/__init__.py

@@ -0,0 +1,4 @@
+from .logger import Logger
+
+
+logger = Logger()

pic_select/log/logger.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from datetime import datetime
+
+
+
+class Logger():
+    def __init__(self, log_file: Path = None):
+        self._log_file = log_file
+
+    def log_file_action(self, thread: str, file: Path, action: str) -> None:
+        message = f"{thread} - {file.name} - {action}"
+        self._log(message=message)
+
+    def log_user_input(self, input: str) -> None:
+        self._log(message=input, new_line=True)
+
+    def log_benchmark(self, title: str, time_ms: int) -> None:
+        message = f"{title} - {time_ms}ms"
+        self._log(message=message, new_line=True)
+
+    def _log(self, message: str, new_line: bool = False) -> None:
+        current_time = datetime.now().strftime("%H:%M:%S")
+        good_message = f"{current_time}: {message}"
+        if self._log_file is None:
+            if new_line:
+                print()
+            print(good_message)
+        else:
+            raise NotImplementedError()

pic_select/logic/clipboard.py

@@ -0,0 +1,13 @@
+import subprocess
+from typing import List
+from pathlib import Path
+
+
+
+def copy_files_to_clipboard(files: List[Path]) -> None:
+    if files is None or len(files) == 0:
+        return None
+    seperator = "', '"
+    cmd = f"Set-Clipboard -Path '{seperator.join([str(p) for p in files])}'"
+    subprocess.run(["powershell", cmd], shell=True)    
+    

pic_select/logic/input/UserInput.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+
+class UserInput(Enum):
+    OPEN = "open"
+    FORWARD = "forward"
+    BACKWARD = "backward"
+    SELECT = "select"
+    COPY = "copy"
+    SELECT_ALL = "selectAll"
+    UNSELECT_ALL = "unselectAll"

pic_select/logic/input/userInputHandler.py

@@ -0,0 +1,94 @@
+from typing import Literal
+from pathlib import Path
+
+from ..clipboard import copy_files_to_clipboard
+from ..load.loaderThread import LoaderThread
+from ..load.pictureDirectory import PictureDirectory
+from ..selector import Selector
+from .UserInput import UserInput
+
+from ...gui.frames.displays.imageViewFrame import ImageViewFrame
+from ...gui.frames.displayFrame import DisplayFrame
+
+
+
+class UserInputHandler:
+
+    def __init__(self, selector: Selector, loader_thread: LoaderThread, picture_directory: PictureDirectory):
+
+        self._selector = selector
+        self._loader_thread = loader_thread
+        self._picture_directory = picture_directory
+        
+        self._image_view_frame = None
+        self._display_frame = None
+
+        self._last_arrow_input: Literal[UserInput.FORWARD, UserInput.BACKWARD] = None
+
+    def set_image_view_frame(self, image_view_frame: ImageViewFrame) -> None:
+        self._image_view_frame = image_view_frame
+
+    def set_display_frame(self, display_frame: DisplayFrame) -> None:
+            self._display_frame = display_frame
+
+    def handle_input(self, input: UserInput, **kwargs):
+        if input not in UserInput:
+            raise RuntimeError("Invalid input")
+
+        match input:
+            case UserInput.OPEN:
+                self._open(file = kwargs["file"])
+            case UserInput.FORWARD:
+                self._forward()
+            case UserInput.BACKWARD:
+                self._backward()
+            case UserInput.SELECT:
+                self._select()
+            case UserInput.COPY:
+                self._copy()
+            case UserInput.SELECT_ALL:
+                self._select_all()
+            case UserInput.UNSELECT_ALL:
+                self._unselect_all()
+
+    def _open(self, file: Path) -> None:
+        self._picture_directory.directory = file.parent
+        self._loader_thread.update_to(path=file)
+        self._display_frame.show_image(path=file)
+
+    def _forward(self) -> None:
+        if self._image_view_frame.is_waiting_on_loader() and self._last_arrow_input == UserInput.FORWARD:
+            return None
+
+        self._last_arrow_input = UserInput.FORWARD
+
+        next_file = self._picture_directory.next_file(anchor=self._image_view_frame.current_image_path)
+        if next_file is not None:
+            self._display_frame.show_image(path=next_file)
+            self._loader_thread.update_to(path=next_file)
+
+    def _backward(self) -> None:
+        if self._image_view_frame.is_waiting_on_loader() and self._last_arrow_input == UserInput.BACKWARD:
+            return None
+
+        self._last_arrow_input = UserInput.BACKWARD
+        
+        previous_file = self._picture_directory.previous_file(anchor=self._image_view_frame.current_image_path)
+        if previous_file is not None:
+            self._display_frame.show_image(path=previous_file)
+            self._loader_thread.update_to(path=previous_file)
+
+    def _select(self) -> None:
+        path = self._image_view_frame.current_image_path
+        if path in self._image_view_frame:
+            self._selector.toggle(path)
+
+    def _copy(self) -> None:
+        selection = self._selector.get_selection()
+        copy_files_to_clipboard(files=selection)
+
+    def _select_all(self) -> None:
+        self._selector.select_all()
+
+    def _unselect_all(self) -> None:
+        self._selector.unselect_all()

pic_select/logic/load/loader.py

@@ -0,0 +1,105 @@
+from PIL import Image
+from pathlib import Path
+from typing import Dict, Callable, Set, Tuple
+from collections.abc import Mapping
+
+from .pictureDirectory import PictureDirectory
+
+
+
+_EXIF_FORMATS = ["JPEG", "TIFF"]
+_TRANSPOSE_MAP = {
+        2: Image.Transpose.FLIP_LEFT_RIGHT,
+        3: Image.Transpose.ROTATE_180,
+        4: Image.Transpose.FLIP_TOP_BOTTOM,
+        5: Image.Transpose.TRANSPOSE,
+        6: Image.Transpose.ROTATE_270,
+        7: Image.Transpose.TRANSVERSE,
+        8: Image.Transpose.ROTATE_90,
+    }
+
+
+
+class Loader(Mapping):
+
+    def __init__(self, picture_directory: PictureDirectory, max_image_size: Tuple[int, int] = None):
+        if picture_directory is None:
+            raise RuntimeError("picture_directory can not be None")
+        self._picture_directory = picture_directory
+        self._max_image_size = max_image_size
+
+        self._images: Dict[Path, Image.Image] = dict()
+
+        self._load_callbacks: Set[Callable[[Path, Image.Image], None]] = set()
+        self._unload_callbacks: Set[Callable[[Path], None]] = set()
+
+    def __getitem__(self, path: Path):
+        if path not in self._images:
+            raise KeyError(f"{path} is not loaded")
+        return self._images[path]
+
+    def __setitem__(self, path: Path, image: Image.Image):
+        raise RuntimeError("use Loader.load()")
+
+    def __delitem__(self, path: Path):
+        raise RuntimeError("use Loader.unload()")
+
+    def __contains__(self, path: Path):
+        return path in self._images
+
+    def __iter__(self):
+        return iter(self._images)
+
+    def __len__(self):
+        return len(self._images)
+    
+    def load(self, path: Path) -> Image.Image:
+        if path not in self._picture_directory:
+            raise KeyError(f"{path} not in {self._picture_directory.directory}")
+
+        if path in self:
+            return self[path]
+                
+        image: Image = Image.open(path)
+
+        if image.format in _EXIF_FORMATS:
+            exif = image.getexif()
+            orientation = exif.get(0x0112)
+            if orientation is not None and orientation > 1:
+                method = _TRANSPOSE_MAP.get(orientation)
+                image = image.transpose(method)
+
+        if self._max_image_size is not None:
+            image.thumbnail(self._max_image_size, Image.Resampling.LANCZOS)
+                
+        self._images[path] = image
+        self._trigger_load(image=image, path=path)
+        return image
+
+    def unload(self, path: Path) -> None:
+        if path not in self._images:
+            return None
+
+        self._images[path].close()
+        self._images.pop(path)
+        self._trigger_unload(unloaded_path=path)
+
+    def _trigger_load(self, image: Image.Image, path: Path) -> None:
+        for callback in self._load_callbacks:
+            callback(path, image)
+    
+    def _trigger_unload(self, unloaded_path: Path) -> None:
+        for callback in self._unload_callbacks:
+            callback(unloaded_path)
+    
+    def subscribe_on_load(self, callback: Callable[[Path, Image.Image], None]):
+        self._load_callbacks.add(callback)
+    
+    def unsubscribe_on_load(self, callback: Callable[[Path, Image.Image], None]):
+        self._load_callbacks.remove(callback)
+    
+    def subscribe_on_unload(self, callback: Callable[[Path], None]):
+        self._unload_callbacks.add(callback)
+    
+    def unsubscribe_on_unload(self, callback: Callable[[Path], None]):
+        self._unload_callbacks.remove(callback)

pic_select/logic/load/loaderThread.py

@@ -0,0 +1,124 @@
+from queue import Queue
+from typing import Callable, Set
+from pathlib import Path
+
+from .loader import Loader
+from .pictureDirectory import PictureDirectory
+
+
+
+class LoaderThread:
+
+    def __init__(self, loader: Loader, picture_directory: PictureDirectory, centre_file: Path = None, preload_length: int = 6, batch_size: int = 3):
+        self._preload_length = preload_length
+        self._batch_size = batch_size
+
+        self._loader = loader
+        self._picture_directory = picture_directory
+
+        self._centre_file = centre_file
+
+        self._queue = Queue()
+        self._queue_size = 0
+
+        self._idle_callbacks: Set[Callable[[], None]] = set()
+        self._busy_callbacks: Set[Callable[[], None]] = set()
+
+    def _run(self) -> None:
+        while True:
+            request = self._queue.get()
+            self._execute_queue(first_request=request)
+            if self._queue.qsize() == 0:
+                self._trigger_idle()
+
+    def _execute_queue(self, first_request) -> None:
+        requests = [first_request]
+
+        while not self._queue.qsize() == 0:
+            requests.append(self._queue.get_nowait())
+
+        request = requests[-1]
+
+        for i in range(len(requests) - 1):
+            self._queue.task_done()
+        self._queue_size = self._queue.qsize()
+
+        self._trigger_busy()
+        self._update_loader(path = request)
+        self._queue.task_done()
+
+    def _update_loader(self, path: Path) -> None:
+        if self._centre_file is None:
+            self._centre_file = path
+        if self._unload_out_of_scope_images(path=path):
+            self._centre_file = path
+            return None
+        if self._load_in_scope_images(path=path):
+            self._centre_file = path
+            return None
+        self._centre_file = path
+
+    def _unload_out_of_scope_images(self, path: Path) -> bool:
+        out_of_scope_images = []
+        for path in self._loader.keys():
+            if self._picture_directory.distance(self._centre_file, path) > self._preload_length:
+                out_of_scope_images.append(path)
+        for path in out_of_scope_images:
+            self._loader.unload(path=path)
+            if self._queue_size < self._queue.qsize():
+                return True
+
+    def _load_in_scope_images(self, path: Path) -> bool:
+
+        def load_file(file: Path) -> None:
+            if file is None:
+                return None
+            if file in self._loader.keys():
+                return None
+            self._loader.load(path=file)
+
+        load_file(path)
+        for relative_position in range(1, self._preload_length + 1):
+            load_file(self._picture_directory.get_relative_file(anchor=path, distance=relative_position))
+            if self._queue_size < self._queue.qsize():
+                return True
+            load_file(self._picture_directory.get_relative_file(anchor=path, distance=-relative_position))
+            if self._queue_size < self._queue.qsize():
+                return True
+
+    def _trigger_idle(self) -> None:
+        for callback in self._idle_callbacks:
+            callback()
+    
+    def _trigger_busy(self) -> None:
+        for callback in self._busy_callbacks:
+            callback()
+
+    def _clear_queue(self) -> None:
+        while not self._queue.qsize() == 0:
+            self._queue.get_nowait()
+            self._queue.task_done()
+
+    def mainloop(self) -> None:
+            self._run()
+
+    def _append_reload(self, path: Path) -> None:
+        self._queue.put(path)
+
+    def update_to(self, path: Path) -> None:
+        if self._centre_file is None or self._picture_directory.distance(self._centre_file, path) > self._batch_size:
+            self._append_reload(path=path)
+        else:
+            self._append_reload(path=self._centre_file)
+
+    def subscribe_on_idle(self, callback: Callable[[], None]):
+        self._idle_callbacks.add(callback)
+
+    def unsubscribe_on_idle(self, callback: Callable[[], None]):
+        self._idle_callbacks.remove(callback)
+
+    def subscribe_on_busy(self, callback: Callable[[], None]):
+        self._busy_callbacks.add(callback)
+
+    def unsubscribe_on_busy(self, callback: Callable[[], None]):
+        self._busy_callbacks.remove(callback)

pic_select/logic/load/pictureDirectory.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+from typing import List
+from collections import UserList
+
+
+
+class PictureDirectory(UserList):
+    
+    def __init__(self, directory: Path = None):
+        if directory is None:
+            self._directory = directory
+            self._files = list()
+        else:
+            self.directory = directory
+        self.data = self._files
+    
+    def _lookup_files(self) -> None:
+        self._files = [f for f in self._directory.iterdir() if f.is_file()]
+        self._files.sort()
+
+    @property
+    def directory(self) -> Path:
+        return self._directory
+
+    @directory.setter
+    def directory(self, directory: Path):
+        if not directory.is_dir():
+            raise ValueError(f"{directory} is no directory")
+        else:
+            self._directory = directory
+        self._lookup_files()
+        self.data = self._files
+
+    def get_relative_file(self, anchor: Path, distance: int) -> Path:
+        if anchor not in self:
+            raise RuntimeError(f"{anchor} not in {self._directory}")
+        index = self.index(anchor) + distance
+        if index < 0 or index >= len(self):
+            return None
+        return self[index]
+
+    def previous_file(self, anchor: Path) -> Path:
+        return self.get_relative_file(anchor=anchor, distance=-1)
+
+    def next_file(self, anchor: Path) -> Path:
+        return self.get_relative_file(anchor=anchor, distance=1)
+
+    def distance(self, pathA: Path, pathB: Path) -> int:
+        if pathA not in self:
+            raise RuntimeError(f"{pathA} not in {self._directory}")
+        if pathB not in self:
+            raise RuntimeError(f"{pathB} not in {self._directory}")
+        return abs(self.index(pathA) - self.index(pathB))

pic_select/logic/selector.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+from typing import Dict, List, Set, Callable
+from collections.abc import Mapping
+
+from .load.pictureDirectory import PictureDirectory
+
+
+
+class Selector(Mapping):
+
+    def __init__(self, picture_directoy: PictureDirectory):
+        self._picture_directory = picture_directoy
+        self._files: Dict[Path, bool] = {}
+
+        self._callbacks: Set[Callable[[Path, bool, int], None]] = set()
+
+    def __getitem__(self, path: Path):
+        if path not in self._files:
+            return False
+        return self._files[path]
+    
+    def __setitem__(self, path: Path, selected: bool):
+        self._files[path] = selected
+
+    def __delitem__(self, path: Path):
+        del self._files[path]
+
+    def __contains__(self, path: Path):
+        return path in self._files
+
+    def __iter__(self):
+        return iter(self._files)
+
+    def __len__(self):
+        return len(self._files)
+
+    def _trigger_select(self, path: Path) -> None:
+        for callback in self._callbacks:
+            callback(path, self.is_selected(path=path), self.get_number_selected())
+
+    def toggle(self, path: Path) -> bool:
+        if path in self._files:
+            self._files[path] = not self._files[path]
+        else:
+            self._files[path] = True
+        self._trigger_select(path=path)
+        return self.is_selected(path=path)
+
+    def get_selection(self) -> List[Path]:
+        return list({k: v for k, v in self._files.items() if v is True}.keys())
+
+    def get_number_selected(self) -> int:
+        return len(self.get_selection())
+
+    def is_selected(self, path: Path) -> bool:
+        if path in self._files:
+            return self._files[path]
+        else:
+            return False
+        
+    def multi_select(self, paths: List[Path]) -> None:
+        for path in paths:
+            self._files[path] = True
+            self._trigger_select(path=path)
+
+    def select_all(self) -> None:
+        self.multi_select(paths=self._picture_directory)
+    
+    def unselect_all(self) -> None:
+        for path in self._files.keys():
+            self._files[path] = False
+            self._trigger_select(path=path)
+
+    def subscribe_on_select(self, callback: Callable[[Path, bool, int], None]):
+        self._callbacks.add(callback)
+
+    def unsubscribe_on_select(self, callback: Callable[[Path, bool, int], None]):
+        self._callbacks.remove(callback)

pic_select/logic/sizeManager.py

@@ -0,0 +1,19 @@
+from screeninfo import get_monitors
+from typing import Tuple
+
+
+class SizeManager():
+    
+    def __init__(self):
+        self._max_monitor_extension = self.get_max_monitor_extension()
+
+    @property
+    def max_monitor_extension(self) -> Tuple[int, int]:
+        return self._max_monitor_extension
+
+    @staticmethod
+    def get_max_monitor_extension() -> Tuple[int, int]:
+        widths, heights = zip(*[(m.width, m.height) for m in get_monitors()])
+        return max(widths), max(heights)
+
+    

pic_select/pic_select.py

@@ -0,0 +1,36 @@
+import threading
+
+from .logic.load.loader import Loader
+from .logic.load.loaderThread import LoaderThread
+from .logic.load.pictureDirectory import PictureDirectory
+from .logic.selector import Selector
+from .logic.input.userInputHandler import UserInputHandler
+from .logic.sizeManager import SizeManager
+
+from .gui.app import App
+from .gui.selectFile import ask_file_name
+
+
+
+def start():
+    picture_directory = PictureDirectory()
+    size_manager = SizeManager()
+    loader = Loader(picture_directory=picture_directory, max_image_size=size_manager.max_monitor_extension)
+    loader_thread = LoaderThread(loader=loader, picture_directory=picture_directory)
+    selector = Selector(picture_directoy=picture_directory)
+    input_handler = UserInputHandler(selector=selector, loader_thread=loader_thread, picture_directory=picture_directory)
+
+    worker_thread = threading.Thread(target=loader_thread.mainloop, daemon=True)
+
+    app = App(title="",
+              input_handler=input_handler,
+              loader=loader,
+              loader_thread=loader_thread,
+              selector=selector)
+
+    input_handler.set_display_frame(display_frame=app.display_frame)
+    input_handler.set_image_view_frame(image_view_frame=app.image_view_frame)
+
+    worker_thread.start()
+
+    app.mainloop()

pic_select-1.0.1.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: pic_select
+Version: 1.0.1
+Author: Nils Urbach
+Author-email: ndu01u@gmail.com
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+
+# pic_select
+
+This is a small module that easily lets you view; select and copy images in a directory.
+
+## Installation and Start
+
+- install using `python -m pip install pic_select`
+- run using `python -m pic_select`
+
+## Usage
+
+- Ctrl+O:       open a image file
+- Left arrow:   show next picture in directory (alphabetical order)
+- Right arrow:  show next picture in directory (alphabetical order)
+- Space bar:    (un)select an image
+- Ctrl+C:       copy all selected images to clipboard
+- Ctrl+A:       select all images in the directory
+- Esc:          unselect all images
+- Ctrl+T:       exit the program
+- F11:          toggle fullscreen

pic_select-1.0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+pic_select/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pic_select/__main__.py,sha256=MsBjJvgc-QnEDRJP6_V4zdrk9YYzOetR1IwPudFI3uA,103
+pic_select/pic_select.py,sha256=N7mdvwARsxGCOoG_XTlB8DM0ysJ3Ff-5oOY-8FXEQHQ,1322
+pic_select/gui/app.py,sha256=aTCGude6kGkNJsUO2pFql6dzI89ECzIDczLCNPEsZV4,3750
+pic_select/gui/selectFile.py,sha256=C4_C4kHow0GiiTA0C8vFmlA59uXchWn8KiLn3YAViUo,204
+pic_select/gui/frames/displayFrame.py,sha256=3gvJmkKFOevitzDWqUWrXvnmxCu1ix4hEs1Zvhr4XKg,3668
+pic_select/gui/frames/components/borderedImageFrame.py,sha256=kd1cMIQb4XxL04ufYIKJkciOkJxH5_cStSQCRIe-gFM,1117
+pic_select/gui/frames/components/imageFrame.py,sha256=77t49lqyFLHWT2K8xqQ_u1rDSZwLOLubC6gkR4JTlD8,2149
+pic_select/gui/frames/components/paddedImageFrame.py,sha256=TdmE4heWfylodmu4xKcyPKVKp8VW7JiPGEQp7_rFQmk,795
+pic_select/gui/frames/displays/imageViewFrame.py,sha256=3k5tZLWniSHmI7CC00h_0eX-0qiH1xGUszuyXE2C2XQ,3831
+pic_select/gui/frames/displays/loadFrame.py,sha256=VRgx_ipZDNlJXvS0jIQukGV1FhMrZL_CMR1m3q5PCT0,686
+pic_select/gui/frames/displays/selectImageFrame.py,sha256=ksoBIcs5K9xbjRFY7NWAkqWYe_8V_n96jck1GMAbQTQ,557
+pic_select/log/__init__.py,sha256=8UOcu1oKmPPmUfRtZwak2Ldt5J4HF78b_CNBP19IbQ4,49
+pic_select/log/logger.py,sha256=8LLQAn9a3nS9Q22tpar3Zx8LdDaGuj1sJC2t-h5GCjw,956
+pic_select/logic/clipboard.py,sha256=Qv7dvR8akce3wvPNSMZoblm5lZNvCtRCgbkl98VoRlc,359
+pic_select/logic/selector.py,sha256=TjJrdOs7CJUhztGhc_KjI7wGq9ow-rn60k6vdrypAMg,2456
+pic_select/logic/sizeManager.py,sha256=HXuzJItZmlSKTuCYNqd_b_3IHquiDdjcmXl6y2Cynq0,515
+pic_select/logic/input/UserInput.py,sha256=U1EyU_akDZpk7KdmLfLP8UdK6Oynmn6nSKr4SYLx5RQ,228
+pic_select/logic/input/userInputHandler.py,sha256=uFeA3IUW8qN_8SLs1tx0uwOA-M1RmjT3kbg4BHqbGJ4,3443
+pic_select/logic/load/loader.py,sha256=t05b9PDmCvat1m6H81Ah8SGwp0RVKKYvqBNOjxtrB-o,3561
+pic_select/logic/load/loaderThread.py,sha256=Li6gSmUqbDXoWtWv_2h8aDfoZ7yFQ-vpKXbpykRJYOg,4328
+pic_select/logic/load/pictureDirectory.py,sha256=ch5hSqlSpJnw76X5owYZ44sjco4Btvoet0hXzdBNudo,1766
+pic_select-1.0.1.dist-info/licenses/LICENSE,sha256=9eUWP30YVqvg82ZPXd86acXWRKPhIJPT-QaRcQLVg8s,1077
+pic_select-1.0.1.dist-info/METADATA,sha256=NjYCB_AR0CgJMe0SYLhUUpfwKy-oxYrbSgTmi8Ccgs4,1286
+pic_select-1.0.1.dist-info/WHEEL,sha256=a-udL2m4V_6Yn8b-uKzWb12RjRxwwMo6ohYFM24tpaY,91
+pic_select-1.0.1.dist-info/top_level.txt,sha256=FJbRlZms-SbCfEc_ffS-Y0htl2oltq9K-HpTR1G9MK8,11
+pic_select-1.0.1.dist-info/RECORD,,

pic_select-1.0.1.dist-info/WHEEL

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

pic_select-1.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2022 Nils Urbach
+
+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.

pic_select-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pic_select