dkinst 0.1.0__py3-none-any.whl

dkinst/__init__.py

@@ -0,0 +1,4 @@
+"""Den K Simple Installer"""
+
+__author__ = "Den Kras"
+__version__ = '0.1.0'

dkinst/cli.py

@@ -0,0 +1,246 @@
+"""Command-line driver for dkinst."""
+import sys
+import pkgutil
+from importlib import import_module
+import argparse
+from pathlib import Path
+import subprocess
+
+from rich.console import Console
+from rich.table import Table
+
+from installers._base import BaseInstaller
+from installers import _base
+import installers
+
+console = Console()
+
+
+VERSION: str = "0.1.0"
+
+
+def _get_installers() -> list[BaseInstaller]:
+    """get list of tuples (name, instance) for every subclass found in dkinst.installers.*"""
+    # import every *.py file so its classes are defined
+    for _, stem_name, _ in pkgutil.iter_modules(installers.__path__):
+        module_string: str = f"{installers.__name__}.{stem_name}"
+        import_module(module_string)
+
+    # collect subclasses
+    installers_list: list[BaseInstaller] = []
+    for subclass in BaseInstaller.__subclasses__():
+        if subclass is not BaseInstaller:
+            installer = subclass()
+            installers_list.append(installer)
+
+    return installers_list
+
+
+def cmd_available() -> None:
+    """List every known installer with metadata."""
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Name", style="bold")
+    table.add_column("Platforms")
+    table.add_column("Methods")
+    table.add_column("Manual Arguments")
+
+    # collect all installers
+    installers_list: list[BaseInstaller] = _get_installers()
+
+    methods: list[str]
+    for installer in installers_list:
+        methods = _base.get_known_methods(installer)
+
+        manual_args = _base._extract_helper_args(installer, methods)
+        table.add_row(
+            installer.name,
+            ", ".join(installer.platforms) or "—",
+            ", ".join(methods) or "—",
+            ", ".join(manual_args) or "—",
+        )
+
+    console.print(table)
+
+
+def _make_parser() -> argparse.ArgumentParser:
+    description: str = (
+        "Den K Simple Installer\n"
+        f"{VERSION}\n"
+        "\n"
+        "Arguments:\n"
+        "  install <installer>          Install the script with the given name.\n"
+        "  update  <installer>          Update the script with the given name.\n"
+        "  uninstall <installer>        Uninstall the script with the given name.\n"
+        "  manual <installer>           If manual method is available for specific installer, "
+        "                               you can use it to execute the helper script with its parameters.\n"
+        "\n"
+        "  manual <installer> <args>    Execute the helper script with its parameters.\n"
+        "  manual <installer> help      Show help for manual arguments of the helper script.\n"
+        "  available                    List all available installers.\n"
+        "  edit-config                  Open the configuration file in the default editor.\n"
+        "                               You can change the base installation path here.\n"
+        "  help                         Show this help message.\n"
+        "\n"
+        "You can use help for any sub-command to see its specific usage.\n"
+        "Examples:\n"
+        "  dkinst help\n"
+        "  dkinst install help\n"
+        "  dkinst update help\n"
+        "  dkinst uninstall help\n"
+        "\n"
+        "==============================\n"
+        "\n"
+    )
+
+    parser = argparse.ArgumentParser(
+        prog="dkinst",
+        description=description,
+        formatter_class=argparse.RawTextHelpFormatter,
+        usage=argparse.SUPPRESS,
+        add_help=False
+    )
+    sub = parser.add_subparsers(dest="sub", required=False)
+
+    for subcmd in _base.ALL_METHODS:
+        # Make <script> optional so `dkinst install help` works
+        sc = sub.add_parser(subcmd, add_help=False)
+        sc.add_argument(
+            "script",
+            nargs="?",  # optional to allow `install help`
+            help="installer script name or 'help'",
+        )
+        # Everything after <script> is handed untouched to the installer
+        sc.add_argument("installer_args", nargs=argparse.REMAINDER)
+
+    sub.add_parser("available")
+    sub.add_parser("edit-config")
+    sub.add_parser("help")
+    return parser
+
+
+def main() -> int:
+    """
+    Entrypoint for the `dkinst` CLI.
+
+    Supported commands
+    ------------------
+    dkinst help
+    dkinst available
+    dkinst install <script>    [extra args passed through]
+    dkinst update  <script>    [extra args passed through]
+    dkinst uninstall <script>  [extra args passed through]
+    """
+    parser = _make_parser()          # builds the ArgumentParser shown earlier
+
+    # If no arguments, show the top-level help and exit successfully
+    passed_arguments = sys.argv[1:]
+    if not passed_arguments:
+        parser.print_help()
+        return 0
+
+    namespace = parser.parse_args()         # plain parsing now
+
+    if namespace.sub == "help":
+        parser.print_help()
+        return 0
+
+    if namespace.sub == "available":
+        cmd_available()
+        return 0
+
+    if namespace.sub == "edit-config":
+        config_path: str = str(Path(__file__).parent / "config.toml")
+        subprocess.run(["notepad", config_path])
+        return 0
+
+    # Methods from the Known Methods list
+    if namespace.sub in _base.ALL_METHODS:
+        method = namespace.sub
+
+        # No script provided OR explicitly asked for help
+        if namespace.script is None or namespace.script == "help":
+            # `manual help` should show the fixed, centralized manual help
+            if method == "manual":
+                BaseInstaller._show_manual_help()
+                return 0
+            BaseInstaller._show_help(method)
+            return 0
+
+        # From here on, a specific installer was provided
+        installer_name = namespace.script
+        extras = namespace.installer_args or []
+
+        for inst in _get_installers():
+            # Find the provided installer.
+            if inst.name != installer_name:
+                continue
+
+            inst._platforms_known()
+
+            # Now check if the current platform is supported by this installer.
+            current_platform = sys.platform
+            if current_platform in _base.PLATFORM_CONVERTION:
+                installers_kommon_platform = _base.PLATFORM_CONVERTION[current_platform]
+                if installers_kommon_platform not in inst.platforms:
+                    console.print(f"This installer [{inst.name}] does not support your platform [{current_platform}].", style='red', markup=False)
+                    return 1
+            else:
+                console.print(f"This platform is unknown: [{current_platform}]", style='red', markup=False)
+                return 1
+
+            # Processing the 'manual' method.
+            if method == 'manual':
+                installer_methods = _base.get_known_methods(inst)
+                if 'manual' not in installer_methods:
+                    console.print(f"No 'manual' method available for the installer: [{inst.name}]", style='red', markup=False)
+                    return 1
+
+                # Use the helper parser for this installer, if available
+                helper_parser = _base._get_helper_parser(inst, installer_methods)
+                if helper_parser is None:
+                    console.print(f"No manual argparser available for [{inst.name}].", style='red', markup=False)
+                    return 1
+
+                if (
+                        # Installer-specific help: [dkinst <method> <installer> help]
+                        len(extras) == 1 and extras[0] == "help"
+                ) or (
+                        # Manual installer execution without arguments: dkinst manual <installer>
+                        # show helper parser help if available.
+                        len(extras) == 0
+                ):
+                    helper_parser.print_help()
+
+                # Regular arguments execution of the manual method.
+                # Parse just the extras, not the whole argv
+                try:
+                    parsed = helper_parser.parse_args(extras)
+                except SystemExit:
+                    # argparse already printed usage/error; treat as handled
+                    return 2
+                # If your installers accept kwargs:
+                target_helper = inst.helper
+                return target_helper.main(**vars(parsed))
+
+            # For all the other methods that aren't manual.
+            if len(extras) == 1 and extras[0] == "help":
+                inst._show_help(method)
+                return 0
+
+            # Normal execution: call method and pass through extras (if any)
+            target = getattr(inst, method)
+
+            if extras:
+                return target(*extras)
+            else:
+                return target()
+
+        console.print(f"No installer found with the name: [{installer_name}]", style='red', markup=False)
+        return 0
+
+    # should never get here: argparse enforces valid sub-commands
+    parser.error(f"Unknown command {namespace.sub!r}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dkinst/installers/_base.py

@@ -0,0 +1,257 @@
+import inspect
+import argparse
+import tomllib
+from pathlib import Path
+from types import ModuleType
+from typing import Literal
+
+
+INSTALLATION_PATH_PORTABLE_WINDOWS: str = "C:\\dkinst"      # Installation path for portable files on Windows that don't have a default location.
+
+KNOWN_SUPPORTED_PLATFORMS: list[str] = ["windows", "debian"]
+PLATFORM_CONVERTION: dict[str, str] = {    # Convert sys.platform to installer platform names.
+    "linux": "linux",
+    "linux2": "linux",
+    "darwin": "macos",
+    "win32": "windows",
+    "cygwin": "windows",
+    "msys": "windows",
+    "freebsd": "freebsd",
+    "openbsd": "freebsd",
+    "netbsd": "freebsd",
+    "aix": "aix",
+    "sunos5": "solaris",
+}
+
+KNOWN_METHODS: list[str] | None = None
+CUSTOM_METHODS: list[str] = ["manual"]
+ALL_METHODS: list[str] | None = None
+
+
+class BaseInstaller:
+    def __init__(self):
+        # The name of the installation script that will be used by the main script to install.
+        self.name: str = "baseinstall"
+        # The description of the installation script.
+        self.description: str = "Base Installer"
+        # The version of the installation script.
+        self.version: str = "1.0.0"
+        # The platforms supported by this installer.
+        self.platforms: list[str] = []
+        # The helper module that provides additional functionality for this installer.
+        # Providing the helper module will automatically introduce the 'manual()' method on the 'cli.py' level.
+        self.helper: ModuleType | None = None
+
+        self.base_path: str = INSTALLATION_PATH_PORTABLE_WINDOWS
+        self.dir_path: str | None = None  # Path to the installation directory of the installed application, if applicable. Example: Path(self.base_path) / self.name
+        self.exe_path: str | None = None  # Path to the main executable of the installed application, if applicable. Example: Path(self.dir_path) / "app.exe"
+
+    def install(self):
+        raise NotImplementedError("Subclasses should implement this method.")
+
+    def uninstall(self):
+        raise NotImplementedError("Method not implemented by the subclass. Uninstall manually.")
+
+    def update(self):
+        raise NotImplementedError("Method not implemented by the subclass. Update manually.")
+
+    @staticmethod
+    def _show_help(
+            method: Literal["install", "uninstall", "update"]
+    ) -> None:
+        """
+        Print default help for a given method. Can be called as:
+          BaseInstaller._show_help("install")
+          inst._show_help("install")  # also works (staticmethod)
+        """
+        m = (method or "").lower()
+
+        header = {
+            "install": "Install — download and set up an application/installer.",
+            "uninstall": "Uninstall — remove an application installed by this tool.",
+            "update": "Update — update an application to the latest supported version.",
+            "manual": "Manual — run the installer helper directly with custom args.",
+        }.get(m, "dkinst — helpers and installers")
+
+        lines: list[str] = [header, ""]
+
+        if m == "install":
+            lines += [
+                "Usage:",
+                "  dkinst install help",
+                "  dkinst install <installer> help",
+                "  dkinst install <installer> [args...]",
+                "",
+                "Notes:",
+                "  • Use `dkinst available` to see all installers.",
+                "  • `install <installer> help` shows details for that installer’s install flow.",
+                "  • Extra [args...] are passed to the installer/its helper if supported.",
+            ]
+        elif m == "uninstall":
+            lines += [
+                "Usage:",
+                "  dkinst uninstall help",
+                "  dkinst uninstall <installer> help",
+                "  dkinst uninstall <installer> [args...]",
+                "",
+                "Notes:",
+                "  • Some installers support silent removal flags; check per-installer help.",
+                "  • Extra [args...] are passed through if the installer supports them.",
+            ]
+        elif m == "update":
+            lines += [
+                "Usage:",
+                "  dkinst update help",
+                "  dkinst update <installer> help",
+                "  dkinst update <installer> [args...]",
+                "",
+                "Notes:",
+                "  • If an installer doesn’t support in-place updates, it may reinstall.",
+                "  • Extra [args...] are passed through if supported by the installer.",
+            ]
+        else:
+            lines += [
+                "Usage:",
+                "  dkinst help",
+                "  dkinst available",
+                "  dkinst <install|uninstall|update|manual> help",
+                "  dkinst <install|uninstall|update|manual> <installer> help",
+                "  dkinst <install|uninstall|update|manual> <installer> [args...]",
+            ]
+
+        print("\n".join(lines))
+
+    @staticmethod
+    def _show_manual_help():
+        lines: list[str] = []
+        lines += [
+                "Usage:",
+                "  dkinst manual help",
+                "  dkinst manual <installer> help",
+                "  dkinst manual <installer> <helper-args...>",
+                "",
+                "Notes:",
+                "  • `manual` exposes the installer’s helper parser directly.",
+                "  • `<installer> help` will print that helper’s argparse usage if available.",
+                "  • Use this when you need fine-grained flags not covered by the defaults.",
+            ]
+
+        print("\n".join(lines))
+
+    def _platforms_known(self):
+        """
+        Check if the current platform list is known list.
+        """
+
+        for platform in self.platforms:
+            if platform not in KNOWN_SUPPORTED_PLATFORMS:
+                raise ValueError(f"Platform '{platform}' is not known.")
+
+
+def get_base_known_methods() -> list[str]:
+    """Return a list of known methods that can be called on installers."""
+    all_methods = inspect.getmembers(BaseInstaller, predicate=inspect.isroutine)
+
+    filtered_methods: list[str] = []
+    for method_name, bound_method in all_methods:
+        if not method_name.startswith("_"):
+            filtered_methods.append(method_name)
+
+    global KNOWN_METHODS
+    if KNOWN_METHODS is None:
+        KNOWN_METHODS = filtered_methods
+
+    global ALL_METHODS
+    ALL_METHODS = CUSTOM_METHODS + KNOWN_METHODS
+
+    return filtered_methods
+# Run this at module load time to initialize KNOWN_METHODS
+get_base_known_methods()
+
+
+def assign_base_paths_from_config() -> None:
+    """Assign the base_path of all installers from the configuration file."""
+
+    working_path: Path = Path(__file__).parent.parent
+    config_path: Path = working_path / "config.toml"
+
+    with open(str(config_path), "rb") as f:
+        config_content: dict = tomllib.load(f)
+
+    global INSTALLATION_PATH_PORTABLE_WINDOWS
+    INSTALLATION_PATH_PORTABLE_WINDOWS = config_content["windows_portable_installation_dir"]
+assign_base_paths_from_config()
+
+
+def get_known_methods(installer: BaseInstaller) -> list[str]:
+    """Return a list of known methods that can be called on the given installer."""
+
+    # All the subclasses of BaseInstaller will have most of the methods of BaseInstaller.
+    # But not all, if a method is not overridden, it will be present in subclass as a bound method.
+    # So we filter out the methods that are not overridden.
+    filtered_methods: list[str] = []
+    for method_name in KNOWN_METHODS:
+        if getattr(installer.__class__, method_name) is not getattr(BaseInstaller, method_name):
+            filtered_methods.append(method_name)
+
+    # If 'helper' attribute is not None, this means that the helper module was provided, add the 'manual()' method.
+    if installer.helper:
+        filtered_methods = filtered_methods + CUSTOM_METHODS
+
+    return filtered_methods
+
+
+def _get_helper_parser(
+        installer: BaseInstaller,
+        methods: list[str] = None
+) -> argparse.ArgumentParser | None:
+    """
+    If installer overrides `manual`, try to import
+    `installers.helpers.<installer.name>` and harvest its ArgumentParser.
+
+    :param installer: The installer instance to check.
+    :param methods: Optional list of methods to check against. If not provided, will gather known methods.
+    :return: An ArgumentParser instance if available, or None if nothing could be found.
+    """
+
+    if not methods:
+        methods = get_known_methods(installer)
+
+    if "manual" not in methods:
+        return None  # no manual method, nothing to return
+    if installer.helper is None:
+        return None  # no helper, nothing to return
+
+    # Is there a parser function in the helper?
+    parse_args_callable = getattr(installer.helper, "_make_parser", None)
+    if parse_args_callable is None:
+        return None  # couldn’t obtain one
+
+    parser: argparse.ArgumentParser = parse_args_callable()
+    return parser
+
+
+def _extract_helper_args(
+        installer: BaseInstaller,
+        methods: list[str] = None
+) -> list[str]:
+    """
+    If installer overrides `manual`, try to import
+    `installers.helpers.<installer.name>` and harvest its ArgumentParser and get its tokens (arguments).
+
+    :param installer: The installer instance to check.
+    :param methods: Optional list of methods to check against. If not provided, will gather known methods.
+    :return: A list of CLI tokens that can be used with the installer.
+        Example: ['--prefix', '--force', 'target'], or [] if nothing could be found.
+    """
+    parser: argparse.ArgumentParser | None = _get_helper_parser(installer, methods)
+    if not parser:
+        return []
+
+    tokens: list[str] = []
+    for act in parser._actions:
+        if act.option_strings:                # flags like -f/--force
+            tokens.append("/".join(act.option_strings))
+        else:                                 # positionals
+            tokens.append(act.dest)
+    return tokens

dkinst/installers/helpers/tesseract_ocr_manager.py

@@ -0,0 +1,411 @@
+import tempfile
+import subprocess
+import ctypes
+import json
+import os
+from pathlib import Path
+import shutil
+import sys
+import time
+import urllib.request
+
+from rich.console import Console
+
+from atomicshop.wrappers import githubw
+
+console = Console()
+
+
+SCRIPT_NAME: str = "TesseractOCR Manager"
+AUTHOR: str = "Denis Kras"
+VERSION: str = "1.0.0"
+RELEASE_COMMENT: str = "Initial release"
+
+
+# Constants for GitHub wrapper.
+RELEASE_STRING_PATTERN: str = "*tesseract*exe"
+
+# Constants for Tesseract installation on Windows.
+WINDOWS_TESSERACT_DEFAULT_INSTALLATION_DIRECTORY: str = r"C:\Program Files\Tesseract-OCR"
+
+
+# Constants for vcpkg and Tesseract compilation.
+VCPKG_DIR: Path = Path.home() / "vcpkg"
+TRIPLET: str = "x64-windows"  # or "x64-windows-static"
+PORT: str = f"tesseract[training-tools]:{TRIPLET}"
+VSWHERE_EXE: Path = Path(
+    os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)")
+) / "Microsoft Visual Studio" / "Installer" / "vswhere.exe"
+TESSERACT_VCPKG_TOOLS_DIR: Path = VCPKG_DIR / "installed" / TRIPLET / "tools" / "tesseract"
+TESSERACT_VCPKG_TOOLS_EXE: Path = TESSERACT_VCPKG_TOOLS_DIR / 'tesseract.exe'
+TESSDATA_DIR: Path = TESSERACT_VCPKG_TOOLS_DIR / "tessdata"
+
+
+TESSERACT_GITHUB_WRAPPER: githubw.GitHubWrapper = githubw.GitHubWrapper(
+    user_name="tesseract-ocr",
+    repo_name="tesseract",
+    branch="main"
+)
+
+
+def get_latest_installer_version() -> str:
+    """
+    Get the latest Tesseract OCR installer version from GitHub.
+    This function fetches the latest release information from the Tesseract OCR GitHub repository.
+    It returns the version number of the latest installer available.
+    """
+
+    latest_release: str = TESSERACT_GITHUB_WRAPPER.get_latest_release_version(
+        asset_pattern=RELEASE_STRING_PATTERN,
+    )
+
+    return latest_release
+
+
+def use_installer(
+        set_path: bool = False
+) -> None:
+    """
+    Install Tesseract OCR on Windows.
+    This function downloads the latest available Tesseract installer from GitHub and installs it.
+    It also adds the Tesseract installation directory to the system PATH.
+    The latest installer maybe lower than the latest available version, so if you need the latest you will need
+    to use the compiler version.
+
+    :param set_path: If True, adds the Tesseract installation directory to the system PATH.
+    """
+
+    temp_file_path: str = tempfile.gettempdir()
+    tesseract_installer = TESSERACT_GITHUB_WRAPPER.download_latest_release(
+        target_directory=temp_file_path,
+        asset_pattern=RELEASE_STRING_PATTERN,
+        find_latest_available_asset=True
+    )
+
+    # The Admin needed to install Tesseract.
+    subprocess.check_call([tesseract_installer, "/S"])
+
+    # Add Tesseract to the PATH.
+    if set_path:
+        subprocess.check_call(["setx", "PATH", f"%PATH%;{WINDOWS_TESSERACT_DEFAULT_INSTALLATION_DIRECTORY}"])
+
+
+def get_latest_compiled_version() -> str:
+    """
+    Get the latest compiled version of Tesseract OCR.
+    This function fetches the latest release information from the Tesseract OCR GitHub repository
+    and returns the version number of the latest compiled release.
+    """
+
+    latest_release: str = TESSERACT_GITHUB_WRAPPER.get_latest_release_version()
+    return latest_release
+
+
+def compile_exe(
+        set_path: bool = False
+) -> int:
+    """
+    Compile the ltest Tesseract version from source.
+    """
+
+    def run(cmd, *, ok=(0,), **kw):
+        print(f"[+] {cmd}")
+        process_instance = subprocess.run(cmd, shell=True, **kw)
+        if process_instance.returncode not in ok:
+            raise subprocess.CalledProcessError(process_instance.returncode, cmd)
+
+    def is_admin():
+        # noinspection PyUnresolvedReferences
+        return bool(ctypes.windll.shell32.IsUserAnAdmin())
+
+    def have(exe):
+        return shutil.which(exe) is not None
+
+    def have_msvc():
+        if not VSWHERE_EXE.exists():
+            return False
+
+        try:
+            out = subprocess.check_output(
+                f'"{VSWHERE_EXE}" -latest -products Microsoft.VisualStudio.Product.BuildTools -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -format json',
+                shell=True, text=True)
+            return bool(json.loads(out))
+        except subprocess.CalledProcessError:
+            return False
+
+    def install_build_tools() -> int:
+        if have_msvc():
+            return 0
+
+        print("Installing Visual Studio 2022 Build Tools + C++ workload …")
+        url = "https://aka.ms/vs/17/release/vs_BuildTools.exe"
+        with tempfile.TemporaryDirectory() as td:
+            exe = Path(td) / "vs_BuildTools.exe"
+            urllib.request.urlretrieve(url, exe)
+            run(
+                f'"{exe}" --passive --wait --norestart '
+                '--add Microsoft.VisualStudio.Workload.VCTools --includeRecommended',
+                ok=(0, 3010, 1641))
+        print("Waiting for Build Tools to register …")
+        for _ in range(60):
+            if have_msvc():
+                return 0
+            time.sleep(5)
+
+        console.print("Timed out waiting for Build Tools to register.", style="red")
+        return 1
+
+    if os.name != "nt":
+        console.print("This script is for Windows only.", style="red")
+        return 1
+    if not is_admin():
+        console.print("This script requires administrative privileges to run.", style="red")
+        return 1
+
+    execution_result: int = install_build_tools()
+    if execution_result != 0:
+        return execution_result
+
+    if not have("git"):
+        console.print("Git is not installed. Please install Git for Windows.", style="red")
+        return 1
+
+    if not VCPKG_DIR.exists():
+        run(f'git clone https://github.com/microsoft/vcpkg "{VCPKG_DIR}"')
+    else:
+        console.print(f"vcpkg exists in [{VCPKG_DIR}]. Updating...", style="blue")
+        run(f'git -C "{VCPKG_DIR}" pull')
+    run(f'"{VCPKG_DIR / "bootstrap-vcpkg.bat"}"')
+
+    vcpkg = VCPKG_DIR / "vcpkg.exe"
+    console.print(f"Creating {PORT} port in vcpkg...", style="blue")
+    run(f'"{vcpkg}" install {PORT} --disable-metrics')
+    run(f'"{vcpkg}" integrate install --disable-metrics')
+
+    os.makedirs(TESSDATA_DIR, exist_ok=True)
+
+    if set_path:
+        run(f'setx PATH "%PATH%;{TESSERACT_VCPKG_TOOLS_DIR}"')
+        # os.environ["PATH"] = os.environ.get("PATH", "") + os.pathsep + str(TESSERACT_VCPKG_TOOLS_DIR)
+        run(f'setx TESSDATA_PREFIX "{TESSDATA_DIR}"')
+        # os.environ["TESSDATA_PREFIX"] = str(TESSDATA_DIR)
+
+    console.print("\nDone. Open a NEW CMD terminal and run [tesseract --version] to verify the installation.", style="green", markup=False)
+    return 0
+
+
+def get_environment_path() -> str | None:
+    """
+    Check if Tesseract is set in the environment variables.
+    This function checks if the Tesseract command is available in the system PATH.
+    Returns the path of tesseract if exists, otherwise None.
+    """
+    return shutil.which("tesseract")
+
+
+def get_executable_version(exe_path: str) -> str:
+    """
+    Get the version of the Tesseract executable.
+    This function runs the Tesseract command with the `--version` flag and returns the version string.
+    If the executable is not found, it returns an empty string.
+    """
+    try:
+        result = subprocess.run([exe_path, "--version"], capture_output=True, text=True)
+        if result.returncode == 0:
+            string_result = result.stdout.strip()
+            full_version: str = string_result.split('\n')[0]  # Get the first line which contains the version.
+            numeric_string: str = full_version.split(' ')[-1]  # Get the last part which is the version number.
+            return numeric_string
+        else:
+            return ""
+    except FileNotFoundError:
+        return ""
+
+
+def _make_parser():
+    import argparse
+    parser = argparse.ArgumentParser(description="Install Tesseract OCR on Windows.")
+    parser.add_argument(
+        "-i", "--installer_usage", action="store_true",
+        help="Use the latest Tesseract installer from GitHub Releases.")
+    parser.add_argument(
+        "-c", "--compile_portable", action="store_true",
+        help="Compile the latest Tesseract version from source in GitHub Releases. "
+             "This could take a while, an hour or more, depending on your system."
+             "This installs Visual Studio Build Tools and all the tesseract dependencies.")
+    parser.add_argument(
+        "-iv", "--installer_version_string_fetch", action="store_true",
+        help="Fetch the latest Tesseract installer version string from GitHub Releases.")
+    parser.add_argument(
+        "-cv", "--compile_version_string_fetch", action="store_true",
+        help="Fetch the latest Tesseract compiled version string from GitHub Releases.")
+    parser.add_argument(
+        "--get-path", action="store_true",
+        help="Return the path of [tesseract] command from the PATH.")
+    parser.add_argument(
+        "--set-path", action="store_true",
+        help="set the path of [tesseract] command to the PATH, based on any of the installation methods.")
+    parser.add_argument(
+        "-f", "--force", action="store_true",
+        help="Force any action without asking.")
+    parser.add_argument(
+        "--exe-path", type=str, default=None,
+        help="Path to the Tesseract executable if you want to set it manually. If you set any of the above installation methods, the version will checked against the latest available version in GitHub Releases, and you will be asked if you want to update it.")
+
+    return parser
+
+
+def main(
+        installer_usage: bool = False,
+        compile_portable: bool = False,
+        installer_version_string_fetch: bool = False,
+        compile_version_string_fetch: bool = False,
+        get_path: bool = False,
+        set_path: bool = False,
+        force: bool = False,
+        exe_path: str = None
+) -> int:
+
+    if (installer_version_string_fetch + compile_version_string_fetch + get_path) > 1:
+        print("You cannot more than 1 argument of [--installer_version_string_fetch], [--compile_version_string_fetch], [--get-path] arguments at the same time.")
+        return 1
+
+    if installer_version_string_fetch or compile_version_string_fetch or get_path:
+        result: str = ""
+        selected_argument: str = ""
+        if installer_version_string_fetch:
+            result = get_latest_installer_version()
+            selected_argument = 'installer_version_string_fetch'
+        if compile_version_string_fetch:
+            result = get_latest_compiled_version()
+            selected_argument = 'compile_version_string_fetch'
+        if get_path:
+            result = get_environment_path()
+            selected_argument = 'get_path'
+
+        print(result)
+
+        if any([installer_usage, compile_portable, set_path]):
+            print(f"You need to remove the [--{selected_argument}] argument, to use other arguments...")
+
+        return 0
+
+    if compile_portable and installer_usage:
+        print("You cannot use both [--installer_usage] and [--compile_portable] arguments at the same time.")
+        return 1
+
+    current_environment_path: str = get_environment_path()
+
+    if exe_path:
+        # If 'current_environment_path' is set and not None, and 'set_path' is True to change the PATH to provided 'exe_path' and
+        # the provided 'exe_path' is different from the current one, ask the user if they want to change it.
+        if current_environment_path and set_path and current_environment_path.lower() != exe_path.lower() and not force:
+            print(f"Current System Environment PATH Tesseract executable path: {current_environment_path}\n"
+                  f"Do you want to update it with provided executable path?: {exe_path}\n"
+                  f"(y/n)")
+            if input().strip().lower() != 'y':
+                print("Exiting without updating the path.")
+                return 0
+
+        if compile_portable:
+            latest_compiled_version: str = get_latest_compiled_version()
+            provided_exe_version: str = get_executable_version(exe_path)
+
+            executable_parent_path: str = os.path.dirname(exe_path)
+            tessdata_parent_path: str = os.path.join(executable_parent_path, "tessdata")
+
+            # Check if the provided executable path exists and only then overwrite.
+            if latest_compiled_version != provided_exe_version:
+                if os.path.exists(exe_path) and not force:
+                    console.print(f"The provided Tesseract executable version: [{provided_exe_version}] "
+                          f"is not the latest available version: [{latest_compiled_version}]. "
+                          f"Do you want to update it and overwrite? (y/n)", style="yellow")
+                    if input().strip().lower() != 'y':
+                        print("Exiting without updating the provided tesseract executable.")
+                        return 0
+
+                execution_result: int = compile_exe(set_path=False)
+                if execution_result != 0:
+                    console.print("Failed to compile Tesseract from source. "
+                          "Please check the logs for more details.", style="red")
+                    return execution_result
+
+                # Backing up the current version of Tesseract executable. But backup only if the folder exists, since if it is not it's new installation.
+                if os.path.exists(executable_parent_path):
+                    parent_of_the_current_parent_path: str = os.path.dirname(executable_parent_path)
+                    exe_parent_dir_name: str = os.path.basename(executable_parent_path)
+                    backup_path: str = os.path.join(parent_of_the_current_parent_path, f"{exe_parent_dir_name}_{provided_exe_version}_backup")
+                    # Rename the current executable directory to back up.
+                    shutil.move(executable_parent_path, backup_path)
+                    print(f"Backed up the current Tesseract executable to: {backup_path}")
+
+                # Create new empty directory for the new Tesseract executable.
+                os.makedirs(executable_parent_path, exist_ok=True)
+
+                # Copy all the files from the compiled Tesseract directory to the provided executable path.
+                for item in TESSERACT_VCPKG_TOOLS_DIR.iterdir():
+                    if item.is_file():
+                        shutil.copy(item, executable_parent_path)
+                    elif item.is_dir():
+                        shutil.copytree(item, os.path.join(executable_parent_path, item.name), dirs_exist_ok=True)
+            else:
+                print(f"The provided Tesseract executable version: {provided_exe_version} "
+                      f"is already the latest available version: {latest_compiled_version}. "
+                      f"No need to update.")
+
+            # Remove the old executable from the PATH if it exists.
+            if not current_environment_path or current_environment_path.lower() != exe_path.lower():
+                # print(f"Removing old Tesseract executable path from the PATH: {current_environment_path}")
+                # subprocess.check_call(["setx", "PATH", f"%PATH%;{str(Path(current_environment_path).parent)}"])
+
+                # Set the new Tesseract executable path and TESSDATA_PREFIX.
+                subprocess.check_call(["setx", "PATH", f"%PATH%;{executable_parent_path}"])
+                subprocess.check_call(["setx", "TESSDATA_PREFIX", tessdata_parent_path])
+                print(f"Tesseract executable path set to: {exe_path}")
+                print(f"TESSDATA_PREFIX set to: {tessdata_parent_path}")
+            return 0
+
+        if installer_usage:
+            print("This option is not implemented yet, please use the [--compile_portable] option to compile Tesseract from source.")
+            return 0
+
+    if compile_portable:
+        if not force:
+            print("Compiling Tesseract from source can take time ~2h. "
+                  "Do you want to continue? (y/n)")
+            if input().strip().lower() != 'y':
+                return 0
+
+            if current_environment_path != TESSERACT_VCPKG_TOOLS_EXE and set_path:
+                print(f"Current Tesseract executable path: {current_environment_path}\n"
+                      f"Do you want to update it with compiled executable path?: {TESSERACT_VCPKG_TOOLS_EXE}?\n"
+                      f"(y/n)")
+            if input().strip().lower() != 'y':
+                print("Exiting without compiling Tesseract.")
+                return 0
+
+        execution_result: int = compile_exe(set_path=set_path)
+        if execution_result != 0:
+            print("Failed to compile Tesseract from source. "
+                  "Please check the logs for more details.")
+            return execution_result
+        else:
+            print("Tesseract OCR compiled successfully.")
+            return 0
+
+    return 0
+
+
+if __name__ == '__main__':
+    parser = _make_parser()
+    args = parser.parse_args()
+    sys.exit(main(
+        installer_usage=args.installer_usage,
+        compile_portable=args.compile_portable,
+        installer_version_string_fetch=args.installer_version_string_fetch,
+        compile_version_string_fetch=args.compile_version_string_fetch,
+        get_path=args.get_path,
+        set_path=args.set_path,
+        force=args.force,
+        exe_path=args.exe_path
+    ))

dkinst/installers/tesseract_ocr.py

@@ -0,0 +1,63 @@
+from pathlib import Path
+from types import ModuleType
+from typing import Literal
+
+from . import _base
+from . helpers import tesseract_ocr_manager
+
+
+class TesseractOCR(_base.BaseInstaller):
+    def __init__(self):
+        super().__init__()
+        self.name: str = Path(__file__).stem
+        self.description: str = "Tesseract OCR Installer"
+        self.version: str = tesseract_ocr_manager.VERSION
+        self.platforms: list = ["windows"]
+        self.helper: ModuleType = tesseract_ocr_manager
+
+        self.dir_path: str = str(Path(self.base_path) / self.name)
+        self.exe_path: str = str(Path(self.dir_path) / "tesseract.exe")
+
+    def install(
+            self,
+            force: bool = False
+    ):
+        tesseract_ocr_manager.main(
+            compile_portable=True,
+            set_path=True,
+            exe_path=self.exe_path,
+            force=force
+        )
+
+    def update(
+            self,
+            force: bool = False
+    ):
+        self.install(force=force)
+
+    def _show_help(
+            self,
+            method: Literal["install", "uninstall", "update"]
+    ) -> None:
+        if method == "install":
+            method_help: str = (
+                "This method uses the [tesseract_ocr_manager.py] with the following arguments:\n"
+                "  --compile-portable               - compile the latest tesseract executable.\n"
+                "  --set-path                       - set system PATH variable to provided executable.\n"
+                f'  --exe-path "{self.exe_path}"                      - Specify the target executable\n'
+                "\n"
+                "  --force                          - force reinstallation/recompilation of the latest version even if executable is already present.\n"
+                "  This one is used only if you provide it explicitly to the 'install' command. Example:\n"
+                "    dkinst install tesseract_ocr force\n"
+                "\n"
+                "You can also use the 'manual' method to provide custom arguments to the helper script.\n"
+                "Example:\n"
+                "  dkinst manual tesseract_ocr help\n"
+                "  dkinst manual tesseract_ocr --compile-portable --set-path\n"
+                "\n"
+            )
+            print(method_help)
+        elif method == "update":
+            print("In this installer 'update()' is the same as 'install()'.")
+        else:
+            raise ValueError(f"Unknown method '{method}'.")

dkinst-0.1.0.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: dkinst
+Version: 0.1.0
+Summary: Den K Simple Installer
+Author: Denis Kras
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/denis-kras/dkinst
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: wheel
+Requires-Dist: rich==14.1.0
+Dynamic: license-file
+
+<h1 align="center">Den K Simple Installer - dkinst</h1>
+
+
+
+<!-- ABOUT THE PROJECT -->
+## About The Project
+
+
+dkinst is a simple installer mostly for my professional needs, in case I need a one-click installer for a library or a tool.
+So, I will not search for a setup script/line or write one.
+It is written in Python, currently supports 3.12. Hope to support newer versions in the near future.
+
+
+<!-- GETTING STARTED -->
+## Getting Started
+
+To get a local copy up and running follow these simple steps.
+
+### Installation Windows
+
+1. Install Python 3.12.10 or use the silent installer that will download and install it for you.<br>
+    1.1. Download the file: install_python_as_admin.cmd<br>
+    1.2. Run CMD as admin.<br>
+    1.3. In CMD run the script with '3.12.10' argument:
+    ```cmd
+   install_python_as_admin.cmd 3.12.10
+   ```
+   <br>
+2. Install the library using pip:
+   ```cmd
+   pip install dkinst
+   ```
+   
+### Installation Linux
+   
+Ubuntu 24 already comes with python 3.12, just use pip to install the library:
+   ```sh
+   pip install dkinst
+   ```
+
+<!-- USAGE EXAMPLES -->
+## Usage
+
+Execute in CMD:
+```cmd
+dkinst
+dkinst help
+```
+For full help and examples about installation commands.
+
+
+
+<!-- LICENSE -->
+## License
+
+Distributed under the MIT License. See `LICENSE.txt` for more information.
+
+
+
+<!-- HISTORY -->
+## History
+
+[History.md](https://github.com/BugSec-Official/atomicshop/blob/main/History.md#history)

dkinst-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+dkinst/__init__.py,sha256=TCgwn6zw4K2i8qTszGSbHd30uBQW4giS4E8GEd8OglY,78
+dkinst/cli.py,sha256=ChBAkoPI-mifHlO4dOpIgDBFKd1zUfZM2FEIxoQuO9s,9238
+dkinst/installers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dkinst/installers/_base.py,sha256=_3t0_xkbHRvFtxpDkLkZw9_pizIEiK5sXTYMIWK3jUw,10278
+dkinst/installers/tesseract_ocr.py,sha256=LqcOJCTQJU3xPz3wm_nQI5Bt6bB5dgDPzf7WykpSM6A,2524
+dkinst/installers/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dkinst/installers/helpers/tesseract_ocr_manager.py,sha256=-Br9vHbqcQHRsNlDkakw5mLMxMBTydqXCblhpcBmp0A,17734
+dkinst-0.1.0.dist-info/licenses/LICENSE,sha256=ohlj1rmsTHdctr-wyqmP6kbFC6Sff8pJd29v3pruZ18,1088
+dkinst-0.1.0.dist-info/METADATA,sha256=TNOweiIXtwWbwPk-1vzq0WDLN0Mzx-SeosGW516BN5Y,2018
+dkinst-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dkinst-0.1.0.dist-info/entry_points.txt,sha256=YNgO3GufKMdA_oRqWEGAVh6k00oIuPItqqChoUtU278,43
+dkinst-0.1.0.dist-info/top_level.txt,sha256=_dGNrME6z6Ihv2sxGC4hfAlnVuhoDlKwx-97LZ2xtQ0,7
+dkinst-0.1.0.dist-info/RECORD,,

dkinst-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dkinst-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dkinst = dkinst.cli:main

dkinst-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 denis-kras
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dkinst-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dkinst