python-template-project 0.1.20__py3-none-any.whl → 0.1.21__py3-none-any.whl

python_template_project/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.20'
-__version_tuple__ = version_tuple = (0, 1, 20)
+__version__ = version = '0.1.21'
+__version_tuple__ = version_tuple = (0, 1, 21)

python_template_project/core/base.py

@@ -16,6 +16,17 @@ except ImportError:
     SRTM_AVAILABLE = False
     srtm = None
 
+# Optional fastkml import for KML reading
+try:
+    from fastkml import kml, styles
+    from fastkml.features import Document, Folder, Placemark
+    from shapely.geometry import LineString, Point
+
+    KML_AVAILABLE = True
+except ImportError:
+    KML_AVAILABLE = False
+    kml = styles = Folder = Placemark = Document = Point = LineString = None
+
 NAME = "python_template_project"
 
 
@@ -114,7 +125,9 @@ class BaseGPXProcessor:
         if self.output:
             output_path = Path(self.output)
         else:
-            timestamp = datetime.now().strftime(f"{self.date_format}_%H%M")
+            timestamp = datetime.now().strftime(
+                f"{self.date_format}_%H%M%S"
+            )  # Added seconds for uniqueness
             output_path = Path.cwd() / f"gpx_processed_{timestamp}"
 
         output_path.mkdir(parents=True, exist_ok=True)
@@ -228,54 +241,56 @@ class BaseGPXProcessor:
             self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
             return track_points  # Return original points if optimization fails
 
-    def _get_gpx_files(self) -> list[Path]:
-        """Get all GPX files from input (file, folder, or zip)."""
-        gpx_files = []
-        for input_path in self.input:
+    def _get_input_files(self) -> list[Path]:
+        """Get all GPX/KML files from input (file, folder, or zip)."""
+        input_files = []
+        for input_path_str in self.input:
             try:
-                if not isinstance(input_path, Path):
-                    input_path = Path(input_path)
+                input_path = Path(input_path_str)
                 self.logger.debug(f"Input path: {input_path.absolute()}")
 
                 if input_path.is_file():
                     if input_path.suffix.lower() == ".gpx":
-                        gpx_files.append(input_path)
+                        input_files.append(input_path)
+                    elif input_path.suffix.lower() == ".kml":
+                        input_files.append(input_path)
                     elif input_path.suffix.lower() == ".zip":
-                        gpx_files.extend(self._extract_gpx_from_zip(input_path))
+                        input_files.extend(self._extract_gpx_kml_from_zip(input_path))
                 elif input_path.is_dir():
-                    # Get all GPX files in directory
-                    gpx_files.extend(input_path.glob("*.gpx"))
+                    # Get all GPX/KML files in directory
+                    input_files.extend(input_path.glob("*.gpx"))
+                    input_files.extend(input_path.glob("*.kml"))
 
-                    # Get GPX files from ZIP files in directory
+                    # Get GPX/KML files from ZIP files in directory
                     for zip_file in input_path.glob("*.zip"):
-                        gpx_files.extend(self._extract_gpx_from_zip(zip_file))
+                        input_files.extend(self._extract_gpx_kml_from_zip(zip_file))
             except Exception as e:
                 self.logger.error(f"Error processing input path {input_path}: {e}")
                 self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
                 continue
 
-        return gpx_files
+        return input_files
 
-    def _extract_gpx_from_zip(self, zip_path: Path) -> list[Path]:
-        """Extract GPX files from ZIP archive to temporary location."""
-        gpx_files = []
-        temp_dir = Path.cwd() / "temp_gpx_extract"
+    def _extract_gpx_kml_from_zip(self, zip_path: Path) -> list[Path]:
+        """Extract GPX/KML files from ZIP archive to temporary location."""
+        extracted_files = []
+        temp_dir = Path.cwd() / "temp_extracted_files"
 
         try:
             temp_dir.mkdir(exist_ok=True)
 
             with zipfile.ZipFile(zip_path, "r") as zip_ref:
                 for file_info in zip_ref.infolist():
-                    if file_info.filename.lower().endswith(".gpx"):
+                    if file_info.filename.lower().endswith((".gpx", ".kml")):
                         extracted_path = temp_dir / Path(file_info.filename).name
                         with open(extracted_path, "wb") as f:
                             f.write(zip_ref.read(file_info.filename))
-                        gpx_files.append(extracted_path)
+                        extracted_files.append(extracted_path)
         except Exception as e:
             self.logger.error(f"Error extracting ZIP file {zip_path}: {e}")
             self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
 
-        return gpx_files
+        return extracted_files
 
     def _load_gpx_file(self, gpx_path: Path) -> GPX | None:
         """Load and parse GPX file."""
@@ -290,35 +305,104 @@ class BaseGPXProcessor:
             self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
             return None
 
-    def _save_gpx_file(self, gpx: GPX, output_path: Path, original_file: Path | None = None):
-        """Save GPX object to file."""
+    def _load_kml_file(self, kml_path: Path) -> GPX | None:
+        """Load and parse KML file, converting it to a GPX object."""
+        if not KML_AVAILABLE:
+            self.logger.error("fastkml library is not available to process KML files.")
+            return None
+
+        try:
+            with open(kml_path, "r", encoding="utf-8") as f:
+                doc = f.read()
+
+            k = kml.KML()
+            k.from_string(doc)
+
+            gpx = gpxpy.gpx.GPX()
+
+            # Iterate through KML features and convert to GPX tracks/waypoints
+            for feature in k.features():
+                if isinstance(feature, Document) or isinstance(feature, Folder):
+                    for sub_feature in feature.features():
+                        self._process_kml_feature(sub_feature, gpx)
+                else:
+                    self._process_kml_feature(feature, gpx)
+
+            self.logger.info(f"Successfully loaded and converted KML file {kml_path} to GPX.")
+            return gpx
+
+        except Exception as e:
+            self.logger.error(f"Error loading or converting KML file {kml_path}: {e}")
+            self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+            return None
+
+    def _process_kml_feature(self, feature, gpx: GPX):
+        """Recursively process KML features to extract points and add to GPX."""
+        if isinstance(feature, Placemark):
+            if feature.geometry is not None:
+                if isinstance(feature.geometry, Point):
+                    waypoint = gpxpy.gpx.GPXWaypoint(
+                        latitude=feature.geometry.y,
+                        longitude=feature.geometry.x,
+                        elevation=feature.geometry.z if feature.geometry.has_z else None,
+                        name=feature.name,
+                        description=feature.description,
+                    )
+                    gpx.waypoints.append(waypoint)
+                elif isinstance(feature.geometry, LineString):
+                    gpx_track = gpxpy.gpx.GPXTrack()
+                    gpx_track.name = feature.name
+                    gpx_segment = gpxpy.gpx.GPXTrackSegment()
+                    for coord in feature.geometry.coords:
+                        point = gpxpy.gpx.GPXTrackPoint(
+                            latitude=coord[1],
+                            longitude=coord[0],
+                            elevation=coord[2] if len(coord) > 2 else None,
+                        )
+                        gpx_segment.points.append(point)
+                    if gpx_segment.points:
+                        gpx_track.segments.append(gpx_segment)
+                    if gpx_track.segments:
+                        gpx.tracks.append(gpx_track)
+        elif isinstance(feature, Document) or isinstance(feature, Folder):
+            for sub_feature in feature.features():
+                self._process_kml_feature(sub_feature, gpx)
+
+    def _save_gpx_file(
+        self, gpx: GPX, output_path: Path, original_file: Path | None = None
+    ) -> Path:
+        """Save GPX object to file and return the path."""
         try:
             with open(output_path, "w", encoding="utf-8") as f:
                 f.write(gpx.to_xml())
                 if original_file and original_file.exists():
                     self.logger.info(
-                        f"Original gpx file size: "
-                        f"{Path(original_file).stat().st_size / 1024:.2f} KB"
+                        f"Original file size: {Path(original_file).stat().st_size / 1024:.2f} KB"
                     )
-                self.logger.info(
-                    f"Processed gpx file size: {output_path.stat().st_size / 1024:.2f} KB"
-                )
-
+                self.logger.info(f"Processed file size: {output_path.stat().st_size / 1024:.2f} KB")
+            return output_path
         except Exception as e:
             self.logger.error(f"Error saving GPX file {output_path}: {e}")
             self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+            return None
 
-    def compress_files(self):
-        """Shrink the size of all given gpx files in self.input."""
+    def compress_files(self) -> list[str]:
+        """Shrink the size of all given gpx/kml files in self.input."""
+        generated_files = []
         try:
-            gpx_files = self._get_gpx_files()
+            input_files = self._get_input_files()
             output_folder = self._get_output_folder()
 
-            self.logger.info(f"Processing {len(gpx_files)} GPX files...")
+            self.logger.info(f"Processing {len(input_files)} GPX/KML files for compression...")
 
-            for gpx_file in gpx_files:
+            for input_file in input_files:
                 try:
-                    gpx = self._load_gpx_file(gpx_file)
+                    gpx = None
+                    if input_file.suffix.lower() == ".gpx":
+                        gpx = self._load_gpx_file(input_file)
+                    elif input_file.suffix.lower() == ".kml":
+                        gpx = self._load_kml_file(input_file)
+
                     if gpx is None:
                         continue
 
@@ -340,14 +424,17 @@ class BaseGPXProcessor:
                     gpx.extensions = None
 
                     # Save compressed file
-                    output_path = output_folder / f"compressed_{gpx_file.name}"
-                    self._save_gpx_file(gpx, output_path, gpx_file)
-                    self.logger.info(f"Compressed: {gpx_file.name} -> {output_path}")
+                    output_path = output_folder / f"compressed_{input_file.stem}.gpx"
+                    saved_path = self._save_gpx_file(gpx, output_path, input_file)
+                    if saved_path:
+                        generated_files.append(str(saved_path))
+                        self.logger.info(f"Compressed: {input_file.name} -> {output_path}")
 
                 except Exception as e:
-                    self.logger.error(f"Error processing file {gpx_file}: {e}")
+                    self.logger.error(f"Error processing file {input_file}: {e}")
                     self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
                     continue
+            return generated_files
 
         except Exception as e:
             self.logger.error(f"Error in compress_files: {e}")
@@ -383,41 +470,49 @@ class BaseGPXProcessor:
             self.logger.warning(f"Error optimizing waypoint: {e}")
             return waypoint
 
-    def merge_files(self):
+    def merge_files(self) -> list[str]:
         """Merge all files of self.input into one gpx file with reduced resolution."""
+        generated_files = []
         try:
-            gpx_files = self._get_gpx_files()
+            input_files = self._get_input_files()
             output_folder = self._get_output_folder()
 
-            if not gpx_files:
-                self.logger.error("No GPX files found to merge.")
-                return
+            if not input_files:
+                self.logger.error("No GPX/KML files found to merge.")
+                return []
 
-            self.logger.info(f"Merging {len(gpx_files)} GPX files...")
+            self.logger.info(f"Merging {len(input_files)} GPX/KML files...")
 
             # Create new GPX object
             merged_gpx = gpxpy.gpx.GPX()
             merged_gpx.name = "Merged GPX Tracks"
-            merged_gpx.description = f"Merged from {len(gpx_files)} GPX files."
+            merged_gpx.description = f"Merged from {len(input_files)} GPX/KML files."
 
             track_counter = 1
 
-            for gpx_file in gpx_files:
+            for input_file in input_files:
                 try:
-                    gpx = self._load_gpx_file(gpx_file)
+                    gpx = None
+                    if input_file.suffix.lower() == ".gpx":
+                        gpx = self._load_gpx_file(input_file)
+                    elif input_file.suffix.lower() == ".kml":
+                        gpx = self._load_kml_file(input_file)
+
                     if gpx is None:
                         continue
 
                     # Add all waypoints from this file
                     for waypoint in gpx.waypoints:
                         waypoint = self._optimize_waypoint(waypoint)
-                        waypoint.name = f"{waypoint.name}_{track_counter}"
+                        waypoint.name = f"{waypoint.name or 'Waypoint'}_{track_counter}"
                         merged_gpx.waypoints.append(waypoint)
 
                     # Add all tracks from this file
                     for track in gpx.tracks:
                         new_track = gpxpy.gpx.GPXTrack()
-                        new_track.name = f"{track.name or track_counter}_{gpx_file.stem}"
+                        new_track.name = (
+                            f"{track.name or 'Track'}_{input_file.stem}_{track_counter}"
+                        )
 
                         for segment in track.segments:
                             optimized_points = self._optimize_track_points(segment.points)
@@ -433,7 +528,9 @@ class BaseGPXProcessor:
                     # Add all routes from this file
                     for route in gpx.routes:
                         new_route = gpxpy.gpx.GPXRoute()
-                        new_route.name = f"{route.name or track_counter}_{gpx_file.stem}"
+                        new_route.name = (
+                            f"{route.name or 'Route'}_{input_file.stem}_{track_counter}"
+                        )
                         new_route.points = self._optimize_track_points(route.points)
 
                         if new_route.points:
@@ -441,43 +538,52 @@ class BaseGPXProcessor:
                             track_counter += 1
 
                 except Exception as e:
-                    self.logger.error(f"Error processing file {gpx_file} during merge: {e}")
+                    self.logger.error(f"Error processing file {input_file} during merge: {e}")
                     self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
                     continue
 
             # Save merged file
             output_path = output_folder / "merged_tracks.gpx"
-            self._save_gpx_file(merged_gpx, output_path)
-            self.logger.info(f"Merged file saved: {output_path}")
+            saved_path = self._save_gpx_file(merged_gpx, output_path)
+            if saved_path:
+                generated_files.append(str(saved_path))
+                self.logger.info(f"Merged file saved: {output_path}")
+            return generated_files
 
         except Exception as e:
             self.logger.error(f"Error in merge_files: {e}")
             self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
             raise
 
-    def extract_pois(self):
+    def extract_pois(self) -> list[str]:
         """Merge every starting point of each track in all files
         into one gpx file with many pois."""
+        generated_files = []
         try:
-            gpx_files = self._get_gpx_files()
+            input_files = self._get_input_files()
             output_folder = self._get_output_folder()
 
-            if not gpx_files:
-                self.logger.error("No GPX files found to extract POIs from.")
-                return
+            if not input_files:
+                self.logger.error("No GPX/KML files found to extract POIs from.")
+                return []
 
-            self.logger.info(f"Extracting POIs from {len(gpx_files)} GPX files...")
+            self.logger.info(f"Extracting POIs from {len(input_files)} GPX/KML files...")
 
             # Create new GPX object for waypoints
             poi_gpx = gpxpy.gpx.GPX()
             poi_gpx.name = "Extracted Track Starting Points"
-            poi_gpx.description = f"Starting points extracted from {len(gpx_files)} GPX files"
+            poi_gpx.description = f"Starting points extracted from {len(input_files)} GPX/KML files"
 
             poi_counter = 1
 
-            for gpx_file in gpx_files:
+            for input_file in input_files:
                 try:
-                    gpx = self._load_gpx_file(gpx_file)
+                    gpx = None
+                    if input_file.suffix.lower() == ".gpx":
+                        gpx = self._load_gpx_file(input_file)
+                    elif input_file.suffix.lower() == ".kml":
+                        gpx = self._load_kml_file(input_file)
+
                     if gpx is None:
                         continue
 
@@ -496,7 +602,9 @@ class BaseGPXProcessor:
 
                                 track_name = track.name or f"Track_{track_idx + 1}"
                                 waypoint.name = f"POI_{poi_counter:03d}"
-                                waypoint.description = f"Start of {track_name} from {gpx_file.name}"
+                                waypoint.description = (
+                                    f"Start of {track_name} from {input_file.name}"
+                                )
                                 waypoint.type = "Track Start"
 
                                 poi_gpx.waypoints.append(waypoint)
@@ -516,7 +624,7 @@ class BaseGPXProcessor:
 
                             route_name = route.name or f"Route_{route_idx + 1}"
                             waypoint.name = f"POI_{poi_counter:03d}"
-                            waypoint.description = f"Start of {route_name} from {gpx_file.name}"
+                            waypoint.description = f"Start of {route_name} from {input_file.name}"
                             waypoint.type = "Route Start"
 
                             poi_gpx.waypoints.append(waypoint)
@@ -524,24 +632,27 @@ class BaseGPXProcessor:
 
                 except Exception as e:
                     self.logger.error(
-                        f"Error processing file {gpx_file} during POI extraction: {e}"
+                        f"Error processing file {input_file} during POI extraction: {e}"
                     )
                     self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
                     continue
 
             # Save POI file
             output_path = output_folder / "extracted_pois.gpx"
-            self._save_gpx_file(poi_gpx, output_path)
-            self.logger.info(
-                f"POI file saved with {len(poi_gpx.waypoints)} waypoints: {output_path}"
-            )
+            saved_path = self._save_gpx_file(poi_gpx, output_path)
+            if saved_path:
+                generated_files.append(str(saved_path))
+                self.logger.info(
+                    f"POI file saved with {len(poi_gpx.waypoints)} waypoints: {output_path}"
+                )
 
             # Clean up temporary files
-            temp_dir = Path.cwd() / "temp_gpx_extract"
+            temp_dir = Path.cwd() / "temp_extracted_files"  # Changed folder name
             if temp_dir.exists():
                 import shutil
 
                 shutil.rmtree(temp_dir)
+            return generated_files
 
         except Exception as e:
             self.logger.error(f"Error in extract_pois: {e}")

python_template_project/gui/gui.py

@@ -7,12 +7,14 @@ run gui: python -m python_template_project.gui
 """
 
 import os
+import subprocess
 import sys
 import threading
 import tkinter as tk
 import traceback
 import webbrowser
 from functools import partial
+from pathlib import Path
 from tkinter import filedialog, messagebox, ttk
 
 from python_template_project.config.config import ConfigParameter, ConfigParameterManager
@@ -77,6 +79,7 @@ class GuiLogWriter:
     def __init__(self, text_widget):
         self.text_widget = text_widget
         self.root = text_widget.winfo_toplevel()
+        self.hyperlink_tags = {}  # To store clickable links
 
     def write(self, text):
         """Write text to the widget in a thread-safe manner."""
@@ -86,13 +89,57 @@ class GuiLogWriter:
     def _update_text(self, text):
         """Update the text widget (must be called from main thread)."""
         try:
+            current_end = self.text_widget.index(tk.END)
             self.text_widget.insert(tk.END, text)
+
+            # Check for a directory path (simplified regex for common path formats)
+            # This regex looks for paths that start with a drive letter (C:\), a forward slash (/)
+            # or a backslash (\) followed by word characters, and ends with a word character.
+            # This is a basic approach; more robust path detection might be needed for edge cases.
+            import re
+
+            path_match = re.search(
+                r"([A-Za-z]:[\\/][\S ]*|[\\][\\/][\S ]*|[\w/.-]+[/][\S ]*)\b", text
+            )
+            if path_match:
+                path = path_match.group(0).strip()
+                # Ensure the path exists and is a directory to make it clickable
+                if Path(path).is_dir():
+                    start_index = self.text_widget.search(path, current_end, tk.END)
+                    if start_index:
+                        end_index = f"{start_index}+{len(path)}c"
+                        tag_name = f"link_{len(self.hyperlink_tags)}"
+                        self.text_widget.tag_config(tag_name, foreground="blue", underline=True)
+                        self.text_widget.tag_bind(
+                            tag_name, "<Button-1>", lambda e, p=path: self._open_path_in_explorer(p)
+                        )
+                        self.text_widget.tag_bind(
+                            tag_name, "<Enter>", lambda e: self.text_widget.config(cursor="hand2")
+                        )
+                        self.text_widget.tag_bind(
+                            tag_name, "<Leave>", lambda e: self.text_widget.config(cursor="")
+                        )
+                        self.text_widget.tag_add(tag_name, start_index, end_index)
+                        self.hyperlink_tags[tag_name] = path
+
             self.text_widget.see(tk.END)
             self.text_widget.update_idletasks()
         except tk.TclError:
             # Widget might be destroyed
             pass
 
+    def _open_path_in_explorer(self, path):
+        """Opens the given path in the file explorer."""
+        try:
+            if sys.platform == "win32":
+                os.startfile(path)
+            elif sys.platform == "darwin":
+                subprocess.Popen(["open", path])
+            else:
+                subprocess.Popen(["xdg-open", path])
+        except Exception as e:
+            get_logger("gui.main").error(f"Failed to open path {path}: {e}")
+
     def flush(self):
         """Flush method for compatibility."""
         pass
@@ -320,7 +367,7 @@ class MainGui:
     def __init__(self, root):
         self.root = root
         self.root.title("python-template-project")
-        self.root.geometry("800x600")
+        self.root.geometry("1200x600")  # Increased width for new layout
 
         # Initialize configuration
         self.config_manager = ConfigParameterManager()
@@ -329,8 +376,9 @@ class MainGui:
         self.logger_manager = initialize_logging(self.config_manager)
         self.logger = get_logger("gui.main")
 
-        # File list
-        self.file_list = []
+        # File lists
+        self.input_files = []
+        self.output_files = []
 
         self._build_widgets()
         self._create_menu()
@@ -348,35 +396,55 @@ class MainGui:
         """Build the main GUI widgets."""
         # Main container
         main_frame = ttk.Frame(self.root)
-        main_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
+        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)
 
-        # Top frame for file list and run button
+        # Top frame for file lists and buttons
         top_frame = ttk.Frame(main_frame)
         top_frame.pack(fill=tk.BOTH, expand=True)
 
-        # Left side - File list
-        file_frame = ttk.LabelFrame(top_frame, text="Input Files")
-        file_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 5))
+        # Left side - Input File list
+        input_file_frame = ttk.LabelFrame(top_frame, text="Input Files")
+        input_file_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 5))
 
-        # File listbox with scrollbar
-        listbox_frame = ttk.Frame(file_frame)
-        listbox_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
+        self.input_file_listbox = tk.Listbox(input_file_frame, selectmode=tk.EXTENDED)
+        input_file_scrollbar = ttk.Scrollbar(
+            input_file_frame, orient="vertical", command=self.input_file_listbox.yview
+        )
+        self.input_file_listbox.configure(yscrollcommand=input_file_scrollbar.set)
 
-        self.file_listbox = tk.Listbox(listbox_frame)
-        file_scrollbar = ttk.Scrollbar(
-            listbox_frame, orient="vertical", command=self.file_listbox.yview
+        self.input_file_listbox.pack(side="left", fill="both", expand=True, padx=5, pady=5)
+        input_file_scrollbar.pack(side="right", fill="y", pady=5)
+        self.input_file_listbox.bind(
+            "<Double-Button-1>", lambda event: self._open_selected_file(event, self.input_files)
         )
-        self.file_listbox.configure(yscrollcommand=file_scrollbar.set)
 
-        self.file_listbox.pack(side="left", fill="both", expand=True)
-        file_scrollbar.pack(side="right", fill="y")
+        # Middle - Output File list
+        output_file_frame = ttk.LabelFrame(top_frame, text="Generated Files")
+        output_file_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(5, 5))
 
-        # Right side - Run button and controls
+        self.output_file_listbox = tk.Listbox(output_file_frame)
+        output_file_scrollbar = ttk.Scrollbar(
+            output_file_frame, orient="vertical", command=self.output_file_listbox.yview
+        )
+        self.output_file_listbox.configure(yscrollcommand=output_file_scrollbar.set)
+
+        self.output_file_listbox.pack(side="left", fill="both", expand=True, padx=5, pady=5)
+        output_file_scrollbar.pack(side="right", fill="y", pady=5)
+        self.output_file_listbox.bind(
+            "<Double-Button-1>", lambda event: self._open_selected_file(event, self.output_files)
+        )
+
+        # Right side - Buttons
         button_frame = ttk.Frame(top_frame)
         button_frame.pack(side=tk.RIGHT, fill=tk.Y, padx=(5, 0))
 
         open_button = ttk.Button(button_frame, text="Open Files", command=self._open_files)
-        open_button.pack(pady=8)
+        open_button.pack(pady=8, fill=tk.X)
+
+        remove_selected_button = ttk.Button(
+            button_frame, text="Remove Selected", command=self._remove_selected_input_files
+        )
+        remove_selected_button.pack(pady=1, fill=tk.X)
 
         # Create buttons dynamically
         self.run_buttons = {}
@@ -384,13 +452,20 @@ class MainGui:
             button = ttk.Button(
                 button_frame, text=label, command=partial(self._run_processing, mode=mode)
             )
-            button.pack(pady=1)
+            button.pack(pady=1, fill=tk.X)
             # Save buttons in dictionary for later access
             self.run_buttons[mode] = button
 
         # Clear files button
-        self.clear_button = ttk.Button(button_frame, text="Clear Files", command=self._clear_files)
-        self.clear_button.pack(pady=8)
+        self.clear_input_button = ttk.Button(
+            button_frame, text="Clear Input Files", command=self._clear_input_files
+        )
+        self.clear_input_button.pack(pady=8, fill=tk.X)
+
+        self.clear_output_button = ttk.Button(
+            button_frame, text="Clear Generated Files", command=self._clear_output_files
+        )
+        self.clear_output_button.pack(pady=1, fill=tk.X)
 
         # Progress bar
         self.progress = ttk.Progressbar(button_frame, mode="indeterminate")
@@ -481,57 +556,159 @@ class MainGui:
         self.log_text.delete(1.0, tk.END)
         self.logger.debug("Log display cleared")
 
-    def _clear_files(self):
-        """Clear the file list."""
-        self.file_list.clear()
-        self.file_listbox.delete(0, tk.END)
-        self.logger.info("File list cleared")
+    def _clear_input_files(self):
+        """Clear the input file list."""
+        self.input_files.clear()
+        self.input_file_listbox.delete(0, tk.END)
+        self.logger.info("Input file list cleared")
+
+    def _clear_output_files(self):
+        """Clear the output file list."""
+        self.output_files.clear()
+        self.output_file_listbox.delete(0, tk.END)
+        self.logger.info("Generated file list cleared")
+
+    def _remove_selected_input_files(self):
+        """Remove selected files from the input file list."""
+        selected_indices = self.input_file_listbox.curselection()
+        if not selected_indices:
+            messagebox.showwarning("Warning", "No files selected to remove!")
+            return
+
+        # Delete from listbox from end to start to avoid index issues
+        for i in reversed(selected_indices):
+            self.input_file_listbox.delete(i)
+            del self.input_files[i]
+        self.logger.info(f"Removed {len(selected_indices)} selected input files.")
+
+    def _open_selected_file(self, event, file_list_source):
+        """Opens the selected file in the system's default application or explorer."""
+        selection_index = event.widget.nearest(event.y)
+        if selection_index == -1:  # No item clicked
+            return
+
+        file_path_str = file_list_source[selection_index]["path"]
+        file_path = Path(file_path_str)
+
+        if not file_path.exists():
+            self.logger.error(f"File not found: {file_path}")
+            messagebox.showerror("Error", f"File not found: {file_path}")
+            return
+
+        try:
+            if sys.platform == "win32":
+                os.startfile(file_path)
+            elif sys.platform == "darwin":
+                subprocess.Popen(["open", file_path])
+            else:
+                subprocess.Popen(["xdg-open", file_path])
+            self.logger.info(f"Opened file: {file_path}")
+        except Exception as e:
+            self.logger.error(f"Could not open file {file_path}: {e}")
+            messagebox.showerror("Error", f"Could not open file {file_path}: {e}")
 
     def _open_files(self):
         """Open file dialog and add files to list."""
         files = filedialog.askopenfilenames(
-            title="Select input files", filetypes=[("All files", "*.*"), ("Text files", "*.txt")]
+            title="Select input files",
+            filetypes=[
+                ("GPX/KML files", "*.gpx *.kml *.zip"),  # Added KML support
+                ("GPX files", "*.gpx"),
+                ("KML files", "*.kml"),
+                ("ZIP files", "*.zip"),
+                ("All files", "*.*"),
+            ],
         )
 
         new_files = 0
-        for file in files:
-            if file not in self.file_list:
-                self.file_list.append(file)
-                self.file_listbox.insert(tk.END, os.path.basename(file))
-                new_files += 1
+        for file_path_str in files:
+            file_path = Path(file_path_str)
+            if file_path_str not in [f["path"] for f in self.input_files]:
+                try:
+                    file_size_kb = file_path.stat().st_size / 1024
+                    self.input_files.append({"path": file_path_str, "size": file_size_kb})
+                    self.input_file_listbox.insert(
+                        tk.END, f"{file_path.name} ({file_size_kb:.2f} KB)"
+                    )
+                    new_files += 1
+                except Exception as e:
+                    self.logger.warning(f"Could not get size for {file_path_str}: {e}")
+                    self.input_files.append({"path": file_path_str, "size": 0})
+                    self.input_file_listbox.insert(tk.END, f"{file_path.name} (N/A KB)")
 
         if new_files > 0:
             self.logger.info(f"Added {new_files} new files to processing list")
         else:
             self.logger.debug("No new files selected")
 
+    def _update_output_listbox(self, generated_files_info):
+        """Updates the output file listbox with newly generated files."""
+        self.output_file_listbox.delete(0, tk.END)  # Clear current list
+        self.output_files.clear()  # Clear internal list
+        for file_path_str in generated_files_info:
+            file_path = Path(file_path_str)
+            try:
+                file_size_kb = file_path.stat().st_size / 1024
+                self.output_files.append({"path": file_path_str, "size": file_size_kb})
+                self.output_file_listbox.insert(tk.END, f"{file_path.name} ({file_size_kb:.2f} KB)")
+            except Exception as e:
+                self.logger.warning(f"Could not get size for generated file {file_path_str}: {e}")
+                self.output_files.append({"path": file_path_str, "size": 0})
+                self.output_file_listbox.insert(tk.END, f"{file_path.name} (N/A KB)")
+
+        if generated_files_info:
+            output_dir = Path(generated_files_info[0]).parent
+            self.logger.info(f"Generated files saved in: {output_dir}")  # Log directory
+
     def _run_processing(self, mode="compress_files"):
         """Run the processing in a separate thread."""
-        if not self.file_list:
-            self.logger.warning("No input files selected")
-            messagebox.showwarning("Warning", "No input files selected!")
+        selected_indices = self.input_file_listbox.curselection()
+        files_to_process = []
+
+        if selected_indices:
+            for i in selected_indices:
+                files_to_process.append(self.input_files[i]["path"])
+        else:
+            files_to_process = [f["path"] for f in self.input_files]
+
+        if not files_to_process:
+            self.logger.warning("No input files selected or all are deselected.")
+            messagebox.showwarning("Warning", "No input files selected or all are deselected!")
             return
 
-        self.logger.info(f"Starting processing of {len(self.file_list)} files in mode: {mode}")
+        self.logger.info(f"Starting processing of {len(files_to_process)} files in mode: {mode}")
 
-        # Alle Buttons während der Verarbeitung deaktivieren
+        # Disable all buttons during processing
         for button in self.run_buttons.values():
             button.config(state="disabled")
+        self.clear_input_button.config(state="disabled")
+        self.clear_output_button.config(state="disabled")
         self.progress.start()
 
         # Run in separate thread to avoid blocking GUI
-        thread = threading.Thread(target=self._process_files, args=(mode,), daemon=True)
+        thread = threading.Thread(
+            target=self._process_files,
+            args=(
+                mode,
+                files_to_process,
+            ),
+            daemon=True,
+        )
         thread.start()
 
-    def _process_files(self, mode="compress_files"):
+    def _process_files(self, mode="compress_files", files_to_process=None):
         """Process the selected files."""
+        generated_files_paths = []
         try:
             self.logger.info("=== Processing Started ===")
             self.logger.info("Processing files...")
 
+            if files_to_process is None:
+                files_to_process = []  # Should not happen with the check in _run_processing
+
             # Create and run project
             project = BaseGPXProcessor(
-                self.file_list,
+                files_to_process,  # Pass selected files
                 self.config_manager.cli.output.default,
                 self.config_manager.cli.min_dist.default,
                 self.config_manager.app.date_format.default,
@@ -540,18 +717,19 @@ class MainGui:
             )
             # implement switch case for different processing modes
             if mode == "compress_files":
-                project.compress_files()
+                generated_files_paths = project.compress_files()
             elif mode == "merge_files":
-                project.merge_files()
+                generated_files_paths = project.merge_files()
             elif mode == "extract_pois":
-                project.extract_pois()
+                generated_files_paths = project.extract_pois()
             else:
                 self.logger.warning(f"Unknown mode: {mode}")
 
-            self.logger.info(f"Completed: {len(self.file_list)} files processed")
-
+            self.logger.info(f"Completed: {len(files_to_process)} files processed")
             self.logger.info("=== All files processed successfully! ===")
 
+            self.root.after(0, self._update_output_listbox, generated_files_paths)
+
         except Exception as err:
             self.logger.error(f"Processing failed: {err}", exc_info=True)
             # Show error dialog in main thread
@@ -567,7 +745,8 @@ class MainGui:
         """Re-enable controls after processing is finished."""
         for button in self.run_buttons.values():
             button.config(state="normal")
-        self.clear_button.config(state="normal")
+        self.clear_input_button.config(state="normal")
+        self.clear_output_button.config(state="normal")
         self.progress.stop()
 
     def _open_settings(self):

{python_template_project-0.1.20.dist-info → python_template_project-0.1.21.dist-info}/METADATA

@@ -1,14 +1,16 @@
 Metadata-Version: 2.4
 Name: python-template-project
-Version: 0.1.20
+Version: 0.1.21
 Summary: Feature-rich Python project template designed for robustness and ease of use.
 Author: pamagister
 Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: fastkml>=1.1.0
 Requires-Dist: gpxpy>=1.6.2
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: shapely>=2.1.1
 Requires-Dist: srtm-py>=0.3.7
 Provides-Extra: dev
 Requires-Dist: pytest>=8.4.0; extra == "dev"

{python_template_project-0.1.20.dist-info → python_template_project-0.1.21.dist-info}/RECORD

@@ -3,21 +3,21 @@ firewall_handler.py,sha256=qT0dInkeKHulpCQD2x3HH7_lMxz4lwdkIPxEvBSl3No,7336
 main.py,sha256=d6ZpnMxcPBf860gQmuYwPVJg1di6r2CR6gSvFLkAZkk,4448
 python_template_project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_template_project/__main__.py,sha256=JS28LiHoU9Xo4c_RvyLBTDKHqdZRRytJLj6qyrg26mQ,195
-python_template_project/_version.py,sha256=HrX7HW5_qgG2kKtggMCOAOnIAM_IUpfjsr4EaS77COI,513
+python_template_project/_version.py,sha256=b9rzYHmy3i_G_wlsa53qvXrAz8O-mxRK23uXogBfZws,513
 python_template_project/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_template_project/cli/__main__.py,sha256=qnGkoNNbhnvLTA24X8YTEDxRqDbNEAzgjp9Ki_JYIhs,184
 python_template_project/cli/cli.py,sha256=Eumz1XfcBnpI4Yt1tn-TNG_VHLCvrDFREdx-6nI-sNY,6974
 python_template_project/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_template_project/config/config.py,sha256=naSOpbmMXZQfAoOrZuEPYhv1_9TKJtpxjRKBVzCKUlE,17924
 python_template_project/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_template_project/core/base.py,sha256=qZiQzA9ib-bxH-f3p9Rxzj8DD6nQQnhykd_Gqg4B3a4,22886
+python_template_project/core/base.py,sha256=Cl4fgT7ME_HZ8T_MVv5Rki9_xyG7kTsC-aJP8HJ3OMc,28017
 python_template_project/core/logging.py,sha256=D99ZAXY9KZvmV7oVlAy3S3fuDf9G7vHvIk277xB7068,6944
 python_template_project/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_template_project/gui/__main__.py,sha256=5AaiBxNCAKWcuSQFcQ_lsEQfEsXm6BA5-i5MScdf30c,184
-python_template_project/gui/gui.py,sha256=9xX36BK9iqBT67uiJmBAuqU1bupB5r_ceInljZgGBtI,21725
-python_template_project-0.1.20.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
-python_template_project-0.1.20.dist-info/METADATA,sha256=Mayn93-AieIAY7qPk36OnMRnVWxjYoVR5ENTQ-ZCOmU,5059
-python_template_project-0.1.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_template_project-0.1.20.dist-info/entry_points.txt,sha256=LmgMiqxIVRdD7gkktVBBR0CR4AhkugqlgifuglkPhtI,148
-python_template_project-0.1.20.dist-info/top_level.txt,sha256=O-Yg0tzEwgH58MhdcYWpJsgZSUPg6SBbOUwlmVHZo3A,55
-python_template_project-0.1.20.dist-info/RECORD,,
+python_template_project/gui/gui.py,sha256=0dNsWHvLu0l8lP-PNIHGUDjM0UM-aW_iN6uCJfo9fNw,30404
+python_template_project-0.1.21.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+python_template_project-0.1.21.dist-info/METADATA,sha256=CtgqqcU_vyydu5fI-hWmbZyE6kLJXKM19CQNwhL5jRM,5119
+python_template_project-0.1.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_template_project-0.1.21.dist-info/entry_points.txt,sha256=LmgMiqxIVRdD7gkktVBBR0CR4AhkugqlgifuglkPhtI,148
+python_template_project-0.1.21.dist-info/top_level.txt,sha256=O-Yg0tzEwgH58MhdcYWpJsgZSUPg6SBbOUwlmVHZo3A,55
+python_template_project-0.1.21.dist-info/RECORD,,