python-template-project 0.1.15__py3-none-any.whl → 0.1.18__py3-none-any.whl

firewall_handler.py

@@ -0,0 +1,198 @@
+import os
+import socket
+import subprocess
+import sys
+import traceback
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+class FirewallHandler:
+    """Handles firewall detection and configuration for network access."""
+
+    def __init__(self, logger=None):
+        self.logger = logger
+        self.test_urls = [
+            "http://httpbin.org/get",
+            "http://www.google.com",
+            "https://httpbin.org/get",
+            "https://www.google.com",
+        ]
+        self.srtm_urls = [
+            "https://cloud.sdsc.edu/v1/AUTH_opentopography/Raster/SRTM_GL1/",
+            "http://cloud.sdsc.edu/v1/AUTH_opentopography/Raster/SRTM_GL1/",
+        ]
+
+    def check_network_access(self, timeout: int = 5) -> bool:
+        """Check if network access is available."""
+        self.logger.info("Checking network connectivity...")
+
+        # First check basic connectivity
+        if not self._check_basic_connectivity():
+            self.logger.warning("Basic network connectivity failed")
+            return False
+
+        # Then check HTTP access
+        if not self._check_http_access(timeout):
+            self.logger.warning("HTTP access failed")
+            return False
+
+        # Finally check SRTM-specific URLs
+        if not self._check_srtm_access(timeout):
+            self.logger.warning("SRTM service access failed")
+            return False
+
+        self.logger.info("Network access verified successfully")
+        return True
+
+    def _check_basic_connectivity(self) -> bool:
+        """Check basic network connectivity using socket."""
+        try:
+            # Try to connect to DNS servers
+            for host, port in [("8.8.8.8", 53), ("1.1.1.1", 53)]:
+                try:
+                    with socket.create_connection((host, port), timeout=3):
+                        return True
+                except (TimeoutError, OSError):
+                    continue
+            return False
+        except Exception as e:
+            self.logger.debug(f"Basic connectivity check failed: {e}")
+            return False
+
+    def _check_http_access(self, timeout: int) -> bool:
+        """Check HTTP access to common websites."""
+        for url in self.test_urls:
+            try:
+                with urllib.request.urlopen(url, timeout=timeout) as response:
+                    if response.status == 200:
+                        self.logger.debug(f"HTTP access confirmed via {url}")
+                        return True
+            except (TimeoutError, urllib.error.URLError, urllib.error.HTTPError) as e:
+                self.logger.debug(f"HTTP access failed for {url}: {e}")
+                continue
+        return False
+
+    def _check_srtm_access(self, timeout: int) -> bool:
+        """Check access to SRTM-specific URLs."""
+        for url in self.srtm_urls:
+            try:
+                with urllib.request.urlopen(url, timeout=timeout) as response:
+                    if response.status in [200, 403]:  # 403 is expected for directory listing
+                        self.logger.debug(f"SRTM access confirmed via {url}")
+                        return True
+            except (TimeoutError, urllib.error.URLError, urllib.error.HTTPError) as e:
+                self.logger.debug(f"SRTM access failed for {url}: {e}")
+                continue
+        return False
+
+    def handle_firewall_issue(self):
+        """Handle firewall issues by attempting to create rules and inform user."""
+        self.logger.info("Attempting to resolve firewall issues...")
+
+        # Get current executable path
+        exe_path = self._get_executable_path()
+        if not exe_path:
+            self.logger.error("Could not determine executable path")
+            self._show_manual_instructions()
+            return
+
+        # Try to create firewall rules
+        if self._is_windows():
+            self._handle_windows_firewall(exe_path)
+        else:
+            self._handle_linux_firewall(exe_path)
+
+    def _get_executable_path(self) -> str | None:
+        """Get the path of the current executable."""
+        try:
+            if getattr(sys, "frozen", False):
+                # PyInstaller executable
+                return sys.executable
+            else:
+                # Python script
+                return sys.executable
+        except Exception as e:
+            self.logger.error(f"Error getting executable path: {e}")
+            return None
+
+    def _is_windows(self) -> bool:
+        """Check if running on Windows."""
+        return os.name == "nt"
+
+    def _handle_windows_firewall(self, exe_path: str):
+        """Handle Windows firewall configuration."""
+        self.logger.info("Attempting to configure Windows Firewall...")
+
+        app_name = Path(exe_path).stem
+
+        # Commands to add firewall rules
+        commands = [
+            # Inbound rule
+            [
+                "netsh",
+                "advfirewall",
+                "firewall",
+                "add",
+                "rule",
+                f"name={app_name}_Inbound",
+                "dir=in",
+                "action=allow",
+                f"program={exe_path}",
+                "enable=yes",
+            ],
+            # Outbound rule
+            [
+                "netsh",
+                "advfirewall",
+                "firewall",
+                "add",
+                "rule",
+                f"name={app_name}_Outbound",
+                "dir=out",
+                "action=allow",
+                f"program={exe_path}",
+                "enable=yes",
+            ],
+        ]
+
+        success = False
+        for cmd in commands:
+            try:
+                result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+                self.logger.info(
+                    f"Firewall rule added successfully: {' '.join(cmd)} result: {result}"
+                )
+                success = True
+            except subprocess.CalledProcessError as e:
+                self.logger.warning(f"Failed to add firewall rule: {e}")
+                self.logger.debug(f"Command: {' '.join(cmd)}")
+                self.logger.debug(f"Error output: {e.stderr}")
+            except Exception as e:
+                self.logger.error(f"Unexpected error adding firewall rule: {e}")
+                self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+
+        if success:
+            self.logger.info(
+                "Windows Firewall rules added successfully. Please restart the application."
+            )
+        else:
+            self.logger.warning("Failed to automatically configure Windows Firewall.")
+            self._show_manual_instructions()
+
+    def _handle_linux_firewall(self, exe_path: str):
+        """Handle Linux firewall configuration."""
+        self.logger.info("Detected Linux system. Firewall configuration may be needed.")
+        self._show_manual_instructions()
+
+    def _show_manual_instructions(self):
+        """Show general manual instructions"""
+        self.logger.info(
+            "Please check your firewall settings and ensure the application has network access.\n"
+            "Refer to the documentation for manual configuration steps."
+            "quick solution:"
+            "Start your EXE as administrator:"
+            "Right-click on EXE → Run as administrator"
+            "Or temporarily deactivate the firewall:"
+        )

python_template_project/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.15'
-__version_tuple__ = version_tuple = (0, 1, 15)
+__version__ = version = '0.1.18'
+__version_tuple__ = version_tuple = (0, 1, 18)

python_template_project/core/base.py

@@ -1,12 +1,21 @@
 import math
+import traceback
 import zipfile
 from datetime import datetime
 from pathlib import Path
 
 import gpxpy
-import srtm
 from gpxpy.gpx import GPX, GPXTrackPoint, GPXWaypoint, GPXXMLSyntaxException
 
+# Optional SRTM import with fallback
+try:
+    import srtm
+
+    SRTM_AVAILABLE = True
+except ImportError:
+    SRTM_AVAILABLE = False
+    srtm = None
+
 NAME = "python_template_project"
 
 
@@ -34,11 +43,72 @@ class BaseGPXProcessor:
         self.min_dist = min_dist
         self.date_format = date_format
         self.include_elevation = elevation
-
-        # Initialize SRTM elevation data
-        self.elevation_data = srtm.get_data()
         self.logger = logger
 
+        # Initialize SRTM elevation data only if elevation is requested and SRTM is available
+        self.elevation_data = None
+        self.srtm_available = False
+
+        if self.include_elevation:
+            self._initialize_elevation_data()
+
+    def _initialize_elevation_data(self):
+        """Initialize SRTM elevation data with proper error handling."""
+        if not SRTM_AVAILABLE:
+            self.logger.warning(
+                "SRTM library not available. "
+                "Elevation data will use original GPX values or default to 0."
+            )
+            return
+
+        try:
+            self.logger.info("Initializing SRTM elevation data...")
+            self.elevation_data = srtm.get_data()
+            self.srtm_available = True
+            self.logger.info("SRTM elevation data initialized successfully.")
+        except AssertionError as e:
+            self.logger.error(f"SRTM initialization failed with AssertionError: {e}")
+            self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+            self._handle_srtm_failure("SRTM assertion failed - possibly network or firewall issue")
+        except Exception as e:
+            self.logger.error(f"SRTM initialization failed: {e}")
+            self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+            self._handle_srtm_failure(f"SRTM initialization error: {str(e)}")
+
+    def _handle_srtm_failure(self, error_msg: str):
+        """Handle SRTM initialization failure with firewall check."""
+        self.srtm_available = False
+        self.elevation_data = None
+
+        self.logger.warning(f"SRTM elevation data unavailable: {error_msg}")
+        self.logger.info("Checking for network/firewall issues...")
+
+        # Import and use firewall handler
+        try:
+            from firewall_handler import FirewallHandler
+
+            firewall_handler = FirewallHandler(logger=self.logger)
+
+            if not firewall_handler.check_network_access():
+                self.logger.warning("Network access appears to be blocked.")
+                firewall_handler.handle_firewall_issue()
+            else:
+                self.logger.info(
+                    "Network access seems available. SRTM issue may be service-related."
+                )
+
+        except ImportError:
+            self.logger.warning(
+                "FirewallHandler not available. Continuing without network diagnostics."
+            )
+        except Exception as e:
+            self.logger.error(f"Error during firewall check: {e}")
+            self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+
+        self.logger.info(
+            "Continuing in offline mode - using original elevation data from GPX files."
+        )
+
     def _get_output_folder(self) -> Path:
         """Get the output folder path, create if not exists."""
         if self.output:
@@ -52,31 +122,49 @@ class BaseGPXProcessor:
 
     def _get_adjusted_elevation(self, point: GPXTrackPoint) -> int | float:
         """Get adjusted elevation from SRTM data, fallback to original elevation."""
-        try:
-            srtm_elevation = self.elevation_data.get_elevation(point.latitude, point.longitude)
-            if srtm_elevation is not None:
-                return round(srtm_elevation, 1)
-        except Exception:
-            pass
+        # If elevation is not requested, return None
+        if not self.include_elevation:
+            return None
+
+        # If SRTM is available and working, try to get elevation data
+        if self.srtm_available and self.elevation_data:
+            try:
+                srtm_elevation = self.elevation_data.get_elevation(point.latitude, point.longitude)
+                if srtm_elevation is not None:
+                    return round(srtm_elevation, 1)
+            except Exception as e:
+                self.logger.info(
+                    f"Error getting SRTM elevation "
+                    f"for point ({point.latitude}, {point.longitude}): {e}"
+                )
+                # Don't disable SRTM entirely for single point failures
+                pass
 
         # Fallback to original elevation or 0
-        return round(point.elevation or 0, 1)
+        original_elevation = (
+            point.elevation if hasattr(point, "elevation") and point.elevation is not None else 0
+        )
+        return round(original_elevation, 1)
 
     @staticmethod
     def _calculate_distance(point1: GPXTrackPoint, point2: GPXTrackPoint) -> float:
         """Calculate distance between two GPX points in meters using Haversine formula."""
-        lat1, lon1 = math.radians(point1.latitude), math.radians(point1.longitude)
-        lat2, lon2 = math.radians(point2.latitude), math.radians(point2.longitude)
+        try:
+            lat1, lon1 = math.radians(point1.latitude), math.radians(point1.longitude)
+            lat2, lon2 = math.radians(point2.latitude), math.radians(point2.longitude)
 
-        dlat = lat2 - lat1
-        dlon = lon2 - lon1
+            dlat = lat2 - lat1
+            dlon = lon2 - lon1
 
-        a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
-        c = 2 * math.asin(math.sqrt(a))
+            a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
+            c = 2 * math.asin(math.sqrt(a))
 
-        # Earth's radius in meters
-        earth_radius = 6371000
-        return earth_radius * c
+            # Earth's radius in meters
+            earth_radius = 6371000
+            return earth_radius * c
+        except (AttributeError, TypeError, ValueError):
+            # Handle cases where points might have invalid coordinates
+            return 0.0
 
     def _optimize_track_points(
         self, track_points: list[GPXTrackPoint] | list[GPXWaypoint]
@@ -85,70 +173,86 @@ class BaseGPXProcessor:
         if not track_points:
             return track_points
 
-        optimized_points = [track_points[0]]  # Always keep first point
-
-        for point in track_points[1:]:
-            # Check distance to last kept point
-            if self._calculate_distance(optimized_points[-1], point) >= self.min_dist:
-                optimized_points.append(point)
-
-        # Always keep last point if it's different from the last kept point
-        if len(track_points) > 1 and optimized_points[-1] != track_points[-1]:
-            optimized_points.append(track_points[-1])
-
-        # Clean and optimize each point
-        for point in optimized_points:
-            # Remove time information
-            point.time = None
-
-            # Round coordinates to 5 decimal places
-            point.latitude = round(point.latitude, 5)
-            point.longitude = round(point.longitude, 5)
+        try:
+            optimized_points = [track_points[0]]  # Always keep first point
+
+            for point in track_points[1:]:
+                # Check distance to last kept point
+                if self._calculate_distance(optimized_points[-1], point) >= self.min_dist:
+                    optimized_points.append(point)
+
+            # Always keep last point if it's different from the last kept point
+            if len(track_points) > 1 and optimized_points[-1] != track_points[-1]:
+                optimized_points.append(track_points[-1])
+
+            # Clean and optimize each point
+            for point in optimized_points:
+                try:
+                    # Remove time information
+                    point.time = None
+
+                    # Round coordinates to 5 decimal places
+                    if hasattr(point, "latitude") and point.latitude is not None:
+                        point.latitude = round(point.latitude, 5)
+                    if hasattr(point, "longitude") and point.longitude is not None:
+                        point.longitude = round(point.longitude, 5)
+
+                    # Set optimized elevation
+                    point.elevation = self._get_adjusted_elevation(point)
+
+                    # Remove unnecessary extensions and metadata
+                    point.extensions = None
+                    if hasattr(point, "symbol"):
+                        point.symbol = None
+                    if hasattr(point, "type"):
+                        point.type = None
+                    point.comment = None
+                    point.description = None
+                    point.source = None
+                    point.link = None
+                    point.link_text = None
+                    point.link_type = None
+                    point.horizontal_dilution = None
+                    point.vertical_dilution = None
+                    point.position_dilution = None
+                    point.age_of_dgps_data = None
+                    point.dgps_id = None
+                except Exception as e:
+                    self.logger.warning(f"Error optimizing point: {e}")
+                    continue
+
+            return optimized_points
 
-            # Set optimized elevation
-            if self.include_elevation:
-                point.elevation = self._get_adjusted_elevation(point)
-            else:
-                point.elevation = None
-
-            # Remove unnecessary extensions and metadata
-            point.extensions = None
-            point.symbol = None
-            point.type = None
-            point.comment = None
-            point.description = None
-            point.source = None
-            point.link = None
-            point.link_text = None
-            point.link_type = None
-            point.horizontal_dilution = None
-            point.vertical_dilution = None
-            point.position_dilution = None
-            point.age_of_dgps_data = None
-            point.dgps_id = None
-
-        return optimized_points
+        except Exception as e:
+            self.logger.error(f"Error optimizing track points: {e}")
+            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:
-            if not isinstance(input_path, Path):
-                input_path = Path(input_path)
-            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)
-                elif input_path.suffix.lower() == ".zip":
-                    gpx_files.extend(self._extract_gpx_from_zip(input_path))
-            elif input_path.is_dir():
-                # Get all GPX files in directory
-                gpx_files.extend(input_path.glob("*.gpx"))
-
-                # Get GPX files from ZIP files in directory
-                for zip_file in input_path.glob("*.zip"):
-                    gpx_files.extend(self._extract_gpx_from_zip(zip_file))
+            try:
+                if not isinstance(input_path, Path):
+                    input_path = Path(input_path)
+                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)
+                    elif input_path.suffix.lower() == ".zip":
+                        gpx_files.extend(self._extract_gpx_from_zip(input_path))
+                elif input_path.is_dir():
+                    # Get all GPX files in directory
+                    gpx_files.extend(input_path.glob("*.gpx"))
+
+                    # Get GPX files from ZIP files in directory
+                    for zip_file in input_path.glob("*.zip"):
+                        gpx_files.extend(self._extract_gpx_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
 
@@ -156,9 +260,10 @@ class BaseGPXProcessor:
         """Extract GPX files from ZIP archive to temporary location."""
         gpx_files = []
         temp_dir = Path.cwd() / "temp_gpx_extract"
-        temp_dir.mkdir(exist_ok=True)
 
         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"):
@@ -168,6 +273,7 @@ class BaseGPXProcessor:
                         gpx_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
 
@@ -181,6 +287,7 @@ class BaseGPXProcessor:
             return None
         except Exception as e:
             self.logger.error(f"Error loading GPX file {gpx_path}: {e}")
+            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):
@@ -199,199 +306,244 @@ class BaseGPXProcessor:
 
         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()}")
 
     def compress_files(self):
         """Shrink the size of all given gpx files in self.input."""
-        gpx_files = self._get_gpx_files()
-        output_folder = self._get_output_folder()
-
-        self.logger.info(f"Processing {len(gpx_files)} GPX files...")
+        try:
+            gpx_files = self._get_gpx_files()
+            output_folder = self._get_output_folder()
 
-        for gpx_file in gpx_files:
-            gpx = self._load_gpx_file(gpx_file)
-            if gpx is None:
-                continue
+            self.logger.info(f"Processing {len(gpx_files)} GPX files...")
 
-            # process and clean waypoints
-            for waypoint in gpx.waypoints:
-                self._optimize_waypoint(waypoint)
+            for gpx_file in gpx_files:
+                try:
+                    gpx = self._load_gpx_file(gpx_file)
+                    if gpx is None:
+                        continue
 
-            # Process all tracks
-            for track in gpx.tracks:
-                for segment in track.segments:
-                    segment.points = self._optimize_track_points(segment.points)
+                    # process and clean waypoints
+                    for waypoint in gpx.waypoints:
+                        self._optimize_waypoint(waypoint)
 
-            # Process all routes
-            for route in gpx.routes:
-                route.points = self._optimize_track_points(route.points)
+                    # Process all tracks
+                    for track in gpx.tracks:
+                        for segment in track.segments:
+                            segment.points = self._optimize_track_points(segment.points)
 
-            # Clean GPX metadata
-            gpx.time = None
-            gpx.extensions = None
+                    # Process all routes
+                    for route in gpx.routes:
+                        route.points = self._optimize_track_points(route.points)
 
-            # 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}")
+                    # Clean GPX metadata
+                    gpx.time = None
+                    gpx.extensions = None
 
-    def _optimize_waypoint(self, waypoint):
-        # Round coordinates and elevation
-        waypoint.latitude = round(waypoint.latitude, 5)
-        waypoint.longitude = round(waypoint.longitude, 5)
-        if self.include_elevation:
-            waypoint.elevation = self._get_adjusted_elevation(waypoint)
-        else:
-            waypoint.elevation = None
-
-        # Clean metadata
-        waypoint.time = None
-        waypoint.extensions = None
-        waypoint.symbol = None
-        waypoint.type = None
-        waypoint.comment = None
-        waypoint.description = None
-        waypoint.source = None
-        waypoint.link = None
-        waypoint.link_text = None
-        waypoint.link_type = None
-        return waypoint
+                    # 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}")
 
-    def merge_files(self):
-        """Merge all files of self.input into one gpx file with reduced resolution."""
-        gpx_files = self._get_gpx_files()
-        output_folder = self._get_output_folder()
+                except Exception as e:
+                    self.logger.error(f"Error processing file {gpx_file}: {e}")
+                    self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+                    continue
 
-        if not gpx_files:
-            self.logger.error("No GPX files found to merge.")
-            return
+        except Exception as e:
+            self.logger.error(f"Error in compress_files: {e}")
+            self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+            raise
 
-        self.logger.info(f"Merging {len(gpx_files)} GPX files...")
+    def _optimize_waypoint(self, waypoint):
+        """Optimize waypoint with error handling."""
+        try:
+            # Round coordinates and elevation
+            if hasattr(waypoint, "latitude") and waypoint.latitude is not None:
+                waypoint.latitude = round(waypoint.latitude, 5)
+            if hasattr(waypoint, "longitude") and waypoint.longitude is not None:
+                waypoint.longitude = round(waypoint.longitude, 5)
 
-        # 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: {', '.join(str(f.name) for f in gpx_files)}"
-        )
+            waypoint.elevation = self._get_adjusted_elevation(waypoint)
 
-        track_counter = 1
+            # Clean metadata
+            waypoint.time = None
+            waypoint.extensions = None
+            if hasattr(waypoint, "symbol"):
+                waypoint.symbol = None
+            if hasattr(waypoint, "type"):
+                waypoint.type = None
+            waypoint.comment = None
+            waypoint.description = None
+            waypoint.source = None
+            waypoint.link = None
+            waypoint.link_text = None
+            waypoint.link_type = None
+            return waypoint
+        except Exception as e:
+            self.logger.warning(f"Error optimizing waypoint: {e}")
+            return waypoint
 
-        for gpx_file in gpx_files:
-            gpx = self._load_gpx_file(gpx_file)
-            if gpx is None:
-                continue
+    def merge_files(self):
+        """Merge all files of self.input into one gpx file with reduced resolution."""
+        try:
+            gpx_files = self._get_gpx_files()
+            output_folder = self._get_output_folder()
+
+            if not gpx_files:
+                self.logger.error("No GPX files found to merge.")
+                return
+
+            self.logger.info(f"Merging {len(gpx_files)} GPX 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."
+
+            track_counter = 1
+
+            for gpx_file in gpx_files:
+                try:
+                    gpx = self._load_gpx_file(gpx_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}"
+                        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}"
+
+                        for segment in track.segments:
+                            optimized_points = self._optimize_track_points(segment.points)
+                            if optimized_points:
+                                new_segment = gpxpy.gpx.GPXTrackSegment()
+                                new_segment.points = optimized_points
+                                new_track.segments.append(new_segment)
+
+                        if new_track.segments:
+                            merged_gpx.tracks.append(new_track)
+                            track_counter += 1
+
+                    # 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.points = self._optimize_track_points(route.points)
+
+                        if new_route.points:
+                            merged_gpx.routes.append(new_route)
+                            track_counter += 1
+
+                except Exception as e:
+                    self.logger.error(f"Error processing file {gpx_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}")
 
-            # Add all waypoints from this file
-            for waypoint in gpx.waypoints:
-                waypoint = self._optimize_waypoint(waypoint)
-                waypoint.name = f"{waypoint.name}_{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}"
-
-                for segment in track.segments:
-                    optimized_points = self._optimize_track_points(segment.points)
-                    if optimized_points:
-                        new_segment = gpxpy.gpx.GPXTrackSegment()
-                        new_segment.points = optimized_points
-                        new_track.segments.append(new_segment)
-
-                if new_track.segments:
-                    merged_gpx.tracks.append(new_track)
-                    track_counter += 1
-
-            # 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.points = self._optimize_track_points(route.points)
-
-                if new_route.points:
-                    merged_gpx.routes.append(new_route)
-                    track_counter += 1
-
-        # 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}")
+        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):
         """Merge every starting point of each track in all files
         into one gpx file with many pois."""
-
-        gpx_files = self._get_gpx_files()
-        output_folder = self._get_output_folder()
-
-        if not gpx_files:
-            self.logger.error("No GPX files found to extract POIs from.")
-            return
-
-        self.logger.info(f"Extracting POIs from {len(gpx_files)} GPX 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_counter = 1
-
-        for gpx_file in gpx_files:
-            gpx = self._load_gpx_file(gpx_file)
-            if gpx is None:
-                continue
-
-            # Extract starting points from tracks
-            for track_idx, track in enumerate(gpx.tracks):
-                for _segment_idx, segment in enumerate(track.segments):
-                    if segment.points:
-                        start_point = segment.points[0]
-
-                        # Create waypoint from starting point
-                        waypoint = gpxpy.gpx.GPXWaypoint(
-                            latitude=round(start_point.latitude, 5),
-                            longitude=round(start_point.longitude, 5),
-                            elevation=self._get_adjusted_elevation(start_point),
-                        )
-
-                        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.type = "Track Start"
-
-                        poi_gpx.waypoints.append(waypoint)
-                        poi_counter += 1
-
-            # Extract starting points from routes
-            for route_idx, route in enumerate(gpx.routes):
-                if route.points:
-                    start_point = route.points[0]
-
-                    # Create waypoint from starting point
-                    waypoint = gpxpy.gpx.GPXWaypoint(
-                        latitude=round(start_point.latitude, 5),
-                        longitude=round(start_point.longitude, 5),
-                        elevation=self._get_adjusted_elevation(start_point),
+        try:
+            gpx_files = self._get_gpx_files()
+            output_folder = self._get_output_folder()
+
+            if not gpx_files:
+                self.logger.error("No GPX files found to extract POIs from.")
+                return
+
+            self.logger.info(f"Extracting POIs from {len(gpx_files)} GPX 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_counter = 1
+
+            for gpx_file in gpx_files:
+                try:
+                    gpx = self._load_gpx_file(gpx_file)
+                    if gpx is None:
+                        continue
+
+                    # Extract starting points from tracks
+                    for track_idx, track in enumerate(gpx.tracks):
+                        for _segment_idx, segment in enumerate(track.segments):
+                            if segment.points:
+                                start_point = segment.points[0]
+
+                                # Create waypoint from starting point
+                                waypoint = gpxpy.gpx.GPXWaypoint(
+                                    latitude=round(start_point.latitude, 5),
+                                    longitude=round(start_point.longitude, 5),
+                                    elevation=self._get_adjusted_elevation(start_point),
+                                )
+
+                                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.type = "Track Start"
+
+                                poi_gpx.waypoints.append(waypoint)
+                                poi_counter += 1
+
+                    # Extract starting points from routes
+                    for route_idx, route in enumerate(gpx.routes):
+                        if route.points:
+                            start_point = route.points[0]
+
+                            # Create waypoint from starting point
+                            waypoint = gpxpy.gpx.GPXWaypoint(
+                                latitude=round(start_point.latitude, 5),
+                                longitude=round(start_point.longitude, 5),
+                                elevation=self._get_adjusted_elevation(start_point),
+                            )
+
+                            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.type = "Route Start"
+
+                            poi_gpx.waypoints.append(waypoint)
+                            poi_counter += 1
+
+                except Exception as e:
+                    self.logger.error(
+                        f"Error processing file {gpx_file} during POI extraction: {e}"
                     )
+                    self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+                    continue
 
-                    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.type = "Route Start"
-
-                    poi_gpx.waypoints.append(waypoint)
-                    poi_counter += 1
+            # 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}"
+            )
 
-        # 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}")
+            # Clean up temporary files
+            temp_dir = Path.cwd() / "temp_gpx_extract"
+            if temp_dir.exists():
+                import shutil
 
-        # Clean up temporary files
-        temp_dir = Path.cwd() / "temp_gpx_extract"
-        if temp_dir.exists():
-            import shutil
+                shutil.rmtree(temp_dir)
 
-            shutil.rmtree(temp_dir)
+        except Exception as e:
+            self.logger.error(f"Error in extract_pois: {e}")
+            self.logger.debug(f"Full traceback:\n{traceback.format_exc()}")
+            raise

{python_template_project-0.1.15.dist-info → python_template_project-0.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-template-project
-Version: 0.1.15
+Version: 0.1.18
 Summary: Feature-rich Python project template designed for robustness and ease of use.
 Author: pamagister
 Requires-Python: <3.12,>=3.10
@@ -43,54 +43,44 @@ A feature-rich Python project template with with auto-generated CLI, GUI and par
 
 This template provides a solid foundation for your next Python project, incorporating best practices for testing, automation, and distribution. It streamlines the development process with a comprehensive set of pre-configured tools and workflows, allowing you to focus on writing code.
 
+## Installation
 
-## Feature overview
+Download from [PyPI](https://pypi.org/).
 
-* **Testing:** Unit testing setup with `pytest`.
-* **CI/CD:**  [GitHub Actions](https://github.com/features/actions) for automated builds (Windows, macOS), unit tests, and code checks.
-* **Code Formatting and Linting:** Pre-commit hook with the [RUFF auto-formatter](https://docs.astral.sh/ruff/) to ensure consistent code style.
-* **Automated Builds:** GitHub pipeline for automatically building a Windows executable and a macOS installer.
-* **Package Management:** Utilizes [uv](https://docs.astral.sh/uv/getting-started/), an extremely fast Python package manager, with dependencies managed in `pyproject.toml`.
-* **Parameter-Driven Automation:**
-    * Automatic generation of a configuration file from parameter definitions.
-    * Automatic generation of a Command-Line Interface (CLI) from the same parameters.
-    * Automatic generation of CLI API documentation.
-* **Documentation:** Configuration for publishing documentation on [Read the Docs](https://about.readthedocs.com/) using [mkdocs](https://www.mkdocs.org/) .
-* **Workflow Automation:** A `Makefile` is included to simplify and automate common development tasks.
-* **Minimalist GUI:** Comes with a basic GUI based on [tkinker](https://tkdocs.com/tutorial/index.html) that includes an auto-generated settings menu based on your defined parameters.
-* **Release pipeline:** Automated releases unsing the Makefile `make release` command, which creates a new tag and pushes it to the remote repo. The `release` pipeline will automatically create a new release on GitHub and trigger a release on PyPI.
-    * **[setuptools](https://pypi.org/project/setuptools/)** is used to package the project and manage dependencies.
-    * **[setuptools-scm](https://pypi.org/project/setuptools-scm/)** is used to automatically generate the `_version.py` file from the `pyproject.toml` file.
+💾 For more installation options see [install](getting-started/install.md).
 
-## Getting started
-
-1. **Create** a new [github repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/creating-a-new-repository).
-2. **Clone** [github repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) the into your local file system.
-    ```bash
-    git clone https://github.com/YOUR-USERNAME/YOUR-REPOSITORY
-    ```
-4. **Install** [uv package and project manager](https://docs.astral.sh/uv/getting-started/installation/)
-    ```bash
-    pip install uv
-    ```
-5. **Generate** [a sample project](https://docs.astral.sh/uv/guides/projects/#creating-a-new-project) with uv
-6. Add and **push** the artifacts to your github repository
-    ```bash
-    git push
-    ```
-8. Copy the content of this repository into your repository
-
-## Troubleshooting
-
-### Problems with release pipeline
-
-If you get this error below:
 ```bash
-/home/runner/work/_temp/xxxx_xxx.sh: line 1: .github/release_message.sh: Permission denied
+pip install python-template-project
 ```
 
-You have to run these commands in your IDE Terminal or the git bash and then push the changes.
+Run GUI from command line
+
 ```bash
-git update-index --chmod=+x ./.github/release_message.sh
+python-template-project-gui
 ```
 
+## How to use this template
+
+🐍 For details, see the [Getting Started](develop/01_getting_started_dev.md) guide.
+
+
+## Feature overview
+
+* 📦 **Package Management:** Utilizes [uv](https://docs.astral.sh/uv/getting-started/), an extremely fast Python package manager, with dependencies managed in `pyproject.toml`.
+* ✅ **Code Formatting and Linting:** Pre-commit hook with the [RUFF auto-formatter](https://docs.astral.sh/ruff/) to ensure consistent code style.
+* 🧪 **Testing:** Unit testing framework with [pytest](https://docs.pytest.org/en/latest/).
+* 📊 **Code coverage reports** using [codecov](https://about.codecov.io/sign-up/)
+* 🔄 **CI/CD:**  [GitHub Actions](https://github.com/features/actions) for automated builds (Windows, macOS), unit tests, and code checks.
+* 💾 **Automated Builds:** GitHub pipeline for automatically building a Windows executable and a macOS installer.
+* 💬 **Parameter-Driven Automation:**
+    * Automatic generation of a configuration file from parameter definitions.
+    * Automatic generation of a Command-Line Interface (CLI) from the same parameters.
+    * Automatic generation of CLI API documentation.
+    * Automatic generation of change log using **gitchangelog** to keep a HISTORY.md file up to date.
+* 📃 **Documentation:** Configuration for publishing documentation on [Read the Docs](https://about.readthedocs.com/) using [mkdocs](https://www.mkdocs.org/) .
+* 🖼️ **Minimalist GUI:** Comes with a basic GUI based on [tkinker](https://tkdocs.com/tutorial/index.html) that includes an auto-generated settings menu based on your defined parameters.
+* 🖥️ **Workflow Automation:** A `Makefile` is included to simplify and automate common development tasks.
+* 🛳️ **Release pipeline:** Automated releases unsing the Makefile `make release` command, which creates a new tag and pushes it to the remote repo. The `release` pipeline will automatically create a new release on GitHub and trigger a release on  [PyPI](https://pypi.org.
+    * **[setuptools](https://pypi.org/project/setuptools/)** is used to package the project and manage dependencies.
+    * **[setuptools-scm](https://pypi.org/project/setuptools-scm/)** is used to automatically generate the `_version.py` file from the `pyproject.toml` file.
+

{python_template_project-0.1.15.dist-info → python_template_project-0.1.18.dist-info}/RECORD

@@ -1,22 +1,23 @@
 __init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=OX-WIjJlMaFvqRmCfLtOYEOYoiov9NdOA089N36rG-g,513
+python_template_project/_version.py,sha256=mhAYdSWzD7l6mXhR3foHESbkj_QM4Asoa3WlsLLYkfM,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=RvoYKJDjP-PYlX4m5xFnUsuHVJw_3-AgpQwOxhPAH5g,6974
 python_template_project/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_template_project/config/config.py,sha256=bVqFIY8oScfhv2LpjcNoyiGqrIyVz5Ri3VjVnem1ZPA,17924
 python_template_project/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_template_project/core/base.py,sha256=0qLUlpc9zhbBgo_PGH-KsGHoNcmGbNPKIuLNpa9mMGI,15196
+python_template_project/core/base.py,sha256=qZiQzA9ib-bxH-f3p9Rxzj8DD6nQQnhykd_Gqg4B3a4,22886
 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=qJ9SawFywwT7ffPndTzhuLEu2KkzjBspmSccAXgUC2k,21725
-python_template_project-0.1.15.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
-python_template_project-0.1.15.dist-info/METADATA,sha256=N0SI3VOLkBfla0VrMu1Xj6H0EQJNJhxYwkKSSZdMmOY,5555
-python_template_project-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_template_project-0.1.15.dist-info/entry_points.txt,sha256=LmgMiqxIVRdD7gkktVBBR0CR4AhkugqlgifuglkPhtI,148
-python_template_project-0.1.15.dist-info/top_level.txt,sha256=9TFlucRiaKsVFCd9mTKCxamJW6LmFnXFXeI7WIvv4AA,38
-python_template_project-0.1.15.dist-info/RECORD,,
+python_template_project-0.1.18.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+python_template_project-0.1.18.dist-info/METADATA,sha256=jAhxpJFP6uHiFbIqV8YtMjiPNJ0P_aqrQI0ZdPjlJJ8,5059
+python_template_project-0.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_template_project-0.1.18.dist-info/entry_points.txt,sha256=LmgMiqxIVRdD7gkktVBBR0CR4AhkugqlgifuglkPhtI,148
+python_template_project-0.1.18.dist-info/top_level.txt,sha256=O-Yg0tzEwgH58MhdcYWpJsgZSUPg6SBbOUwlmVHZo3A,55
+python_template_project-0.1.18.dist-info/RECORD,,

{python_template_project-0.1.15.dist-info → python_template_project-0.1.18.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
 __init__
+firewall_handler
 main
 python_template_project