python-template-project 0.1.0__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:"
+        )

main.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""
+Unified entry point for CLI and GUI application.
+Automatically detects whether to run CLI or GUI based on how the application is started.
+"""
+
+import os
+import sys
+
+
+def is_console_attached():
+    """
+    Check if the application is running in a console environment.
+    Returns True if launched from console, False if launched via double-click.
+    """
+    try:
+        # On Windows, check if we have a console attached
+        if os.name == "nt":
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            # GetConsoleWindow returns 0 if no console is attached
+            console_window = kernel32.GetConsoleWindow()
+            if console_window == 0:
+                return False
+
+            # Check if the console was created by this process
+            # (indicates double-click launch with console auto-created)
+            process_list = kernel32.GetConsoleProcessList(None, 0)
+            if process_list <= 1:
+                return False
+
+            return True
+        else:
+            # On Unix-like systems (macOS, Linux), check multiple indicators
+            # Check if stdout is a terminal
+            if not sys.stdout.isatty():
+                return False
+
+            # Additional check for macOS: Check if we're running in a .app bundle
+            if sys.platform == "darwin":
+                # If we're in a .app bundle, we're likely launched via double-click
+                executable_path = sys.executable
+                if ".app/" in executable_path:
+                    # We're in an app bundle, check if we have a real terminal
+                    # by checking if TERM environment variable is set
+                    return os.environ.get("TERM") is not None
+
+            return True
+    except Exception as ex:
+        # Fallback: assume GUI if we can't determine
+        print(ex)
+        return False
+
+
+def has_command_line_args():
+    """Check if command line arguments (beyond script name) are provided."""
+    return len(sys.argv) > 1
+
+
+def main():
+    """Main entry point that decides between CLI and GUI."""
+
+    # Force CLI mode if command line arguments are provided
+    if has_command_line_args():
+        run_cli()
+        return
+
+    # Check if we're in a console environment
+    if is_console_attached():
+        # We're in a console - offer choice or default to CLI
+        print("Python Template Project")
+        print("=" * 50)
+        print("Detected console environment.")
+        print("Options:")
+        print("  1. Run CLI interface (default)")
+        print("  2. Run GUI interface")
+        print("  3. Show help")
+        print()
+
+        try:
+            choice = input("Select option [1]: ").strip()
+            if choice == "2":
+                run_gui()
+            elif choice == "3":
+                show_help()
+            else:
+                run_cli()
+        except (KeyboardInterrupt, EOFError):
+            print("\nExiting...")
+            sys.exit(0)
+    else:
+        # Launched via double-click - start GUI
+        run_gui()
+
+
+def run_cli():
+    """Launch the CLI interface."""
+    try:
+        from python_template_project.cli.cli import main as cli_main
+
+        cli_main()
+    except ImportError as e:
+        print(f"Error importing CLI module: {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error running CLI: {e}")
+        sys.exit(1)
+
+
+def run_gui():
+    """Launch the GUI interface."""
+    try:
+        from python_template_project.gui.gui import main as gui_main
+
+        gui_main()
+    except ImportError as e:
+        print(f"Error importing GUI module: {e}")
+        # If GUI fails, fallback to CLI
+        print("Falling back to CLI interface...")
+        run_cli()
+    except Exception as e:
+        print(f"Error running GUI: {e}")
+        print("Falling back to CLI interface...")
+        run_cli()
+
+
+def show_help():
+    """Show help information."""
+    print("""
+Unified Application
+
+Usage:
+  When launched from console:
+    - Without arguments: Interactive mode selection
+    - With arguments: Direct CLI mode
+
+  When launched via double-click:
+    - Automatically starts GUI interface
+
+Command Line Arguments:
+  Run with any CLI arguments to force CLI mode.
+
+Examples:
+  python main.py --help          # Shows CLI help
+  python main.py                 # Interactive mode selection
+  double-click main.exe          # Starts GUI
+
+""")
+
+
+if __name__ == "__main__":
+    main()

python_template_project/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.18'
+__version_tuple__ = version_tuple = (0, 1, 18)