work in progress

Author: amol-

rsconnect/actions.py

@@ -37,7 +37,7 @@
     make_quarto_source_bundle,
     read_manifest_file,
 )
-from .environment import Environment, EnvironmentException
+from .environment import Environment
 from .exception import RSConnectException
 from .log import VERBOSE, logger
 from .models import AppMode, AppModes
@@ -78,8 +78,6 @@ def failed(err: str):
         passed()
     except RSConnectException as exc:
         failed("Error: " + exc.message)
-    except EnvironmentException as exc:
-        failed("Error: " + str(exc))
     except Exception as exc:
         traceback.print_exc()
         failed("Internal error: " + str(exc))

rsconnect/bundle.py

@@ -53,7 +53,8 @@
 
 import click
 
-from .environment import Environment, MakeEnvironment
+from . import pyproject
+from .environment import Environment
 from .exception import RSConnectException
 from .log import VERBOSE, logger
 from .models import AppMode, AppModes, GlobSet
@@ -1669,6 +1670,22 @@ def _warn_on_ignored_requirements(directory: str, requirements_file_name: str) -
         )
 
 
+def _warn_on_missing_python_version(version_constraint: Optional[str]) -> None:
+    """
+    Check that the project has a Python version constraint requested.
+    If it doesn't warn the user that it should be specified.
+
+    :param version_constraint: the version constraint in the project.
+    """
+    if version_constraint is None:
+        click.secho(
+            "    Warning: Python version constraint missing from pyproject.toml or .python-version\n"
+            "             Connect will guess the version to use based on local environment.\n"
+            "             Consider specifying a Python version constraint.",
+            fg="yellow",
+        )
+
+
 def fake_module_file_from_directory(directory: str) -> str:
     """
     Takes a directory and invents a properly named file that though possibly fake,
@@ -1717,7 +1734,7 @@ def inspect_environment(
     if force_generate:
         flags.append("f")
 
-    args = [python, "-m", "rsconnect.environment"]
+    args = [python, "-m", "rsconnect.subprocesses.environment"]
     if flags:
         args.append("-" + "".join(flags))
     args.append(directory)
@@ -1732,20 +1749,23 @@ def inspect_environment(
     except json.JSONDecodeError as e:
         raise RSConnectException("Error parsing environment JSON") from e
 
-    try:
-        return MakeEnvironment(**environment_data)
-    except TypeError as e:
+    if "error" in environment_data:
         system_error_message = environment_data.get("error")
         if system_error_message:
             raise RSConnectException(f"Error creating environment: {system_error_message}") from e
+
+    try:
+        return Environment.from_json(environment_data)
+    except TypeError as e:
         raise RSConnectException("Error constructing environment object") from e
 
 
-def get_python_env_info(
+def _get_python_env_info(
     file_name: str,
     python: str | None,
     force_generate: bool = False,
     override_python_version: str | None = None,
+    python_version_requirement: str | None = None,
 ) -> tuple[str, Environment]:
     """
     Gathers the python and environment information relating to the specified file
@@ -1766,8 +1786,11 @@ def get_python_env_info(
     logger.debug("Python: %s" % python)
     logger.debug("Environment: %s" % pformat(environment._asdict()))
 
+    if python_version_requirement:
+        environment.python_version_requirement = python_version_requirement
+
     if override_python_version:
-        environment = environment._replace(python=override_python_version)
+        environment = environment.python = override_python_version
 
     return python, environment
 
@@ -2261,17 +2284,29 @@ def create_python_environment(
     force_generate: bool = False,
     python: Optional[str] = None,
     override_python_version: Optional[str] = None,
+    app_file: Optional[str] = None,
 ) -> Environment:
-    module_file = fake_module_file_from_directory(directory)
+    if app_file is None:
+        module_file = fake_module_file_from_directory(directory)
+    else:
+        module_file = app_file
 
     # click.secho('    Deploying %s to server "%s"' % (directory, connect_server.url))
-
     _warn_on_ignored_manifest(directory)
     _warn_if_no_requirements_file(directory)
     _warn_if_environment_directory(directory)
 
+    python_version_requirement = pyproject.detect_python_version_requirement(directory)
+    _warn_on_missing_python_version(python_version_requirement)
+
+    if override_python_version:
+        # TODO: --override-python-version should be deprecated in the future
+        #       and instead we should suggest the user sets it in .python-version
+        #       or pyproject.toml
+        python_version_requirement = override_python_version
+
     # with cli_feedback("Inspecting Python environment"):
-    _, environment = get_python_env_info(module_file, python, force_generate, override_python_version)
+    _, environment = _get_python_env_info(module_file, python, force_generate, override_python_version)
 
     if force_generate:
         _warn_on_ignored_requirements(directory, environment.filename)

rsconnect/environment.py

@@ -1,233 +1,35 @@
-#!/usr/bin/env python
-"""
-Environment data class abstraction that is usable as an executable module
+import typing
+import dataclasses
 
-```bash
-python -m rsconnect.environment
-```
-"""
-from __future__ import annotations
+from .subprocesses.environment import EnvironmentData, MakeEnvironmentData as _MakeEnvironmentData
 
-import datetime
-import json
-import locale
-import os
-import re
-import subprocess
-import sys
-from dataclasses import asdict, dataclass, replace
-from typing import Callable, Optional
 
-version_re = re.compile(r"\d+\.\d+(\.\d+)?")
-exec_dir = os.path.dirname(sys.executable)
-
-
-@dataclass(frozen=True)
 class Environment:
-    contents: str
-    filename: str
-    locale: str
-    package_manager: str
-    pip: str
-    python: str
-    source: str
-    error: str | None
-
-    def _asdict(self):
-        return asdict(self)
-
-    def _replace(self, **kwargs: object):
-        return replace(self, **kwargs)
-
-
-def MakeEnvironment(
-    contents: str,
-    filename: str,
-    locale: str,
-    package_manager: str,
-    pip: str,
-    python: str,
-    source: str,
-    error: Optional[str] = None,
-    **kwargs: object,  # provides compatibility where we no longer support some older properties
-) -> Environment:
-    return Environment(contents, filename, locale, package_manager, pip, python, source, error)
-
-
-class EnvironmentException(Exception):
-    pass
-
-
-def detect_environment(dirname: str, force_generate: bool = False) -> Environment:
-    """Determine the python dependencies in the environment.
-
-    `pip freeze` will be used to introspect the environment.
-
-    :param: dirname Directory name
-    :param: force_generate Force the generation of an environment
-    :return: a dictionary containing the package spec filename and contents if successful,
-    or a dictionary containing `error` on failure.
-    """
-
-    if force_generate:
-        result = pip_freeze()
-    else:
-        result = output_file(dirname, "requirements.txt", "pip") or pip_freeze()
-
-    if result is not None:
-        result["python"] = get_python_version()
-        result["pip"] = get_version("pip")
-        result["locale"] = get_default_locale()
-
-    return MakeEnvironment(**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.
+    """A project environment,
 
-    Returns a dictionary containing the filename and contents
-    if successful, None if the file does not exist,
-    or a dictionary containing 'error' on failure.
+    The data is loaded from a rsconnect.utils.environment json response
     """
-    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 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:
-        if len(sys.argv) < 2:
-            raise EnvironmentException("Usage: %s [-fc] DIRECTORY" % sys.argv[0])
-        # directory is always the last argument
-        directory = sys.argv[len(sys.argv) - 1]
-        flags = ""
-        force_generate = False
-        if len(sys.argv) > 2:
-            flags = sys.argv[1]
-        if "f" in flags:
-            force_generate = True
-        envinfo = detect_environment(directory, force_generate)._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()
+    def __init__(self, data: EnvironmentData, python_version_requirement: typing.Optional[str] = None):
+        self._data = data
+        self._data_fields = dataclasses.fields(self.data)
+
+        # Fields that are not loaded from the environment subprocess
+        self.python_version_requirement
+
+    def __getattr__(self, name: str) -> typing.Any:
+        # We directly proxy the attributes of the EnvironmentData object
+        # so that schema changes can be handled in EnvironmentData exclusively.
+        return self._data[name]
+
+    def __setattr__(self, name, value):
+        if name in self._data_fields:
+            # proxy the attribute to the underlying EnvironmentData object
+            self._data._replace(name=value)
+        else:
+            super().__setattr__(name, value)
+
+    @classmethod
+    def from_json(cls, json_data: dict) -> "Environment":
+        """Create an Environment instance from the JSON representation of EnvironmentData."""
+        return cls(_MakeEnvironmentData(**json_data))