sdv-installer 0.0.0.dev11__py3-none-any.whl

sdv_installer/utils/console_utils.py

@@ -0,0 +1,277 @@
+"""Utility functions for securely handling password input with character masking."""
+
+import sys
+import time
+from urllib.parse import urlparse, urlunparse
+
+from sdv_installer.config import API_VALIDATE
+from sdv_installer.constants import (
+    ACTION_ERROR_MESSAGE,
+    ACTION_SUCCESS_ALREADY_INSTALLED,
+    ACTION_SUCCESS_ALREADY_UPDATED,
+    ACTION_SUCCESS_MESSAGE,
+    ADDITIONAL_DEPS_MESSAGE_PREFIX,
+    BACKSPACE_KEYS,
+    ENTER_KEY,
+    NEWLINE_KEY,
+    SUMMARY_PARTIAL_SUCCESS_MESSAGE,
+    SUMMARY_SUCCESS_MESSAGE,
+    SUMMARY_WARNING_MESSAGE,
+    ExitCode,
+)
+from sdv_installer.utils.package_utils import is_version_bigger, is_version_equal
+
+
+def print_with_flush(text):
+    """Helper function to print text and flush the output immediately."""
+    sys.stdout.write(text)
+    sys.stdout.flush()
+
+
+def handle_keypress(character, password):
+    """Handles user keypresses: backspace and normal characteracter input."""
+    if character in BACKSPACE_KEYS:
+        if password:
+            password = password[:-1]
+            print_with_flush('\b \b')
+
+    else:
+        password += character
+        print_with_flush('*')
+
+    return password
+
+
+def get_password(prompt, get_char_func):
+    """Generic password input handler."""
+    print_with_flush(prompt)
+    password = ''
+    while True:
+        char = get_char_func()
+        char = char.decode('utf-8') if isinstance(char, bytes) else char
+        if char in [ENTER_KEY, NEWLINE_KEY]:
+            print_with_flush('\n')
+            break
+        password = handle_keypress(char, password)
+
+    return password
+
+
+def get_char_win():
+    """Windows-specific character reading function."""
+    import msvcrt
+
+    return msvcrt.getch()
+
+
+def get_char_unix():
+    """Unix-specific character reading function."""
+    import termios
+    import tty
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        return sys.stdin.read(1)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+def get_password_input(prompt='License Key: '):
+    """Password getter with stars."""
+    if sys.platform == 'win32':
+        return get_password(prompt, get_char_win)
+
+    return get_password(prompt, get_char_unix)
+
+
+def print_message(message):
+    """Function to be used to print messages across the library."""
+    print(message)  # noqa
+
+
+def handle_process_exit_code(
+    process,
+    package,
+    printable_package,
+    version=None,
+    action=None,
+    installed_packages=None,
+    upgrade=False,
+):
+    """Handle and display messages based on a subprocess exit code.
+
+    Determines the appropriate success or error message to display
+    based on the exit code of a subprocess and the package installation context.
+
+    Args:
+        process (subprocess.Process):
+            A completed subprocess with a `returncode` attribute.
+        package (str):
+            The internal package name.
+        printable_package (str):
+            The user-friendly package name for display.
+        version (str, optional):
+            The target version of the package. Defaults to None.
+        action (str, optional):
+            The action performed (e.g., 'install', 'upgrade'). Defaults to None.
+        installed_packages (dict, optional):
+            A mapping of package names to installed versions. Defaults to None.
+        upgrade (bool, optional):
+            Indicates whether this is an upgrade operation. Defaults to False.
+    """
+    if process.returncode == ExitCode.SUCCESS:
+        msg = ACTION_SUCCESS_MESSAGE.get(action)
+        if action == 'install':
+            installed_version = installed_packages.get(package) if installed_packages else None
+            if installed_version:
+                is_installed_bigger = is_version_bigger(installed_version, version)
+                is_installed_equal = is_version_equal(installed_version, version)
+                if upgrade and is_installed_bigger or is_installed_equal:
+                    msg = ACTION_SUCCESS_ALREADY_UPDATED.get(action)
+                elif installed_version and is_installed_equal:
+                    msg = ACTION_SUCCESS_ALREADY_INSTALLED.get(action)
+
+    elif process.returncode >= ExitCode.ERROR:
+        msg = ACTION_ERROR_MESSAGE.get(action)
+
+    sys.stdout.write(f'\r{printable_package} - {msg}\n')
+    sys.stdout.flush()
+
+
+def display_progress_animation(
+    process,
+    package,
+    version=None,
+    action=None,
+    installed_packages=None,
+    upgrade=False,
+    show_version=False,
+):
+    """Display an animated progress indicator while a subprocess is running.
+
+    This function continuously displays an animated progress message
+    (e.g., "package .", "package ..", "package ...") until the given
+    subprocess finishes. Once completed, it prints a final message
+    based on the process's exit code.
+
+    Args:
+        process (subprocess.Popen):
+            The subprocess to monitor.
+        package (str):
+            The name of the package being processed.
+        version (str, optional):
+            An optional version string to display with the package name.
+        action (str, optional):
+            The action being performed (e.g., "install", "download"). Used to determine
+            the appropriate success or error message.
+    """
+    printable_package = f'{package} (version {version})' if show_version and version else package
+
+    frames = [f'{printable_package} .  ', f'{printable_package} .. ', f'{printable_package} ...']
+    while True:
+        for frame in frames:
+            sys.stdout.write(f'\r{frame}')
+            sys.stdout.flush()
+            time.sleep(0.3)
+            if process.poll() is not None:
+                handle_process_exit_code(
+                    process,
+                    package,
+                    printable_package,
+                    version,
+                    action,
+                    installed_packages,
+                    upgrade,
+                )
+                return
+
+
+def print_invalid_credentials():
+    """Print an error message for invalid or expired SDV Enterprise credentials."""
+    print_message(
+        'Error installing SDV Enterprise. This may be due to an invalid '
+        'username/license key combo, or because your license key has expired. '
+        "Please double-check that you're providing the right credentials. If "
+        "you're continuing to experience issues, please reach out to the "
+        'DataCebo team. '
+    )
+
+
+def print_failed_to_connect():
+    """Print an error message indicating failure to connect to the authentication server."""
+    print_message(
+        'Failed to connect to the authentication server.\n'
+        'Please check your internet connection or firewall settings and that the API server '
+        f'{API_VALIDATE} is reachable.'
+    )
+
+
+def print_warning_base_connector_package_installed():
+    """Print a 'warning' message indicating that the base connector package will be installed."""
+    print_message(
+        "\nWarning: In order to use AI Connectors, you'll need to install "
+        'database-specific packages. Please use the `--options` '
+        'flag to specify your database variants.'
+    )
+
+
+def print_additional_dependencies_installed(additional_dependencies):
+    """Print a message indicating that additional enterprise-related packages were installed.
+
+    Args:
+        action (list[str]):
+            The list of additional packages that were installed.
+    """
+    if len(additional_dependencies) == 0:
+        return
+    message = f'{ADDITIONAL_DEPS_MESSAGE_PREFIX} ('
+    message += ', '.join(additional_dependencies) + ').'
+    print_message('\n' + message)
+
+
+def print_package_summary(action, package_status, sdv_included):
+    """Print a summary message indicating that whether or not the installation was successful.
+
+    Args:
+        action (str):
+            The action that was performed (download or install).
+        package_status (dict):
+            A dictionary with the packages and whether or not the action was successfully performed.
+        sdv_included (bool):
+            Whether sdv-enterprise was included in the successful result.
+    """
+    all_success = all(package_status.values())
+
+    if all_success and sdv_included:
+        print_message('\n' + SUMMARY_SUCCESS_MESSAGE[action])
+
+    elif all_success and not sdv_included:
+        print_message('\n' + SUMMARY_PARTIAL_SUCCESS_MESSAGE[action])
+    else:
+        print_message('\n' + SUMMARY_WARNING_MESSAGE[action])
+
+
+def mask_license_key(url):
+    """Mask the license key in a URL with stars.
+
+    This function takes a URL that contains embedded basic authentication
+    credentials (username and password/license key) and replaces the
+    license key with a masked value ("****") for safe logging or display.
+
+    Args:
+        url (str):
+            The URL containing basic auth credentials.
+
+    Returns:
+        str:
+            The URL with the license key masked. If no username is present,
+            the original URL is returned.
+    """
+    parsed = urlparse(url)
+    if parsed.username:
+        netloc = f'{parsed.username}:****@{parsed.hostname}'
+        return urlunparse(parsed._replace(netloc=netloc))
+
+    return url

sdv_installer/utils/data_storage.py

@@ -0,0 +1,86 @@
+"""Utilities to handle appdirs and store application data."""
+
+import logging
+import os
+from pathlib import Path
+
+from platformdirs import user_data_dir
+
+APP_NAME = 'SDV-Installer'
+APP_AUTHOR = 'DataCebo'
+LOGGER = logging.getLogger(__name__)
+CONFIG_PATH = Path(__file__).resolve().parent
+
+
+def store_package_name(package):
+    """Store the installed package name in a text file in a platform-specific directory.
+
+    Args:
+        packages (str):
+            A string representing the package name.
+    """
+    storage_dir = Path(user_data_dir(APP_NAME, APP_AUTHOR))
+
+    try:
+        storage_dir.mkdir(parents=True, exist_ok=True)
+    except PermissionError:
+        # No access to user data dir, fall back if possible
+        if os.access(CONFIG_PATH, os.W_OK):
+            storage_dir = CONFIG_PATH
+        else:
+            # Nowhere to write
+            return
+
+    except OSError:
+        # Filesystem might be read-only or inaccessible
+        return
+
+    package_file = storage_dir / 'installed_packages.txt'
+    try:
+        with package_file.open('a') as installed_packages:
+            installed_packages.write(package + '\n')
+
+    except (PermissionError, OSError) as error:
+        LOGGER.error(f"Failed to write installed package '{package}' to '{package_file}': {error}")
+
+
+def read_stored_packages():
+    """Read the list of installed packages from the platform-specific data file.
+
+    Returns:
+        list[str]:
+            A list of installed package names.
+
+    Raises:
+        FileNotFoundError:
+            If the file does not exist.
+    """
+    storage_dir = Path(user_data_dir(APP_NAME, APP_AUTHOR))
+    package_file = storage_dir / 'installed_packages.txt'
+
+    if not package_file.exists():
+        raise FileNotFoundError('No stored package file found.')
+
+    with package_file.open('r') as installed_packages:
+        return set([line.strip() for line in installed_packages if line.strip()])
+
+
+def remove_package_name(package):
+    """Remove a single package name from the installed packages file.
+
+    Args:
+        package (str):
+            A string representing the package name to remove.
+    """
+    storage_dir = Path(user_data_dir(APP_NAME, APP_AUTHOR))
+    package_file = storage_dir / 'installed_packages.txt'
+
+    if not package_file.exists():
+        return
+
+    # Read all packages and filter out the one to remove
+    with package_file.open('r') as package_reader:
+        packages = [line.strip() for line in package_reader if line.strip() != package]
+
+    with package_file.open('w') as package_writer:
+        package_writer.write('\n'.join(packages) if packages else '')

sdv_installer/utils/package_utils.py

@@ -0,0 +1,268 @@
+"""Utility functions for package and virtual env."""
+
+import os
+import pathlib
+import subprocess
+import sys
+from importlib.metadata import distributions
+from typing import Dict, Tuple
+
+from packaging.requirements import Requirement
+from packaging.utils import parse_sdist_filename, parse_wheel_filename
+from packaging.version import InvalidVersion, Version
+
+from sdv_installer.constants import EXPECTED_PACKAGES, ProductType
+
+BASE_PREFIX = 'sdv-enterprise'
+
+
+def list_current_installed_packages():
+    """Returns a list of currently installed package names.
+
+    Uses `importlib.metadata.distributions()` to retrieve metadata for all installed
+    distributions and extracts their package names.
+
+    Returns:
+        List[str]:
+            A list of package names currently installed in the environment.
+    """
+    return [dist.metadata['Name'] for dist in distributions()]
+
+
+def list_current_installed_packages_with_their_version():
+    """Returns a list of currently installed package names.
+
+    Uses `importlib.metadata.distributions()` to retrieve metadata for all installed
+    distributions and extracts their package names.
+
+    Returns:
+        List[str]:
+            A list of package names currently installed in the environment.
+    """
+    return {dist.metadata['Name']: dist.metadata['Version'] for dist in distributions()}
+
+
+def clean_path(path: str):
+    """Cleans a file path by stripping leading/trailing whitespace and converting to lowercase.
+
+    Args:
+        path (str):
+            The input file path as a string.
+
+    Returns:
+        str:
+            The cleaned file path.
+    """
+    return path.strip().lower()
+
+
+def get_package_name(file_path: str):
+    """Extracts the package name from a given file path.
+
+    Supports `.whl`, `.tar.gz`, and other archive formats. For wheel and source distribution
+    files, the name is parsed using appropriate helper functions. For other file types,
+    the base file name is returned.
+
+    Args:
+        file_path (str):
+            Path to the package file.
+
+    Returns:
+        str or None:
+            The extracted package name, or None if the path is invalid.
+    """
+    package_name = None
+    if not file_path or not file_path.strip():
+        return None
+
+    file_path = clean_path(file_path)
+    if file_path.endswith('.whl') or file_path.endswith('.tar.gz'):
+        filename = os.path.basename(file_path)
+        if file_path.endswith('.whl'):
+            package_name, _, _, _ = parse_wheel_filename(filename)
+        else:
+            package_name, _ = parse_sdist_filename(filename)
+    else:
+        package_name = pathlib.PurePath(file_path).name
+
+    return package_name
+
+
+def get_latest_package_version(package_name, index_url=None):
+    """Returns a sorted list of available versions for a given package.
+
+    This function invokes `pip index versions` via subprocess to retrieve the
+    list of available versions for a specified package from the given Python
+    package index (PyPI or a custom index).
+
+    Args:
+        package_name (str):
+            The name of the package to query.
+        index_url (str, optional):
+            The base URL of the package index to use. If not provided, the default PyPI
+            index is used.
+
+    Returns:
+        str:
+            Returns a string representing the highest version available.
+            Returns None if the pip command fails.
+    """
+    cmd = [sys.executable, '-m', 'pip', 'index', 'versions', package_name]
+    if index_url:
+        cmd += ['--index-url', index_url]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        return None
+
+    for line in result.stdout.splitlines():
+        if line.startswith('Available versions: '):
+            text_versions = line.replace('Available versions: ', '')
+            text_versions = text_versions.split(',')
+            break
+
+    return text_versions[0]
+
+
+def split_base_and_bundles(
+    packages: Dict[str, str], use_product_type: bool = True
+) -> Tuple[str, list]:
+    """Split base sdv-enterprise packages from bundles.
+
+    Args:
+        packages (dict): List of package dicts. Each dict has the keys 'package_name' and
+        'package_type'.
+        use_product_type (bool): Whether or not to use the product type attribute to figure out
+        if a package is a base package or bundle. If false, fall back to using the package name.
+
+    Returns:
+        tuple (list[str], list[str]). A list of base packages and a list of bundle packages.
+    """
+    base_packages = []
+    bundles = []
+    if use_product_type:
+        for package, product_type in packages.items():
+            if product_type == ProductType.BASE.value:
+                base_packages.append(package)
+            elif product_type == ProductType.BUNDLE.value:
+                bundles.append(package)
+    else:
+        for package in packages:
+            if package.startswith(BASE_PREFIX):
+                base_packages.append(package)
+            else:
+                bundles.append(package)
+
+    return sorted(base_packages), sorted(bundles)
+
+
+def is_version_bigger(installed_version, requested_version):
+    """Check if the installed version is greater than the requested version."""
+    if isinstance(installed_version, str) and isinstance(requested_version, str):
+        try:
+            return Version(installed_version) > Version(requested_version)
+        except InvalidVersion:
+            return False
+
+    return False
+
+
+def is_version_equal(installed_version, requested_version):
+    """Check if the installed version is equal to the requested version."""
+    if isinstance(installed_version, str) and isinstance(requested_version, str):
+        try:
+            return Version(installed_version) == Version(requested_version)
+        except InvalidVersion:
+            return False
+
+    return False
+
+
+def convert_to_set(obj):
+    """Convert a list, tuple, str, int, float, or dictionary to a set."""
+    if isinstance(obj, (list, tuple)):
+        obj = set(obj)
+    elif isinstance(obj, (str, int, float)):
+        obj = {obj}
+    elif isinstance(obj, dict):
+        obj = set(obj.keys())
+    return obj
+
+
+def get_requirement_name(requirement_name):
+    """Get the name of a requirement, useful to remove extra_requires, specifiers, markers."""
+    if isinstance(requirement_name, str):
+        return Requirement(requirement_name).name
+    return requirement_name
+
+
+def is_none_or_empty_iterate(obj):
+    """Check if object is None or an empty list/dict/iterate."""
+    return obj is None or (hasattr(obj, '__len__') and len(obj) == 0)
+
+
+def determine_additional_sdv_enterprise_deps(
+    packages_before_install,
+    packages_after_install,
+    user_requested_packages,
+    all_sdv_enterprise_related_pkgs=EXPECTED_PACKAGES,
+):
+    """Determine the additional sdv-enterprise related packages installed, given before & after.
+
+    Args:
+        packages_before_install (set, list[str]):
+            All packages before installation with sdv-installer.
+
+        packages_after_install (set, list[str]):
+            All packages after installation with sdv-installer.
+
+        user_requested_packages (set, list[str], dict[str, str], str, None)
+            The user requested packages to install. If it is an itert
+
+        all_sdv_enterprise_related_pkgs (set, list[str])
+            The package names of all base packages and bundle packages
+            that could be installed by the user.
+            Defaults to EXPECTED_PACKAGES
+
+    Returns:
+        (set): The additional sdv-enterprise related packages that were installed.
+    """
+    if is_none_or_empty_iterate(user_requested_packages):
+        # User did not say a specific package to install
+        # Return empty list to specify no additional deps were installed (everything installed)
+        return {}
+
+    packages_before_install = convert_to_set(packages_before_install)
+    packages_after_install = convert_to_set(packages_after_install)
+
+    user_requested_packages = convert_to_set(user_requested_packages)
+    user_requested_packages = {get_requirement_name(pkg) for pkg in user_requested_packages}
+
+    all_sdv_enterprise_related_pkgs = convert_to_set(all_sdv_enterprise_related_pkgs)
+
+    all_installed_pkgs = packages_after_install.difference(packages_before_install)
+    installed_pkgs_related_to_sdv_enterprise = all_installed_pkgs.intersection(
+        all_sdv_enterprise_related_pkgs
+    )
+    additional_dependencies_installed = installed_pkgs_related_to_sdv_enterprise.difference(
+        user_requested_packages
+    )
+    return additional_dependencies_installed
+
+
+def check_is_sdv_enterprise_included(packages):
+    """Check if any of the given package names includes 'sdv-enterprise'.
+
+    Args:
+        packages (list of str):
+            A list of package names.
+
+    Returns:
+        bool:
+            True if 'sdv-enterprise' is found in any package name, False otherwise.
+    """
+    for package in packages:
+        if package.startswith(BASE_PREFIX):
+            return True
+
+    return False

sdv_installer/utils/request_error_handling.py

@@ -0,0 +1,53 @@
+"""Utility functions to handle requests HTTP errors."""
+
+
+class NotFoundError(ValueError):
+    """Error to be raised when an end point is not found (404)."""
+
+
+def handle_http_error_response(response):
+    """Handle HTTP error responses and raises appropriate exceptions with error messages.
+
+    The function attempts to parse the error details from the response as JSON. If the content
+    cannot be parsed as JSON, the raw response text will be used.
+
+    Args:
+        response (requests.Response):
+            The HTTP response object that contains the status code and error details.
+
+    Raises:
+        ValueError:
+            If the status code is 400 (Bad Request) or 422 (Validation Error).
+        PermissionError:
+            If the status code is 401 (Unauthorized) or 403 (Forbidden).
+        NotFoundError:
+            If the status code is 404 (Not Found).
+        RuntimeError:
+            If the status code is 405 (Method Not Allowed) or 5xx (Server Error).
+        Exception:
+            For any unexpected status code.
+    """
+    status = response.status_code
+    try:
+        error_detail = response.json()
+    except ValueError:
+        error_detail = response.text
+
+    error_map = {
+        400: (ValueError, f'Bad Request: {error_detail}'),
+        401: (PermissionError, f'Invalid Credentials or Expired License Key: {error_detail}.'),
+        403: (PermissionError, 'Forbidden: You don’t have permission to access this resource.'),
+        404: (NotFoundError, 'Not Found: The requested endpoint does not exist.'),
+        405: (RuntimeError, 'Method Not Allowed: Check the HTTP method.'),
+        422: (ValueError, f'Validation Error: {error_detail}'),
+    }
+
+    if status >= 500:
+        exception, message = RuntimeError, f'Server Error ({status}): {error_detail}'
+
+    else:
+        exception, message = error_map.get(
+            status, (Exception, f'Unexpected Error ({status}): {error_detail}')
+        )
+
+    raise exception(message)