rsconnect-python 1.31.0__tar.gz → 1.31.1__tar.gz

{rsconnect_python-1.31.0 → rsconnect_python-1.31.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rsconnect_python
-Version: 1.31.0
+Version: 1.31.1
 Summary: The Posit Connect command-line interface.
 Author: Posit, PBC
 Author-email: Posit, PBC <rsconnect@posit.co>

{rsconnect_python-1.31.0 → rsconnect_python-1.31.1}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "rsconnect_python"
 description = "The Posit Connect command-line interface."
 requires-python = ">=3.8"
-version = "1.31.0"
+version = "1.31.1"
 dependencies = [
     "typing-extensions>=4.8.0",
     "pip>=10.0.0",

{rsconnect_python-1.31.0 → rsconnect_python-1.31.1}/pyproject.toml.orig

@@ -2,7 +2,7 @@
 name = "rsconnect_python"
 description = "The Posit Connect command-line interface."
 requires-python = ">=3.8"
-version = "1.31.0"
+version = "1.31.1"
 dependencies = [ "typing-extensions>=4.8.0", "pip>=10.0.0", "uv>=0.9.0", "semver>=2.0.0,<4.0.0", "pyjwt>=2.4.0", "click>=8.0.0", "packaging>=20.0", "toml>=0.10; python_version < '3.11'",]
 [[project.authors]]
 name = "Posit, PBC"

{rsconnect_python-1.31.0 → rsconnect_python-1.31.1}/rsconnect/api.py

@@ -2165,16 +2165,15 @@ for shinyapps.io. See command help for further details."
             )
             upload_result = S3Server(upload_url).handle_bad_response(upload_result, is_httpresponse=True)
 
-    def primary_file_for_connect_cloud(self) -> str:
-        """The entrypoint to report to Connect Cloud, read from the built bundle.
+    def bundle_manifest(self) -> dict[str, Any]:
+        """The manifest of the built bundle.
 
-        Connect Cloud needs a `primary_file` and uses it to decide, for example,
-        whether Shiny content is R or Python. Every deploy path writes the
-        entrypoint into the bundle's manifest, so reading it back from there
-        avoids having to thread it separately through each command.
+        Every deploy path writes what Connect Cloud needs into the bundle's
+        manifest, so reading it back from there avoids having to thread the same
+        values separately through each command.
         """
         if self.bundle is None:
-            raise RSConnectException("A bundle must be created before determining the primary file.")
+            raise RSConnectException("A bundle must be created before reading its manifest.")
 
         position = self.bundle.tell()
         try:
@@ -2186,12 +2185,34 @@ for shinyapps.io. See command help for further details."
                 extracted = tar.extractfile(member) if member is not None else None
                 if extracted is None:
                     raise RSConnectException("The bundle does not contain a manifest.json.")
-                manifest = json.loads(extracted.read().decode("utf-8"))
+                return cast("dict[str, Any]", json.loads(extracted.read().decode("utf-8")))
         except (tarfile.TarError, KeyError, ValueError) as exc:
             raise RSConnectException("Could not read the bundle manifest: %s" % exc) from exc
         finally:
             self.bundle.seek(position)
 
+    def python_version_for_connect_cloud(self) -> Optional[str]:
+        """The MAJOR.MINOR Python version to ask Connect Cloud for, or None.
+
+        None means the request omits the field: a redeploy keeps the version already
+        set on the content, and a first deploy takes Connect Cloud's default. Content
+        with no Python at all lands here too.
+        """
+        manifest = self.bundle_manifest()
+        environment: dict[str, Any] = manifest.get("environment") or {}
+        requirement: dict[str, Any] = environment.get("python") or {}
+        interpreter: dict[str, Any] = manifest.get("python") or {}
+        requires: Optional[str] = requirement.get("requires")
+        local_version: Optional[str] = interpreter.get("version")
+        return connect_cloud.resolve_python_version(requires, local_version)
+
+    def primary_file_for_connect_cloud(self) -> str:
+        """The entrypoint to report to Connect Cloud, read from the built bundle.
+
+        Connect Cloud needs a `primary_file` and uses it to decide, for example,
+        whether Shiny content is R or Python.
+        """
+        manifest = self.bundle_manifest()
         metadata = manifest.get("metadata") or {}
         primary_file = metadata.get("entrypoint") or metadata.get("primary_rmd") or metadata.get("primary_html")
         files = manifest.get("files") or {}
@@ -2302,6 +2323,7 @@ for shinyapps.io. See command help for further details."
                     title=self.title,
                     app_mode=self.app_mode,
                     primary_file=self.primary_file_for_connect_cloud(),
+                    python_version=self.python_version_for_connect_cloud(),
                     env_vars=self.env_vars,
                     update_title=not self.title_is_default,
                     app_id_is_explicit=self.app_id_is_explicit,
@@ -3293,6 +3315,7 @@ class ConnectCloudAccountSearchResults(TypedDict):
 class ConnectCloudRevision(TypedDict):
     id: str
     content_id: NotRequired[str]
+    python_version: NotRequired[Optional[str]]
     status: NotRequired[str]
     source_bundle_upload_url: NotRequired[str]
     publish_result: NotRequired[Optional[str]]
@@ -3648,21 +3671,29 @@ class ConnectCloudClient(BearerTokenHTTPServer):
         primary_file: str,
         secrets: Optional[list[dict[str, str]]] = None,
         access: Optional[str] = None,
+        python_version: Optional[str] = None,
     ) -> ConnectCloudContent:
         """Create content to upload a bundle into.
 
         `access` is the content's visibility ("public" or "private"). Omitted from
         the request when None so the server picks its own default.
+
+        `python_version` is MAJOR.MINOR. Omitted when None, which is how content
+        with no Python is created; Connect Cloud then falls back to its own
+        default rather than reading the version out of the bundle's manifest.
         """
+        next_revision: dict[str, Any] = {
+            "source_type": "bundle",
+            "content_type": content_type,
+            "app_mode": app_mode,
+            "primary_file": primary_file,
+        }
+        if python_version is not None:
+            next_revision["python_version"] = python_version
         body: dict[str, Any] = {
             "account_id": account_id,
             "title": title,
-            "next_revision": {
-                "source_type": "bundle",
-                "content_type": content_type,
-                "app_mode": app_mode,
-                "primary_file": primary_file,
-            },
+            "next_revision": next_revision,
             "secrets": secrets or [],
         }
         if access is not None:
@@ -3680,6 +3711,7 @@ class ConnectCloudClient(BearerTokenHTTPServer):
         new_bundle: bool = True,
         title: Optional[str] = None,
         access: Optional[str] = None,
+        python_version: Optional[str] = None,
     ) -> ConnectCloudContent:
         """Update content, optionally minting a fresh revision to upload into.
 
@@ -3693,14 +3725,19 @@ class ConnectCloudClient(BearerTokenHTTPServer):
         deploy without -E/-t must leave the existing values alone. `access` (the
         content's visibility) is omitted the same way, so a redeploy without
         -V keeps whatever visibility the content already has.
+
+        `python_version` is omitted when None for the same reason: a redeploy of
+        content whose bundle carries no Python version keeps the version already
+        set on the content, including one chosen in the Connect Cloud UI.
         """
-        body: dict[str, Any] = {
-            "revision_overrides": {
-                "primary_file": primary_file,
-                "app_mode": app_mode,
-                "content_type": content_type,
-            },
+        revision_overrides: dict[str, Any] = {
+            "primary_file": primary_file,
+            "app_mode": app_mode,
+            "content_type": content_type,
         }
+        if python_version is not None:
+            revision_overrides["python_version"] = python_version
+        body: dict[str, Any] = {"revision_overrides": revision_overrides}
         if secrets is not None:
             body["secrets"] = secrets
         if title is not None:
@@ -3895,6 +3932,7 @@ class ConnectCloudService:
         update_title: bool = False,
         app_id_is_explicit: bool = False,
         visibility: Optional[str] = None,
+        python_version: Optional[str] = None,
     ) -> ConnectCloudDeployResult:
         """Create or fetch the content item and get a revision to upload into.
 
@@ -3961,6 +3999,7 @@ class ConnectCloudService:
                 content_type=content_type,
                 app_mode=app_mode.name(),
                 primary_file=primary_file,
+                python_version=python_version,
                 secrets=secrets,
                 access=visibility,
             )
@@ -3975,6 +4014,7 @@ class ConnectCloudService:
                 primary_file=primary_file,
                 app_mode=app_mode.name(),
                 content_type=content_type,
+                python_version=python_version,
                 secrets=secrets,
                 new_bundle=upload,
                 title=title if update_title and title else None,

{rsconnect_python-1.31.0 → rsconnect_python-1.31.1}/rsconnect/connect_cloud.py

@@ -12,7 +12,11 @@ import os
 from typing import Any, NamedTuple, Optional
 from urllib.parse import urlparse
 
+from packaging.specifiers import InvalidSpecifier, Specifier, SpecifierSet
+from packaging.version import InvalidVersion, Version
+
 from .exception import RSConnectException
+from .log import logger
 from .oauth import (
     ACCESS_TOKEN_FIELD,
     CLIENT_SECRET_FIELD,
@@ -313,3 +317,208 @@ def credentials_from_keyring(url: str, nickname: str) -> tuple[Optional[str], Op
 def delete_credentials_from_keyring(url: str, nickname: str) -> None:
     """Delete a saved credential's secrets from the system keyring."""
     keyring_delete_values(keyring_key(url, nickname), _CREDENTIAL_FIELDS)
+
+
+# The lowest MAJOR.MINOR Connect Cloud will accept for a revision's python_version
+# (the RequestPythonVersion enum in https://api.connect.posit.cloud/openapi.json).
+MINIMUM_PYTHON_VERSION = Version("3.9")
+
+# Tail of both warnings below. resolve_python_version runs before the deploy knows
+# whether the content already exists, so it has to name both outcomes.
+_VERSION_CHOSEN_BY_CONNECT_CLOUD = (
+    "The content will run on the Python version already set on it in Posit Connect "
+    "Cloud, or Connect Cloud's default if this is a first deployment."
+)
+
+# Operators that put a floor under the versions a clause admits. "<" and "<=" bound
+# only the top, and "!=" excludes a point, so neither says where the range starts.
+_LOWER_BOUND_OPERATORS = (">=", ">", "==", "===", "~=")
+
+
+def _clause_version(clause: Specifier) -> Optional[Version]:
+    """The version a single specifier clause names, or None if it cannot be parsed.
+
+    Strips the wildcard from "==3.11.*", which is not a version on its own.
+    """
+    try:
+        return Version(clause.version.rstrip("*").rstrip("."))
+    except InvalidVersion:
+        return None
+
+
+def _effective_floor(specifier: SpecifierSet) -> Optional[Version]:
+    """The lowest version the constraint admits, or None if it has no lower bound.
+
+    Clauses are ANDed, so the highest of their floors is the one that binds:
+    ">=3.9,==3.12.*" starts at 3.12, not 3.9.
+    """
+    floor = None
+    for clause in specifier:
+        if clause.operator not in _LOWER_BOUND_OPERATORS:
+            continue
+        version = _clause_version(clause)
+        if version is not None and (floor is None or version > floor):
+            floor = version
+    return floor
+
+
+# Connect Cloud accepts a MAJOR.MINOR line, such as "3.11", and chooses the patch
+# release. The helpers below determine whether a constraint permits none, some,
+# or all patch releases in that line.
+#
+# SpecifierSet can test only concrete versions, so we sample patch 0 and, for each
+# clause referring to the line, its named patch and the following patch. Between
+# these boundaries the result cannot change, making those samples sufficient.
+
+
+def _line_boundary_patches(minor: str, specifier: SpecifierSet) -> list[int]:
+    """The sample patches for a line. For "3.11" and ">3.11.5", [0, 5, 6]."""
+    line = Version(minor).release[:2]
+    patches = {0}
+    for clause in specifier:
+        version = _clause_version(clause)
+        if version is None:
+            continue
+        release = version.release
+        # Padded so a clause naming only a major, as ">4" does, is read against that
+        # major's first line rather than matching nothing.
+        clause_line = (release + (0, 0))[:2]
+        if clause_line != line:
+            continue
+        patch = release[2] if len(release) > 2 else 0
+        patches.update((patch, patch + 1))
+    return sorted(patches)
+
+
+def _line_permits_some_patch(minor: str, specifier: SpecifierSet) -> bool:
+    """Return whether `specifier` permits at least one patch release in `minor`.
+
+    `minor` is a MAJOR.MINOR line such as "3.11". For example, ">3.11.5,<3.12"
+    permits the 3.11 line, while "!=3.11.*" does not.
+    """
+    return any(Version("%s.%d" % (minor, patch)) in specifier for patch in _line_boundary_patches(minor, specifier))
+
+
+# How many minor lines above the constraint's floor to consider when the floor's own
+# line is excluded. Generous for any real requirement, and only there to stop a
+# pathological constraint scanning forever. This is a bound on our own search, not on
+# the versions Connect Cloud offers: it never rejects a version, it only gives up
+# looking for one.
+_LINE_SCAN_LIMIT = 20
+
+
+def _lowest_admitted_line(floor: Version, specifier: SpecifierSet) -> Optional[str]:
+    """The lowest MAJOR.MINOR at or above `floor` that the constraint admits.
+
+    Usually the floor's own line. It is not when an exclusion empties that line, as
+    ">=3.9,!=3.9.*" does, which means 3.10 and is the reason this scans rather than
+    testing the floor alone.
+    """
+    release = floor.release
+    # A floor naming only a major version, as ">=4" does, starts at that major's
+    # first line.
+    major, minor = release[0], release[1] if len(release) > 1 else 0
+    for offset in range(_LINE_SCAN_LIMIT + 1):
+        candidate = "%d.%d" % (major, minor + offset)
+        if _line_permits_some_patch(candidate, specifier):
+            return candidate
+    return None
+
+
+def _minor_version(version: Version) -> Optional[str]:
+    """A version as the MAJOR.MINOR string Connect Cloud names its interpreters by.
+
+    None when the version names no minor, as "==3.*" does: there is no single line
+    to ask for.
+    """
+    if len(version.release) < 2:
+        return None
+    return "%d.%d" % (version.release[0], version.release[1])
+
+
+def _parsed(version: str) -> Optional[Version]:
+    try:
+        return Version(version)
+    except InvalidVersion:
+        return None
+
+
+def _log_requested(minor: str) -> str:
+    """Log the version being asked for and return it.
+
+    Said on every deploy, and names the patch as Connect Cloud's choice. A patch the
+    user asked for is already gone by the time it reaches here -- adapt_python_requires
+    turns a .python-version of "3.11.5" into "~=3.11.0" -- so this line is the only
+    place they see that it was not honored.
+    """
+    logger.info("Requesting Python %s from Posit Connect Cloud, which chooses the patch release." % minor)
+    return minor
+
+
+def resolve_python_version(requires: Optional[str], local_version: Optional[str]) -> Optional[str]:
+    """Pick the Connect Cloud Python version for a deploy.
+
+    `requires` is the PEP 440 constraint from the manifest's
+    ``environment.python.requires``; `local_version` is the interpreter the
+    bundle was built against, from ``python.version``. Returns None when there is
+    nothing usable to send, which leaves the field off the request: a redeploy then
+    keeps the version already set on the content, and a first deploy takes Connect
+    Cloud's default.
+
+    The interpreter the content was built against wins when the constraint allows
+    it. Otherwise the lowest version the constraint admits is used.
+
+    Availability is not checked here: an unrecognized version is sent and Connect
+    Cloud rules on it. A version below the lowest Connect Cloud offers is the
+    exception, and is not sent at all.
+
+    Connect Cloud picks the patch itself, so a constraint that names one ("==3.11.14")
+    can only be honored as far as its minor line.
+    """
+    specifier = None
+    if requires:
+        try:
+            specifier = SpecifierSet(requires)
+        except InvalidSpecifier:
+            logger.warning(
+                "Ignoring the manifest's Python version requirement, which is not a valid "
+                "PEP 440 constraint: %s" % requires
+            )
+
+    local = _parsed(local_version) if local_version else None
+    if local is not None and (specifier is None or local in specifier):
+        minor = _minor_version(local)
+        if minor is not None and Version(minor) >= MINIMUM_PYTHON_VERSION:
+            return _log_requested(minor)
+        # rsconnect runs on Pythons older than Connect Cloud offers. Without a
+        # requirement there is nothing else to go on, so let the platform choose;
+        # with one, the search below may still find a version it does offer.
+        if specifier is None:
+            if minor is None:
+                logger.warning(
+                    'The manifest\'s Python version "%s" does not name a minor version to ask Posit '
+                    "Connect Cloud for. %s" % (local_version, _VERSION_CHOSEN_BY_CONNECT_CLOUD)
+                )
+            else:
+                logger.warning(
+                    "Posit Connect Cloud does not offer Python %s. %s" % (minor, _VERSION_CHOSEN_BY_CONNECT_CLOUD)
+                )
+            return None
+
+    if specifier is None:
+        return None
+
+    # Search from the requirement's lowest version or Connect Cloud's, whichever is
+    # higher, so the result is one Connect Cloud can actually run: ">=3.8" is met by
+    # every version it offers and resolves to 3.9. A requirement with no lower bound,
+    # or one naming only a major version, starts at Connect Cloud's lowest.
+    floor = _effective_floor(specifier)
+    start = max(floor, MINIMUM_PYTHON_VERSION) if floor is not None else MINIMUM_PYTHON_VERSION
+    minor = _lowest_admitted_line(start, specifier)
+    if minor is None:
+        logger.warning(
+            "No Python version Posit Connect Cloud offers satisfies the requirement %s, so it "
+            "will not be met. %s" % (requires, _VERSION_CHOSEN_BY_CONNECT_CLOUD)
+        )
+        return None
+    return _log_requested(minor)