pic-select 1.0.1__tar.gz

pic_select-1.0.1/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,20 @@
+# 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/pic_select/__main__.py

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

pic_select-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/pic_select/log/__init__.py

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

pic_select-1.0.1/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-1.0.1/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-1.0.1/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"