pyhabitat 1.0.17__py3-none-any.whl → 1.0.19__py3-none-any.whl

pyhabitat/__init__.py

@@ -5,12 +5,14 @@ from .environment import (
     matplotlib_is_available_for_headless_image_export,
     tkinter_is_available,
     in_repl,
-    on_termux,
     on_freebsd,
     on_linux,
     on_android,
     on_windows,
+    on_wsl,
     on_apple,
+    on_termux,
+    on_pydroid,
     on_ish_alpine,
     as_pyinstaller,
     as_frozen,
@@ -24,10 +26,9 @@ from .environment import (
     web_browser_is_available,
     edit_textfile,
     interp_path,
+    main,
 )
 
-from .__main__ import main
-
 # Optional: Set __all__ for explicit documentation and cleaner imports
 __all__ = [
     'matplotlib_is_available_for_gui_plotting',
@@ -35,6 +36,8 @@ __all__ = [
     'tkinter_is_available',
     'in_repl',
     'on_termux',
+    'on_pydroid',
+    'on_wsl',
     'on_freebsd',
     'on_linux',
     'on_android',

pyhabitat/__main__.py

@@ -1,69 +1,4 @@
-from .environment import (
-    in_repl,
-    on_termux,
-    on_windows,
-    on_apple,
-    on_linux,
-    on_ish_alpine,
-    on_android,
-    on_freebsd,
-    is_elf,
-    is_windows_portable_executable,
-    is_macos_executable,
-    is_pyz,
-    is_pipx,
-    is_python_script,
-    as_frozen,
-    as_pyinstaller,
-    interp_path,
-    tkinter_is_available,
-    matplotlib_is_available_for_gui_plotting,
-    matplotlib_is_available_for_headless_image_export,
-    web_browser_is_available,
-    interactive_terminal_is_available
-)
-
-def main():
-    print("PyHabitat Environment Report")
-    print("===========================")
-    print("\nInterpreter Checks // Based on sys.executable()")
-    print("-----------------------------")
-    print(f"interp_path(): {interp_path()}")
-    print(f"is_elf(interp_path()): {is_elf(interp_path())}")
-    print(f"is_windows_portable_executable(interp_path()): {is_windows_portable_executable(interp_path())}")
-    print(f"is_macos_executable(interp_path()): {is_macos_executable(interp_path())}")
-    print(f"is_pyz(interp_path()): {is_pyz(interp_path())}")
-    print(f"is_pipx(interp_path()): {is_pipx(interp_path())}")
-    print(f"is_python_script(interp_path()): {is_python_script(interp_path())}")
-    print("\nCurrent Environment Check // Based on sys.argv[0]")
-    print("-----------------------------")
-    print(f"is_elf(): {is_elf()}")
-    print(f"is_windows_portable_executable(): {is_windows_portable_executable()}")
-    print(f"is_macos_executable(): {is_macos_executable()}")
-    print(f"is_pyz(): {is_pyz()}")
-    print(f"is_pipx(): {is_pipx()}")
-    print(f"is_python_script(): {is_python_script()}")
-    print(f"\nCurrent Build Checks // Based on hasattr(sys,..) and getattr(sys,..)")
-    print("------------------------------")
-    print(f"in_repl(): {in_repl()}")
-    print(f"as_frozen(): {as_frozen()}")
-    print(f"as_pyinstaller(): {as_pyinstaller()}")
-    print("\nOperating System Checks // Based on platform.system()")
-    print("------------------------------")
-    print(f"on_termux(): {on_termux()}")
-    print(f"on_windows(): {on_windows()}")
-    print(f"on_apple(): {on_apple()}")
-    print(f"on_linux(): {on_linux()}")
-    print(f"on_ish_alpine(): {on_ish_alpine()}")
-    print(f"on_android(): {on_android()}")
-    print(f"on_freebsd(): {on_freebsd()}")
-    print("\nCapability Checks")
-    print("-------------------------")
-    print(f"tkinter_is_available(): {tkinter_is_available()}")
-    print(f"matplotlib_is_available_for_gui_plotting(): {matplotlib_is_available_for_gui_plotting()}")
-    print(f"matplotlib_is_available_for_headless_image_export(): {matplotlib_is_available_for_headless_image_export()}")
-    print(f"web_browser_is_available(): {web_browser_is_available()}")
-    print(f"interactive_terminal_is_available(): {interactive_terminal_is_available()}")
+from pyhabitat.cli import run_cli
 
 if __name__ == "__main__":
-    main()
+    run_cli()

pyhabitat/__main__stable.py

@@ -0,0 +1,72 @@
+#from .cli import run_cli
+
+from .environment import (
+    in_repl,
+    on_termux,
+    on_windows,
+    on_apple,
+    on_linux,
+    on_ish_alpine,
+    on_android,
+    on_freebsd,
+    is_elf,
+    is_windows_portable_executable,
+    is_macos_executable,
+    is_pyz,
+    is_pipx,
+    is_python_script,
+    as_frozen,
+    as_pyinstaller,
+    interp_path,
+    tkinter_is_available,
+    matplotlib_is_available_for_gui_plotting,
+    matplotlib_is_available_for_headless_image_export,
+    web_browser_is_available,
+    interactive_terminal_is_available
+)
+
+def main():
+    print("PyHabitat Environment Report")
+    print("===========================")
+    print("\nInterpreter Checks // Based on sys.executable()")
+    print("-----------------------------")
+    print(f"interp_path(): {interp_path()}")
+    print(f"is_elf(interp_path()): {is_elf(interp_path())}")
+    print(f"is_windows_portable_executable(interp_path()): {is_windows_portable_executable(interp_path())}")
+    print(f"is_macos_executable(interp_path()): {is_macos_executable(interp_path())}")
+    print(f"is_pyz(interp_path()): {is_pyz(interp_path())}")
+    print(f"is_pipx(interp_path()): {is_pipx(interp_path())}")
+    print(f"is_python_script(interp_path()): {is_python_script(interp_path())}")
+    print("\nCurrent Environment Check // Based on sys.argv[0]")
+    print("-----------------------------")
+    print(f"is_elf(): {is_elf()}")
+    print(f"is_windows_portable_executable(): {is_windows_portable_executable()}")
+    print(f"is_macos_executable(): {is_macos_executable()}")
+    print(f"is_pyz(): {is_pyz()}")
+    print(f"is_pipx(): {is_pipx()}")
+    print(f"is_python_script(): {is_python_script()}")
+    print(f"\nCurrent Build Checks // Based on hasattr(sys,..) and getattr(sys,..)")
+    print("------------------------------")
+    print(f"in_repl(): {in_repl()}")
+    print(f"as_frozen(): {as_frozen()}")
+    print(f"as_pyinstaller(): {as_pyinstaller()}")
+    print("\nOperating System Checks // Based on platform.system()")
+    print("------------------------------")
+    print(f"on_termux(): {on_termux()}")
+    print(f"on_windows(): {on_windows()}")
+    print(f"on_apple(): {on_apple()}")
+    print(f"on_linux(): {on_linux()}")
+    print(f"on_ish_alpine(): {on_ish_alpine()}")
+    print(f"on_android(): {on_android()}")
+    print(f"on_freebsd(): {on_freebsd()}")
+    print("\nCapability Checks")
+    print("-------------------------")
+    print(f"tkinter_is_available(): {tkinter_is_available()}")
+    print(f"matplotlib_is_available_for_gui_plotting(): {matplotlib_is_available_for_gui_plotting()}")
+    print(f"matplotlib_is_available_for_headless_image_export(): {matplotlib_is_available_for_headless_image_export()}")
+    print(f"web_browser_is_available(): {web_browser_is_available()}")
+    print(f"interactive_terminal_is_available(): {interactive_terminal_is_available()}")
+
+if __name__ == "__main__":
+    main()
+    #run_cli()

pyhabitat/cli.py

@@ -0,0 +1,22 @@
+import argparse
+from pathlib import Path
+from pyhabitat.environment import main
+
+def run_cli():
+    """Parse CLI arguments and run the pyhabitat environment report."""
+    parser = argparse.ArgumentParser(
+        description="PyHabitat: Python environment and build introspection"
+    )
+    parser.add_argument(
+        "--path",
+        type=str,
+        default=None,
+        help="Path to a script or binary to inspect (defaults to sys.argv[0])",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable verbose debug output",
+    )
+    args = parser.parse_args()
+    main(path=Path(args.path) if args.path else None, debug=args.debug)

pyhabitat/environment.py

@@ -13,6 +13,7 @@ from pathlib import Path
 import subprocess
 import io
 import zipfile
+import logging
 
 __all__ = [
     'matplotlib_is_available_for_gui_plotting',
@@ -21,8 +22,10 @@ __all__ = [
     'on_termux',
     'on_freebsd',
     'on_linux',
+    'on_pydroid',
     'on_android',
     'on_windows',
+    'on_wsl',
     'on_apple',
     'on_ish_alpine',
     'as_pyinstaller',
@@ -37,6 +40,7 @@ __all__ = [
     'edit_textfile',
     'in_repl',
     'interp_path',
+    'main',
 ]
 
 # Global cache for tkinter and matplotlib (mpl) availability
@@ -44,6 +48,7 @@ _TKINTER_AVAILABILITY: bool | None = None
 _MATPLOTLIB_EXPORT_AVAILABILITY: bool | None = None
 _MATPLOTLIB_WINDOWED_AVAILABILITY: bool | None = None
 
+
 # --- GUI CHECKS ---
 def matplotlib_is_available_for_gui_plotting(termux_has_gui=False):
     """Check if Matplotlib is available AND can use a GUI backend for a popup window."""
@@ -206,6 +211,64 @@ def on_android() -> bool:
         return False
     return "android" in platform.platform().lower()
 
+
+def on_wsl():
+    """Return True if running inside Windows Subsystem for Linux (WSL or WSL2)."""
+    # Must look like Linux, not Windows
+    if platform.system() != "Linux":
+        return False
+
+     
+    # --- Check environment variables for WSL2 ---
+    # False negative risk: 
+    # Environment variables may be absent in older WSL1 installs.
+    # False negative likelihood: low.
+    if "WSL_DISTRO_NAME" in os.environ or "WSL_INTEROP" in os.environ:
+        return True
+
+    # --- Check kernel info for 'microsoft' string ---
+    # False negative risk: 
+    # Custom kernels, future Windows versions, or minimal WSL distros may omit 'microsoft' in strings.
+    # False negative likelihood: Very low to moderate.
+
+    try:
+        with open("/proc/version") as f:
+            if "microsoft" in version_info or "wsl" in version_info:
+                return True
+    except FileNotFoundError:
+        pass
+        
+    # Check for WSL-specific mounts (fallback)
+    """
+    /proc/sys/kernel/osrelease
+    Purpose: Contains the kernel release string. In WSL, it usually contains "microsoft" (WSL2) or "microsoft-standard" (WSL1).
+    Very reliable for detecting WSL1 and WSL2 unless someone compiled a custom kernel and removed the microsoft string.
+    
+    False negative risk: 
+    If /proc/version or /proc/sys/kernel/osrelease cannot be read due to permissions, a containerized WSL distro, or some sandboxed environment.
+    # False negative likelihood: Very low.
+    """
+    if Path("/proc/sys/kernel/osrelease").exists():
+        try:
+            with open("/proc/sys/kernel/osrelease") as f:
+                osrelease = f.read().lower()
+                if "microsoft" in osrelease:
+                    return True
+        except Exception:
+            pass
+    return False
+
+def on_pydroid():
+    """Return True if running under Pydroid 3 (Android app)."""
+    if not on_android():
+        return False
+
+    exe = (sys.executable or "").lower()
+    if "pydroid" in exe or "ru.iiec.pydroid3" in exe:
+        return True
+
+    return any("pydroid" in p.lower() for p in sys.path)
+
 def on_windows() -> bool:
     """Detect if running on Windows."""
     return platform.system() == 'Windows'
@@ -274,132 +337,74 @@ def as_frozen():
     return getattr(sys, 'frozen', False)
 
 # --- Binary Characteristic Checks ---
-def is_elf(exec_path: Path | str | None = None, debug: bool = False) -> bool:
+def is_elf(exec_path: Path | str | None = None, debug: bool = False, suppress_debug: bool =False) -> bool:
     """Checks if the currently running executable (sys.argv[0]) is a standalone PyInstaller-built ELF binary."""
     # If it's a pipx installation, it is not the monolithic binary we are concerned with here.
-    
-    if exec_path is None:    
-        exec_path = Path(sys.argv[0]).resolve()
-    else:
-        exec_path = Path(exec_path).resolve()
-
-    if debug:
-        print(f"DEBUG: Checking executable path: {exec_path}")
-        
-    if is_pipx():
+    exec_path, is_valid = _check_executable_path(exec_path, debug and not suppress_debug)
+    if not is_valid:
         return False
     
-    # Check if the file exists and is readable
-    if not exec_path.is_file():
-        if debug: print("DEBUG:False (Not a file)")
-        return False    
     try:
         # Check the magic number: The first four bytes of an ELF file are 0x7f, 'E', 'L', 'F' (b'\x7fELF').
         # This is the most reliable way to determine if the executable is a native binary wrapper (like PyInstaller's).
-        with open(exec_path, 'rb') as f:
-            magic_bytes = f.read(4)
-        
+        magic_bytes = read_magic_bytes(exec_path, 4, debug and not suppress_debug)
+
         return magic_bytes == b'\x7fELF'
     except Exception:
-        # Handle exceptions like PermissionError, IsADirectoryError, etc.
+        if debug:
+            logging.debug("False (Exception during file check)")
         return False
     
-def is_pyz(exec_path: Path | str | None = None, debug: bool = False) -> bool:
+def is_pyz(exec_path: Path | str | None = None, debug: bool = False, suppress_debug: bool =False) -> bool:
     """Checks if the currently running executable (sys.argv[0]) is a PYZ zipapp ."""
-    # If it's a pipx installation, it is not the monolithic binary we are concerned with here.
-    if exec_path is None:    
-        exec_path = Path(sys.argv[0]).resolve()
-    else:
-        exec_path = Path(exec_path).resolve()
 
-    if debug:
-        print(f"DEBUG: Checking executable path: {exec_path}")
-        
-    if not exec_path.is_file():
-        if debug: print("DEBUG:False (Not a file)")
-        return False
-    
-    if is_pipx():
+    # If it's a pipx installation, it is not the monolithic binary we are concerned with here.
+    exec_path, is_valid = _check_executable_path(exec_path, debug and not suppress_debug)
+    if not is_valid:
         return False
     
     # Check if the extension is PYZ
     if not str(exec_path).endswith(".pyz"):
+        if debug:
+            logging.debug("False (Not a .pyz file)")
         return False
-    
+
     if not _check_if_zip(exec_path):
+        if debug:
+            logging.debug("False (Not a valid ZIP file)")
         return False
 
-def is_windows_portable_executable(exec_path: Path | str | None = None, debug: bool = False) -> bool:
+    return True
+
+
+def is_windows_portable_executable(exec_path: Path | str | None = None, debug: bool = False, suppress_debug: bool =False) -> bool:
     """
-    Checks if the currently running executable (sys.argv[0]) is a 
-    Windows Portable Executable (PE) binary, and explicitly excludes 
-    pipx-managed environments.
+    Checks if the specified path or sys.argv[0] is a Windows Portable Executable (PE) binary.
     Windows Portable Executables include .exe, .dll, and other binaries.
     The standard way to check for a PE is to look for the MZ magic number at the very beginning of the file.
     """
-    # 1. Determine execution path
-    if exec_path is None:
-        exec_path = Path(sys.argv[0]).resolve()
-    else:
-        exec_path = Path(exec_path).resolve()
-
-    if debug:
-        print(f"DEBUG: Checking executable path: {exec_path}")
-
-    # 2. Exclude pipx environments immediately
-    if is_pipx():
-        if debug: print("DEBUG: False (is_pipx is True)")
+    exec_path, is_valid = _check_executable_path(exec_path, debug and not suppress_debug)
+    if not is_valid:
         return False
+    magic_bytes = read_magic_bytes(exec_path, 2, debug and not suppress_debug)
+    result = magic_bytes.startswith(b"MZ")
 
-    # 3. Perform file checks
-    if not exec_path.is_file():
-        if debug: print("DEBUG:False (Not a file)")
-        return False
-
-    try:
-        # Check the magic number: All Windows PE files (EXE, DLL, etc.) 
-        # start with the two-byte header b'MZ' (for Mark Zbikowski).
-        with open(exec_path, 'rb') as f:
-            magic_bytes = f.read(2)
-
-        is_pe = magic_bytes == b'MZ'
-        
-        if debug: 
-            print(f"DEBUG: Magic bytes: {magic_bytes}")
-            print(f"DEBUG: {is_pe} (Non-pipx check)")
-            
-        return is_pe
-        
-    except Exception as e:
-        if debug: print(f"DEBUG: Error during file check: {e}")
-        # Handle exceptions like PermissionError, IsADirectoryError, etc.
-        return False
+    return result
     
-def is_macos_executable(exec_path: Path | str | None = None, debug: bool = False) -> bool:
+def is_macos_executable(exec_path: Path | str | None = None, debug: bool = False, suppress_debug: bool =False) -> bool:
     """
     Checks if the currently running executable is a macOS/Darwin Mach-O binary, 
     and explicitly excludes pipx-managed environments.
     """
-    if exec_path is None:
-        exec_path = Path(sys.argv[0]).resolve()
-    else:
-        exec_path = Path(exec_path).resolve()
-    if debug:
-        print(f"DEBUG: Checking executable path: {exec_path}")
-        
-    if is_pipx():
-        if debug: print("DEBUG: is_macos_executable: False (is_pipx is True)")
-        return False
-        
-    if not exec_path.is_file():
-        if debug: print("DEBUG:False (Not a file)")
+    exec_path, is_valid = _check_executable_path(exec_path, debug and not suppress_debug)
+    if not is_valid:
         return False
         
     try:
         # Check the magic number: Mach-O binaries start with specific 4-byte headers.
         # Common ones are: b'\xfe\xed\xfa\xce' (32-bit) or b'\xfe\xed\xfa\xcf' (64-bit)
-        with open(exec_path, 'rb') as f:
-            magic_bytes = f.read(4)
+        
+        magic_bytes = read_magic_bytes(exec_path, 4, debug and not suppress_debug)
 
         # Common Mach-O magic numbers (including their reversed-byte counterparts)
         MACHO_MAGIC = {
@@ -411,75 +416,88 @@ def is_macos_executable(exec_path: Path | str | None = None, debug: bool = False
         
         is_macho = magic_bytes in MACHO_MAGIC
         
-        if debug: 
-            print(f"DEBUG: is_macos_executable: {is_macho} (Non-pipx check)")
             
         return is_macho
         
     except Exception:
+        if debug:
+            logging.debug("False (Exception during file check)")
         return False
     
-def is_pipx(exec_path: Path | str | None = None, debug: bool = False) -> bool:
+def is_pipx(exec_path: Path | str | None = None, debug: bool = False, suppress_debug: bool = True) -> bool:
     """Checks if the executable is running from a pipx managed environment."""
-    if exec_path is None:
-        exec_path = Path(sys.argv[0]).resolve()
-    else:
-        exec_path = Path(exec_path).resolve()
-    if debug:
-        print(f"DEBUG: Checking executable path: {exec_path}")
-        
-    if not exec_path.is_file():
-        if debug: print("DEBUG:False (Not a file)")
+    exec_path, is_valid = _check_executable_path(exec_path, debug and not suppress_debug, check_pipx=False)
+    if not is_valid:
         return False
+        
     try:
-        # Helper for case-insensitivity on Windows
-        def normalize_path(p: Path) -> str:
-            return str(p).lower()
-
-        # This is the path to the interpreter running the script (e.g., venv/bin/python)
-        # In a pipx-managed execution, this is the venv python.
         interpreter_path = Path(sys.executable).resolve()
         pipx_bin_path, pipx_venv_base_path = _get_pipx_paths()
         # Normalize paths for comparison
-        norm_exec_path = normalize_path(exec_path)
-        norm_interp_path = normalize_path(interpreter_path)
+        norm_exec_path = str(exec_path).lower()
+        norm_interp_path = str(interpreter_path).lower()
 
         if debug:
-            # --- DEBUGGING OUTPUT ---
-            print(f"DEBUG: EXEC_PATH:      {exec_path}")
-            print(f"DEBUG: INTERP_PATH:    {interpreter_path}")
-            print(f"DEBUG: PIPX_BIN_PATH:  {pipx_bin_path}")
-            print(f"DEBUG: PIPX_VENV_BASE: {pipx_venv_base_path}")
-            print(f"DEBUG: Check B result: {normalize_path(interpreter_path).startswith(normalize_path(pipx_venv_base_path))}")
-        # ------------------------
-        
-        # 1. Signature Check (Most Robust): Look for the unique 'pipx/venvs' string.
-        # This is a strong check for both the executable path (your discovery) 
-        # and the interpreter path (canonical venv location).
+            logging.debug(f"EXEC_PATH: {exec_path}")
+            logging.debug(f"INTERP_PATH: {interpreter_path}")
+            logging.debug(f"PIPX_BIN_PATH: {pipx_bin_path}")
+            logging.debug(f"PIPX_VENV_BASE: {pipx_venv_base_path}")
+            is_in_pipx_venv_base = norm_interp_path.startswith(str(pipx_venv_base_path).lower())
+            logging.debug(f"Interpreter path resides somewhere within the pipx venv base hierarchy: {is_in_pipx_venv_base}")
+            logging.debug(
+                f"This determines whether the current interpreter is managed by pipx: {is_in_pipx_venv_base}"
+            )
         if "pipx/venvs" in norm_exec_path or "pipx/venvs" in norm_interp_path:
-            if debug: print("is_pipx: True (Signature Check)")
+            if debug:
+                logging.debug("True (Signature Check)")
             return True
 
-        # 2. Targeted Venv Check: The interpreter's path starts with the PIPX venv base.
-        # This is a canonical check if the signature check is somehow missed.
-        if norm_interp_path.startswith(normalize_path(pipx_venv_base_path)):
-            if debug: print("is_pipx: True (Interpreter Base Check)")
+        if norm_interp_path.startswith(str(pipx_venv_base_path).lower()):
+            if debug:
+                logging.debug("True (Interpreter Base Check)")
             return True
-        
-        # 3. Targeted Executable Check: The executable's resolved path starts with the PIPX venv base.
-        # This is your key Termux discovery, confirming the shim resolves into the venv.
-        if norm_exec_path.startswith(normalize_path(pipx_venv_base_path)):
-             if debug: print("is_pipx: True (Executable Base Check)")
-             return True
 
-        if debug: print("is_pipx: False")
-        return False
+        if norm_exec_path.startswith(str(pipx_venv_base_path).lower()):
+            if debug:
+                logging.debug("True (Executable Base Check)")
+            return True
 
+        return False
     except Exception:
-        # Fallback for unexpected path errors
+        if debug:
+            logging.debug("False (Exception during pipx check)")
         return False
+        if debug:
+            logging.debug(f"EXEC_PATH: {exec_path}")
+            logging.debug(f"INTERP_PATH: {interpreter_path}")
+            logging.debug(f"PIPX_BIN_PATH: {pipx_bin_path}")
+            logging.debug(f"PIPX_VENV_BASE: {pipx_venv_base_path}")
+            logging.debug(f"Check B result: {norm_interp_path.startswith(str(pipx_venv_base_path).lower())}")
 
-def is_python_script(path: Path | str | None = None, debug: bool = False) -> bool:
+        if "pipx/venvs" in norm_exec_path or "pipx/venvs" in norm_interp_path:
+            if debug:
+                logging.debug("True (Signature Check)")
+            return True
+
+        if norm_interp_path.startswith(str(pipx_venv_base_path).lower()):
+            if debug:
+                logging.debug("True (Interpreter Base Check)")
+            return True
+
+        if norm_exec_path.startswith(str(pipx_venv_base_path).lower()):
+            if debug:
+                logging.debug("True (Executable Base Check)")
+            return True
+
+        if debug:
+            logging.debug("False")
+        return False
+    except Exception:
+        if debug:
+            logging.debug("False (Exception during pipx check)")
+        return False
+    
+def is_python_script(path: Path | str | None = None, debug: bool = False, suppress_debug: bool =False) -> bool:
     """
     Checks if the specified path or running script is a Python source file (.py).
 
@@ -493,19 +511,14 @@ def is_python_script(path: Path | str | None = None, debug: bool = False) -> boo
     Returns:
         bool: True if the specified or default path is a Python source file (.py); False otherwise.
     """
-    if path is None:
-        exec_path = Path(sys.argv[0]).resolve()
-    else:
-        exec_path = Path(path).resolve()
-    if debug:
-        print(f"Checking Python script for path: {exec_path}")
-    if not exec_path.is_file():
+    exec_path, is_valid = _check_executable_path(path, debug and not suppress_debug, check_pipx=False)
+    if not is_valid:
         return False
     return exec_path.suffix.lower() == '.py'    
 
 # --- Interpreter Check ---
 
-def interp_path(print_path: bool = False) -> str:
+def interp_path(debug: bool = False) -> str:
     """
     Returns the path to the Python interpreter binary and optionally prints it.
 
@@ -521,8 +534,8 @@ def interp_path(print_path: bool = False) -> str:
         str: The path to the Python interpreter binary, or an empty string if unavailable.
     """
     path = sys.executable
-    if print_path:
-        print(f"Python interpreter path: {path}")
+    if debug:
+        logging.debug(f"Python interpreter path: {path}")
     return path
 
 # --- TTY Check ---
@@ -601,7 +614,8 @@ def edit_textfile(path: Path | str | None = None) -> None:
     """Why Not Use check=True on Termux:
     The pkg utility in Termux is a wrapper around Debian's apt. When you run pkg install <package>, if the package is already installed, the utility often returns an exit code of 100 (or another non-zero value) to indicate that no changes were made because the package was already present.
     """
-    
+
+# --- Helper Functions ---    
 def _run_dos2unix(path: Path | str | None = None):
     """Attempt to run dos2unix, failing silently if not installed."""
     
@@ -618,7 +632,20 @@ def _run_dos2unix(path: Path | str | None = None):
     except Exception:
         # Catch other subprocess errors (e.g. permission issues)
         pass
-        
+    
+def read_magic_bytes(path: str, length: int = 4, debug: bool = False) -> bytes:
+    """Return the first few bytes of a file for type detection."""
+    try:
+        with open(path, "rb") as f:
+            magic = f.read(length)
+        if debug:
+            logging.debug(f"Magic bytes: {magic!r}")
+        return magic
+    except Exception as e:
+        if debug:
+            logging.debug(f"False (Error during file check: {e})")
+        return False
+    
 def _get_pipx_paths():
     """
     Returns the configured/default pipx binary and home directories.
@@ -657,4 +684,138 @@ def _check_if_zip(path: Path | str | None) -> bool:
     except Exception:
         # Handle cases where the path might be invalid, or other unexpected errors
         return False
-        
+
+def _check_executable_path(exec_path: Path | str | None, debug: bool = False, check_pipx: bool = True) -> tuple[Path | None, bool]:
+    """Helper function to resolve executable path and perform common checks."""
+    if exec_path is None:
+        exec_path = Path(sys.argv[0]).resolve() if sys.argv[0] and sys.argv[0] != '-c' else None
+    else:
+        exec_path = Path(exec_path).resolve()
+
+    if debug:
+        logging.debug(f"Checking executable path: {exec_path}")
+
+    if exec_path is None:
+        if debug:
+            logging.debug("False (No valid path)")
+        return None, False
+
+    if check_pipx and is_pipx(exec_path, debug):
+        if debug:
+            logging.debug("False (is_pipx is True)")
+        return exec_path, False
+
+    if not exec_path.is_file():
+        if debug:
+            logging.debug("False (Not a file)")
+        return exec_path, False
+
+    return exec_path, True        
+
+# --- Main Function for report and CLI compatibility ---
+
+def main(path=None, debug=False):
+    """Print a comprehensive environment report.
+
+    Args:
+        path (Path | str | None): Path to inspect (defaults to sys.argv[0]).
+        debug (bool): Enable verbose debug output.
+    """
+    if debug:
+        logging.basicConfig(level=logging.DEBUG)
+        logging.getLogger('matplotlib').setLevel(logging.WARNING)  # Suppress matplotlib debug logs
+    print("================================")
+    print("======= PyHabitat Report =======")
+    print("================================")
+    print("\nCurrent Build Checks ")
+    print("# // Based on hasattr(sys,..) and getattr(sys,..)")
+    print("------------------------------")
+    print(f"in_repl(): {in_repl()}")
+    print(f"as_frozen(): {as_frozen()}")
+    print(f"as_pyinstaller(): {as_pyinstaller()}")
+    print("\nOperating System Checks")
+    print("# // Based on platform.system()")
+    print("------------------------------")
+    print(f"on_windows(): {on_windows()}")
+    print(f"on_apple(): {on_apple()}")
+    print(f"on_linux(): {on_linux()}")
+    print(f"on_wsl(): {on_wsl()}")
+    print(f"on_android(): {on_android()}")
+    print(f"on_termux(): {on_termux()}")
+    print(f"on_pydroid(): {on_pydroid()}")
+    print(f"on_ish_alpine(): {on_ish_alpine()}")
+    print(f"on_freebsd(): {on_freebsd()}")
+    print("\nCapability Checks")
+    print("-------------------------")
+    print(f"tkinter_is_available(): {tkinter_is_available()}")
+    print(f"matplotlib_is_available_for_gui_plotting(): {matplotlib_is_available_for_gui_plotting()}")
+    print(f"matplotlib_is_available_for_headless_image_export(): {matplotlib_is_available_for_headless_image_export()}")
+    print(f"web_browser_is_available(): {web_browser_is_available()}")
+    print(f"interactive_terminal_is_available(): {interactive_terminal_is_available()}")
+    print("\nInterpreter Checks")
+    print("# // Based on sys.executable()")
+    print("-----------------------------")
+    print(f"interp_path(): {interp_path()}")
+    if debug:
+        # Do these debug prints once to avoid redundant prints
+        # Supress redundant prints explicity using suppress_debug=True, 
+        # so that only unique information gets printed for each check, 
+        # even when more than one use the same functions which include debugging logs.
+        #print(f"_check_executable_path(interp_path(), debug=True)")
+        _check_executable_path(interp_path(), debug=debug)    
+        #print(f"read_magic_bites(interp_path(), debug=True)")
+        read_magic_bytes(interp_path(), debug=debug)
+    print(f"is_elf(interp_path()): {is_elf(interp_path(), debug=debug, suppress_debug=True)}")
+    print(f"is_windows_portable_executable(interp_path()): {is_windows_portable_executable(interp_path(), debug=debug, suppress_debug=True)}")
+    print(f"is_macos_executable(interp_path()): {is_macos_executable(interp_path(), debug=debug, suppress_debug=True)}")
+    print(f"is_pyz(interp_path()): {is_pyz(interp_path(), debug=debug, suppress_debug=True)}")
+    print(f"is_pipx(interp_path()): {is_pipx(interp_path(), debug=debug, suppress_debug=True)}")
+    print(f"is_python_script(interp_path()): {is_python_script(interp_path(), debug=debug, suppress_debug=True)}")
+    print("\nCurrent Environment Check")
+    print("# // Based on sys.argv[0]")
+    print("-----------------------------")
+    inspect_path = path if path is not None else (None if sys.argv[0] == '-c' else sys.argv[0])
+    logging.debug(f"Inspecting path: {inspect_path}")
+    # Early validation of path
+    if path is not None:
+        path_obj = Path(path)
+        if not path_obj.is_file():
+            print(f"Error: '{path}' is not a valid file or does not exist.")
+            if debug:
+                logging.error(f"Invalid path: '{path}' is not a file or does not exist.")
+            raise SystemExit(1)
+    script_path = None
+    if path or (sys.argv[0] and sys.argv[0] != '-c'):
+        script_path = Path(path or sys.argv[0]).resolve()
+    print(f"sys.argv[0] = {str(sys.argv[0])}")
+    if script_path is not None:
+        print(f"script_path = {script_path}")
+        if debug:
+            # Do these debug prints once to avoid redundant prints
+            # Supress redundant prints explicity using suppress_debug=True, 
+            # so that only unique information gets printed for each check, 
+            # even when more than one use the same functions which include debugging logs.
+            p#rint(f"_check_executable_path(script_path, debug=True)")
+            _check_executable_path(script_path, debug=debug)
+            #print(f"read_magic_bites(script_path, debug=True)")
+            read_magic_bytes(script_path, debug=debug)
+        print(f"is_elf(): {is_elf(script_path, debug=debug, suppress_debug=True)}")
+        print(f"is_windows_portable_executable(): {is_windows_portable_executable(script_path, debug=debug, suppress_debug=True)}")
+        print(f"is_macos_executable(): {is_macos_executable(script_path, debug=debug, suppress_debug=True)}")
+        print(f"is_pyz(): {is_pyz(script_path, debug=debug, suppress_debug=True)}")
+        print(f"is_pipx(): {is_pipx(script_path, debug=debug, suppress_debug=True)}")
+        print(f"is_python_script(): {is_python_script(script_path, debug=debug, suppress_debug=True)}")
+    else:
+        print("Skipping: ") 
+        print("    is_elf(), ")
+        print("    is_windows_portable_executable(), ")
+        print("    is_macos_executable(), ")
+        print("    is_pyz(), ")
+        print("    is_pipx(), ") 
+        print("    is_python_script(), ")
+        print("All False, script_path is None.")
+    print("")
+    print("=================================")
+    print("=== PyHabitat Report Complete ===")
+    print("=================================")
+    print("")

{pyhabitat-1.0.17.dist-info → pyhabitat-1.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyhabitat
-Version: 1.0.17
+Version: 1.0.19
 Summary: A lightweight library for detecting system environment, GUI, and build properties.
 Author-email: George Clayton Bennett <george.bennett@memphistn.gov>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Keywords: environment,os-detection,gui,build-system
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: System :: Systems Administration
-Requires-Python: >=3.8
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
@@ -78,10 +78,12 @@ Key question: "What is this running on?"
 | `on_windows()` | Returns `True` on Windows. |
 | `on_apple()` | Returns `True` on macOS (Darwin). |
 | `on_linux()` | Returns `True` on Linux in general. |
+| `on_wsl()` | Returns `True` if running inside Windows Subsystem for Linux (WSL or WSL2). |
 | `on_termux()` | Returns `True` if running in the Termux Android environment. |
 | `on_freebsd()` | Returns `True` on FreeBSD. |
 | `on_ish_alpine()` | Returns `True` if running in the iSH Alpine Linux iOS emulator. |
 | `on_android()` | Returns `True` on any Android-based Linux environment. |
+| `on_pydroid()` | Returns `True` Return True if running under the Pydroid 3 Android app (other versions untested). |
 | `in_repl()` | Returns `True` is the user is currently in a Python REPL; hasattr(sys,'ps1'). |
 
 ### Packaging and Build Checking
@@ -118,7 +120,7 @@ Key Question: "What could I do next?"
 | Function | Description |
 | :--- | :--- |
 | `edit_textfile(path)` | Opens a text file for editing using the default editor (Windows, Linux, macOS) or nano in Termux/iSH. In REPL mode, prints an error. Path argument (str or Path) uses Path.resolve() for stability. |
-| `interp_path(print_path=False)` | Returns the path to the Python interpreter binary (sys.executable). Optionally prints the path. Returns empty string if unavailable. |
+| `interp_path()` | Returns the path to the Python interpreter binary (sys.executable). Returns empty string if unavailable. |
 | `main()` | Prints a comprehensive environment report with sections: Interpreter Checks (sys.executable), Current Environment Check (sys.argv[0]), Current Build Checks (sys attributes), Operating System Checks (platform.system()), and Capability Checks. Run via `python -m pyhabitat` or `import pyhabitat; pyhabitat.main()` in the REPL. |
 
 </details>
@@ -130,7 +132,7 @@ Key Question: "What could I do next?"
 
 The module exposes all detection functions directly for easy access.
 
-### 0\.Example of PyHabitat in Action
+### 0\. Example of PyHabitat in Action
 
 The `pipeline-eds` package uses the `pyhabitat` library to handle [configuration](https://github.com/City-of-Memphis-Wastewater/pipeline/blob/main/src/pipeline/security_and_config.py) and [plotting](https://github.com/City-of-Memphis-Wastewater/pipeline/blob/main/src/pipeline/cli.py), among other things.
 

pyhabitat-1.0.19.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyhabitat/__init__.py,sha256=B_yS2yBG2kjHkte_xissSG8aJ15af-soBo3Cy7caiEc,1288
+pyhabitat/__main__.py,sha256=qlOKShd_Xk0HGpYOySXQSQe3K60a9wwrstCAceJkKIs,76
+pyhabitat/__main__stable.py,sha256=UACpHLrr_Rmf0L5dJCEae6kFzLn7dqCqIri68IBnb10,2910
+pyhabitat/cli.py,sha256=ZlY6v_IT7Mw-ekR3WPT8NLsqMQ_RXI-cckVq9oLT4AU,683
+pyhabitat/environment.py,sha256=2wyjdWNRSv8VxaXkjoQz285ATAlhddrY_dor45mMnQ4,32871
+pyhabitat-1.0.19.dist-info/licenses/LICENSE,sha256=D4fg30ctUGnCJlWu3ONv5-V8JE1v3ctakoJTcVjsJlg,1072
+pyhabitat-1.0.19.dist-info/METADATA,sha256=N8o0nM2KOq7X4B-JNUMcePtqjinqsdqrqZ11Ct8qsRY,10900
+pyhabitat-1.0.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyhabitat-1.0.19.dist-info/entry_points.txt,sha256=409xZ-BrarQJJLtO-aActCGkL0FMhNVi9wsq3u7tRHM,52
+pyhabitat-1.0.19.dist-info/top_level.txt,sha256=zXYK44Qu8EqxUETREvd2diMUaB5JiGRErkwFaoLQnnI,10
+pyhabitat-1.0.19.dist-info/RECORD,,

pyhabitat-1.0.19.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyhabitat = pyhabitat.cli:run_cli

pyhabitat-1.0.17.dist-info/RECORD

@@ -1,8 +0,0 @@
-pyhabitat/__init__.py,sha256=-WMvkW27x91heqsUfCCKHJntusBG2AIXCr6J29Pw9W8,1246
-pyhabitat/__main__.py,sha256=GT_PXbj6X2nlZIbRiFBKXDiv158_YrsoLhf7FsLFV-Q,2868
-pyhabitat/environment.py,sha256=d9nUoWeu86oWNGYBNACOWti71mGiTCADpBLIAW87sxw,24806
-pyhabitat-1.0.17.dist-info/licenses/LICENSE,sha256=D4fg30ctUGnCJlWu3ONv5-V8JE1v3ctakoJTcVjsJlg,1072
-pyhabitat-1.0.17.dist-info/METADATA,sha256=-uJXF7he0eiYXH63gvd9jXyHXef-V9vL7Yq0E2bZda0,10732
-pyhabitat-1.0.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyhabitat-1.0.17.dist-info/top_level.txt,sha256=zXYK44Qu8EqxUETREvd2diMUaB5JiGRErkwFaoLQnnI,10
-pyhabitat-1.0.17.dist-info/RECORD,,