rsconnect-python 1.30.0__py3-none-any.whl

rsconnect/subprocesses/inspect_environment.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python
+"""
+Environment data class abstraction that is usable as an executable module
+
+```bash
+python -m rsconnect.subprocesses.inspect_environment
+```
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime
+import json
+import locale
+import os
+import tempfile
+import re
+import subprocess
+import sys
+from dataclasses import asdict, dataclass, replace
+from typing import Callable, Optional
+
+try:
+    import tomllib
+except ImportError:
+    # Python <3.11 doesn't have tomllib in the standard library
+    import toml as tomllib  # type: ignore[no-redef]
+
+version_re = re.compile(r"\d+\.\d+(\.\d+)?")
+exec_dir = os.path.dirname(sys.executable)
+
+
+@dataclass(frozen=True)
+class EnvironmentData:
+    contents: str
+    filename: str
+    locale: str
+    package_manager: str
+    pip: str
+    python: str
+    source: str
+    python_requires: Optional[str]
+    error: Optional[str]
+
+    def _asdict(self):
+        return asdict(self)
+
+    def _replace(self, **kwargs: object):
+        return replace(self, **kwargs)
+
+
+def MakeEnvironmentData(
+    contents: str,
+    filename: str,
+    locale: str,
+    package_manager: str,
+    pip: str,
+    python: str,
+    source: str,
+    python_requires: Optional[str] = None,
+    error: Optional[str] = None,
+    **kwargs: object,  # provides compatibility where we no longer support some older properties
+) -> EnvironmentData:
+    return EnvironmentData(contents, filename, locale, package_manager, pip, python, source, python_requires, error)
+
+
+class EnvironmentException(Exception):
+    pass
+
+
+def detect_environment(dirname: str, requirements_file: Optional[str] = "requirements.txt") -> EnvironmentData:
+    """Determine the python dependencies in the environment.
+
+    `pip freeze` will be used to introspect the environment.
+
+    :param: dirname Directory name
+    :param: requirements_file The requirements file to read. If None, generate using pip freeze.
+    :return: a dictionary containing the package spec filename and contents if successful,
+    or a dictionary containing `error` on failure.
+    """
+
+    if requirements_file is None:
+        # --force-generate sets requirements_file to None
+        result = pip_freeze()
+    elif os.path.basename(requirements_file) == "uv.lock":
+        result = uv_export(dirname, requirements_file)
+    elif os.path.basename(requirements_file) == "pyproject.toml":
+        result = pyproject_dependencies(dirname, requirements_file)
+    else:
+        result = output_file(dirname, requirements_file, "pip")
+        if result is None:
+            raise EnvironmentException(
+                "The requirements file '%s' was not found in '%s'. "
+                "Please create it or use --force-generate to use pip freeze." % (requirements_file, dirname)
+            )
+
+    if result is not None:
+        result["python"] = get_python_version()
+        result["pip"] = get_version("pip")
+        result["locale"] = get_default_locale()
+
+    return MakeEnvironmentData(**result)
+
+
+def get_python_version() -> str:
+    v = sys.version_info
+    return "%d.%d.%d" % (v[0], v[1], v[2])
+
+
+def get_default_locale(locale_source: Callable[..., tuple[str | None, str | None]] = locale.getlocale):
+    result = ".".join([item or "" for item in locale_source()])
+    return "" if result == "." else result
+
+
+def get_version(module: str):
+    try:
+        args = [sys.executable, "-m", module, "--version"]
+        proc = subprocess.Popen(
+            args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+        )
+        stdout, _stderr = proc.communicate()
+        match = version_re.search(stdout)
+        if match:
+            return match.group()
+
+        msg = "Failed to get version of '%s' from the output of: %s" % (
+            module,
+            " ".join(args),
+        )
+        raise EnvironmentException(msg)
+    except Exception as exception:
+        raise EnvironmentException("Error getting '%s' version: %s" % (module, str(exception)))
+
+
+def output_file(dirname: str, filename: str, package_manager: str):
+    """Read an existing package spec file.
+
+    Returns a dictionary containing the filename and contents
+    if successful, None if the file does not exist,
+    or a dictionary containing 'error' on failure.
+    """
+    try:
+        path = os.path.join(dirname, filename)
+        if not os.path.exists(path):
+            return None
+
+        with open(path, "r") as f:
+            data = f.read()
+
+        data = "\n".join([line for line in data.split("\n") if "rsconnect" not in line])
+
+        return {
+            "filename": filename,
+            "contents": data,
+            "source": "file",
+            "package_manager": package_manager,
+        }
+    except Exception as exception:
+        raise EnvironmentException("Error reading %s: %s" % (filename, str(exception)))
+
+
+def pip_freeze():
+    """Inspect the environment using `pip freeze --disable-pip-version-check version`.
+
+    Returns a dictionary containing the filename
+    (always 'requirements.txt') and contents if successful,
+    or a dictionary containing 'error' on failure.
+    """
+    try:
+        proc = subprocess.Popen(
+            [sys.executable, "-m", "pip", "freeze", "--disable-pip-version-check"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+        )
+
+        pip_stdout, pip_stderr = proc.communicate()
+        pip_status = proc.returncode
+    except Exception as exception:
+        raise EnvironmentException("Error during pip freeze: %s" % str(exception))
+
+    if pip_status != 0:
+        msg = pip_stderr or ("exited with code %d" % pip_status)
+        raise EnvironmentException("Error during pip freeze: %s" % msg)
+
+    pip_stdout = filter_pip_freeze_output(pip_stdout)
+
+    pip_stdout = (
+        "# requirements.txt generated by rsconnect-python on "
+        + str(datetime.datetime.now(datetime.timezone.utc))
+        + "\n"
+        + pip_stdout
+    )
+
+    return {
+        "filename": "requirements.txt",
+        "contents": pip_stdout,
+        "source": "pip_freeze",
+        "package_manager": "pip",
+    }
+
+
+def uv_export(dirname: str, lock_filename: str):
+    """
+    Export requirements from a uv.lock file using `uv export`.
+    """
+    lock_path = lock_filename
+    if not os.path.isabs(lock_filename):
+        lock_path = os.path.join(dirname, lock_filename)
+
+    if not os.path.exists(lock_path):
+        raise EnvironmentException("uv.lock not found: %s" % lock_filename)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        output_path = os.path.join(tmpdir, "requirements.txt.lock")
+        try:
+            result = subprocess.run(
+                [
+                    "uv",
+                    "export",
+                    "--format",
+                    "requirements-txt",
+                    "--frozen",
+                    "--no-hashes",
+                    "--no-annotate",
+                    "--offline",
+                    "--no-header",
+                    "--no-emit-project",
+                    "--output-file",
+                    output_path,
+                ],
+                cwd=os.path.dirname(lock_path),
+                stdout=sys.stderr,
+                stderr=sys.stderr,
+                check=False,
+            )
+        except Exception as exception:
+            raise EnvironmentException("Error during uv export: %s" % str(exception))
+
+        if result.returncode != 0:
+            raise EnvironmentException("Error during uv export: exited with code %d" % result.returncode)
+
+        with open(output_path, mode="r", encoding="utf-8") as output_file:
+            exported = output_file.read()
+
+    requirements = filter_pip_freeze_output(exported)
+    requirements = (
+        "# requirements.txt.lock generated from uv.lock by rsconnect-python on "
+        + str(datetime.datetime.now(datetime.timezone.utc))
+        + "\n"
+        + requirements
+    )
+
+    return {
+        "filename": "requirements.txt.lock",
+        "contents": requirements,
+        "source": "uv_lock",
+        "package_manager": "uv",
+        "pip": None,
+    }
+
+
+def pyproject_dependencies(dirname: str, pyproject_filename: str):
+    """Read project.dependencies from a pyproject.toml file as a requirements spec.
+
+    Emits a requirements.txt file listing the top-level dependencies declared
+    in ``[project].dependencies``. Unlike ``uv.lock``, the result is not a
+    fully resolved lock and Connect will perform dependency resolution at
+    deploy time.
+    """
+    pyproject_path = pyproject_filename
+    if not os.path.isabs(pyproject_filename):
+        pyproject_path = os.path.join(dirname, pyproject_filename)
+
+    if not os.path.exists(pyproject_path):
+        raise EnvironmentException(f"pyproject.toml not found: {pyproject_filename}")
+
+    try:
+        with open(pyproject_path, "r", encoding="utf-8") as f:
+            pyproject = tomllib.loads(f.read())
+    except Exception as exception:
+        raise EnvironmentException(f"Error reading {pyproject_filename}: {exception}")
+
+    project = pyproject.get("project", {})
+    dependencies: list[object] = project.get("dependencies", [])
+    if not isinstance(dependencies, list):
+        raise EnvironmentException(f"Invalid project.dependencies in {pyproject_filename}: expected a list of strings.")
+
+    requirements = filter_pip_freeze_output("\n".join(str(dep) for dep in dependencies))
+    requirements = (
+        f"# requirements.txt generated from pyproject.toml by rsconnect-python on "
+        f"{datetime.datetime.now(datetime.timezone.utc)}\n"
+        f"{requirements}"
+    )
+
+    return {
+        "filename": "requirements.txt",
+        "contents": requirements,
+        "source": "pyproject_toml",
+        "package_manager": "pip",
+    }
+
+
+def filter_pip_freeze_output(pip_stdout: str):
+    # Filter out dependency on `rsconnect` and ignore output lines from pip which start with `[notice]`
+    return "\n".join(
+        [line for line in pip_stdout.split("\n") if (("rsconnect" not in line) and (line.find("[notice]") != 0))]
+    )
+
+
+def strip_ref(line: str):
+    # remove erroneous conda build paths that will break pip install
+    return line.split(" @ file:", 1)[0].strip()
+
+
+def exclude(line: str):
+    return line and line.startswith("setuptools") and "post" in line
+
+
+def main():
+    """
+    Run `detect_environment` and dump the result as JSON.
+    """
+    try:
+        parser = argparse.ArgumentParser(
+            description="Inspect python environment and return dependency metadata.", add_help=True
+        )
+        parser.add_argument(
+            "-r",
+            "--requirements-file",
+            dest="requirements_file",
+            default="requirements.txt",
+            help="Requirements file name (relative to the directory). Use 'none' to capture via pip freeze.",
+        )
+        parser.add_argument("directory", help="Directory to inspect.")
+        args = parser.parse_args()
+
+        requirements_file = args.requirements_file
+        if requirements_file.lower() == "none":
+            requirements_file = None
+
+        envinfo = detect_environment(args.directory, requirements_file=requirements_file)._asdict()
+        if "contents" in envinfo:
+            keepers = list(map(strip_ref, envinfo["contents"].split("\n")))
+            keepers = [line for line in keepers if not exclude(line)]
+            envinfo["contents"] = "\n".join(keepers)
+
+        json.dump(
+            envinfo,
+            sys.stdout,
+            indent=4,
+        )
+    except EnvironmentException as exception:
+        json.dump(dict(error=str(exception)), sys.stdout, indent=4)
+
+
+if __name__ == "__main__":
+    main()

rsconnect/timeouts.py

@@ -0,0 +1,89 @@
+import os
+import textwrap
+
+from typing import Union
+
+from rsconnect.exception import RSConnectException
+
+_CONNECT_REQUEST_TIMEOUT_KEY: str = "CONNECT_REQUEST_TIMEOUT"
+_CONNECT_REQUEST_TIMEOUT_DEFAULT_VALUE: str = "300"
+
+_CONNECT_TASK_TIMEOUT_KEY: str = "CONNECT_TASK_TIMEOUT"
+_CONNECT_TASK_TIMEOUT_DEFAULT_VALUE: str = "86400"
+
+
+def get_request_timeout() -> int:
+    """Gets the timeout from the CONNECT_REQUEST_TIMEOUT env variable.
+
+    The timeout value is intended to be interpreted in seconds. A value of 60 is equal to sixty seconds, or one minute.
+
+    If CONNECT_REQUEST_TIMEOUT is unset, a default value of 300 is used.
+
+    If CONNECT_REQUEST_TIMEOUT is set to a value less than 0, an `RSConnectException` is raised.
+
+    A CONNECT_REQUEST_TIMEOUT set to 0 is logically equivalent to no timeout.
+
+    The primary intent for this method is for usage with the `http` module. Specifically, for setting the timeout
+    parameter with an `http.client.HTTPConnection` or `http.client.HTTPSConnection`.
+
+    :raises: `RSConnectException` if CONNECT_REQUEST_TIMEOUT is not a natural number.
+    :return: the timeout value
+    """
+    timeout: Union[int, str] = os.environ.get(_CONNECT_REQUEST_TIMEOUT_KEY, _CONNECT_REQUEST_TIMEOUT_DEFAULT_VALUE)
+
+    try:
+        timeout = int(timeout)
+    except ValueError:
+        raise RSConnectException(
+            f"'CONNECT_REQUEST_TIMEOUT' is set to '{timeout}'. The value must be a non-negative integer."
+        )
+
+    if timeout < 0:
+        raise RSConnectException(
+            f"'CONNECT_REQUEST_TIMEOUT' is set to '{timeout}'. The value must be a non-negative integer."
+        )
+
+    return timeout
+
+
+def get_task_timeout() -> int:
+    """Gets the timeout from the CONNECT_TASK_TIMEOUT env variable.
+
+    The timeout value is intended to be interpreted in seconds. A value of 60 is equal to sixty seconds, or one minute.
+
+    If CONNECT_TASK_TIMEOUT is unset, a default value of 86,400 (1 day) is used.
+
+    If CONNECT_TASK_TIMEOUT is set to a value less or equal to 0, an `RSConnectException` is raised.
+
+    The primary intent for this method is for usage with the `api` module. Specifically, for setting the timeout
+    parameter in the method `wait_for_task`.
+
+    :raises: `RSConnectException` if CONNECT_TASK_TIMEOUT is not a positive integer.
+    :return: the timeout value
+    """
+    timeout: Union[int, str] = os.environ.get(_CONNECT_TASK_TIMEOUT_KEY, _CONNECT_TASK_TIMEOUT_DEFAULT_VALUE)
+
+    try:
+        timeout = int(timeout)
+    except ValueError:
+        raise RSConnectException(f"'CONNECT_TASK_TIMEOUT' is set to '{timeout}'. The value must be a positive integer.")
+
+    if timeout <= 0:
+        raise RSConnectException(f"'CONNECT_TASK_TIMEOUT' is set to '{timeout}'. The value must be a positive integer.")
+
+    return timeout
+
+
+def get_task_timeout_help_message(timeout: int = get_task_timeout()) -> str:
+    """Gets a human friendly help message for adjusting the task timeout value."""
+
+    return f"The task timed out after {timeout} seconds." + textwrap.dedent(
+        f"""
+
+        You may try increasing the task timeout value using the {_CONNECT_TASK_TIMEOUT_KEY} environment variable. The default value is {_CONNECT_TASK_TIMEOUT_DEFAULT_VALUE} seconds. The current value is {get_task_timeout()} seconds.
+
+        Example:
+
+            CONNECT_TASK_TIMEOUT={_CONNECT_TASK_TIMEOUT_DEFAULT_VALUE} rsconnect deploy api --server <your-server> --api-key <your-api-key> ./
+        """  # noqa: E501
+    )