python-package-folder 5.1.5__tar.gz → 5.2.0__tar.gz

{python_package_folder-5.1.5 → python_package_folder-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 5.1.5
+Version: 5.2.0
 Summary: Python package to automatically package and build a folder, fetching all relevant dependencies.
 Project-URL: Repository, https://github.com/alelom/python-package-folder
 Author-email: Alessio Lombardi <work@alelom.com>

{python_package_folder-5.1.5 → python_package_folder-5.2.0}/pyproject.toml

@@ -43,7 +43,7 @@ dependencies = [
 
 # ---- Dev dependencies ----
 
-version = "5.1.5"
+version = "5.2.0"
 [dependency-groups]
 dev = [
     "pytest>=8.3.5",

{python_package_folder-5.1.5 → python_package_folder-5.2.0}/src/python_package_folder/publisher.py

@@ -8,6 +8,7 @@ repositories including PyPI, PyPI Test, and Azure Artifacts.
 from __future__ import annotations
 
 import getpass
+import os
 import subprocess
 import sys
 from enum import Enum
@@ -19,6 +20,18 @@ except ImportError:
     keyring = None
 
 
+def _is_non_interactive() -> bool:
+    """Check if running in a non-interactive environment (CI/CD)."""
+    # Check for common CI environment variables
+    ci_vars = ["GITHUB_ACTIONS", "CI", "CONTINUOUS_INTEGRATION", "TF_BUILD"]
+    if any(os.getenv(var) for var in ci_vars):
+        return True
+    # Check if stdin is not a TTY (non-interactive)
+    if not sys.stdin.isatty():
+        return True
+    return False
+
+
 class Repository(Enum):
     """
     Supported package repositories.
@@ -112,9 +125,9 @@ class Publisher:
         """
         Get credentials for publishing.
 
-        Always prompts for username and password/token if not already provided.
-        Does not use keyring to store/retrieve credentials - credentials must be
-        provided via command-line arguments or will be prompted each time.
+        Prompts for username and password/token if not already provided.
+        In non-interactive environments (CI/CD), checks environment variables
+        or raises an error if credentials are missing.
 
         Returns:
             Tuple of (username, password/token)
@@ -122,21 +135,54 @@ class Publisher:
         username = self.username
         password = self.password
 
-        # Always prompt if not provided via command-line arguments
-        # We don't use keyring to avoid storing credentials
+        is_non_interactive_env = _is_non_interactive()
+
+        # Get username
         if not username:
-            username = input(f"Enter username for {self.repository.value}: ").strip()
-            if not username:
-                raise ValueError("Username is required")
+            if is_non_interactive_env:
+                # Check environment variables
+                username = os.getenv("TWINE_USERNAME") or os.getenv("PYPI_USERNAME")
+                if not username:
+                    raise ValueError(
+                        f"Username is required for publishing to {self.repository.value} in CI/CD. "
+                        "Please provide --username argument or set TWINE_USERNAME/PYPI_USERNAME environment variable."
+                    )
+            else:
+                username = input(f"Enter username for {self.repository.value}: ").strip()
+                if not username:
+                    raise ValueError("Username is required")
 
+        # Get password
         if not password:
-            if self.repository == Repository.AZURE:
-                prompt = f"Enter Azure Artifacts token for {username}: "
+            if is_non_interactive_env:
+                # Check environment variables (common names used by twine and CI/CD)
+                password = (
+                    os.getenv("TWINE_PASSWORD")
+                    or os.getenv("PYPI_PASSWORD")
+                    or os.getenv("AZURE_ARTIFACTS_TOKEN")  # For Azure
+                )
+                if not password:
+                    raise ValueError(
+                        f"Password/token is required for publishing to {self.repository.value} in CI/CD. "
+                        "Please provide --password argument or set one of: "
+                        "TWINE_PASSWORD, PYPI_PASSWORD, or AZURE_ARTIFACTS_TOKEN environment variable."
+                    )
             else:
-                prompt = f"Enter PyPI token for {username} (or __token__ for API token): "
-            password = getpass.getpass(prompt)
-            if not password:
-                raise ValueError("Password/token is required")
+                if self.repository == Repository.AZURE:
+                    prompt = f"Enter Azure Artifacts token for {username}: "
+                else:
+                    prompt = f"Enter PyPI token for {username} (or __token__ for API token): "
+                try:
+                    password = getpass.getpass(prompt)
+                except (EOFError, OSError):
+                    # Handle non-interactive environments gracefully
+                    raise ValueError(
+                        f"Password/token is required for publishing to {self.repository.value}. "
+                        "Cannot prompt for password in non-interactive environment. "
+                        "Please provide --password argument or set TWINE_PASSWORD/PYPI_PASSWORD environment variable."
+                    )
+                if not password:
+                    raise ValueError("Password/token is required")
 
         # Auto-detect if password is an API token and adjust username
         if password.startswith("pypi-") or password.startswith("pypi_Ag"):

{python_package_folder-5.1.5 → python_package_folder-5.2.0}/src/python_package_folder/version_calculator.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import logging
 import re
 import subprocess
+from html.parser import HTMLParser
 from pathlib import Path
 
 import requests
@@ -110,6 +111,68 @@ def _query_pypi_version(package_name: str, registry: str) -> str | None:
         return None
 
 
+class SimpleIndexParser(HTMLParser):
+    """Parser for PEP 503 simple index HTML to extract package versions."""
+    
+    def __init__(self, package_name: str):
+        super().__init__()
+        self.package_name = package_name
+        self.versions: set[str] = set()
+        self.in_anchor = False
+        self.current_href = ""
+    
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag == "a":
+            self.in_anchor = True
+            # Extract href attribute
+            for attr_name, attr_value in attrs:
+                if attr_name == "href" and attr_value:
+                    self.current_href = attr_value
+                    break
+    
+    def handle_data(self, data: str) -> None:
+        if self.in_anchor:
+            # Extract version from link text or href
+            # Format: package-name-version-... or package-name-version.tar.gz
+            version = self._extract_version_from_filename(data.strip())
+            if version:
+                self.versions.add(version)
+            # Also check href if it contains version info
+            if self.current_href:
+                version = self._extract_version_from_filename(self.current_href)
+                if version:
+                    self.versions.add(version)
+    
+    def handle_endtag(self, tag: str) -> None:
+        if tag == "a":
+            self.in_anchor = False
+            self.current_href = ""
+    
+    def _extract_version_from_filename(self, filename: str) -> str | None:
+        """Extract version number from package filename."""
+        # Pattern: package-name-version-... or package-name-version.tar.gz
+        # Examples: data-0.1.0-py3-none-any.whl, data-0.1.0.tar.gz
+        # The version is between the package name and the next separator
+        
+        # Normalize package name (replace - with _ for matching)
+        normalized_package = self.package_name.replace("-", "_").replace(".", "_")
+        
+        # Try to match: package-name-version- or package-name-version.
+        # Version format: X.Y.Z (semantic versioning)
+        pattern = rf"{re.escape(self.package_name)}-(\d+\.\d+\.\d+(?:\.\d+)?(?:[a-zA-Z0-9]+)?)"
+        match = re.search(pattern, filename, re.IGNORECASE)
+        if match:
+            return match.group(1)
+        
+        # Fallback: try with normalized package name
+        pattern = rf"{re.escape(normalized_package)}-(\d+\.\d+\.\d+(?:\.\d+)?(?:[a-zA-Z0-9]+)?)"
+        match = re.search(pattern, filename, re.IGNORECASE)
+        if match:
+            return match.group(1)
+        
+        return None
+
+
 def _query_azure_artifacts_version(
     package_name: str,
     repository_url: str,
@@ -117,8 +180,8 @@ def _query_azure_artifacts_version(
     """
     Query Azure Artifacts for the latest version.
 
-    Azure Artifacts uses a simple index format (HTML) which is more complex to parse.
-    For now, we'll attempt to query but fall back gracefully if it fails.
+    Azure Artifacts uses a simple index format (HTML) following PEP 503.
+    Parses the HTML to extract version numbers from package filenames.
 
     Args:
         package_name: Package name to query
@@ -141,24 +204,49 @@ def _query_azure_artifacts_version(
         return None
 
     try:
-        response = requests.get(simple_index_url, timeout=5)
+        response = requests.get(simple_index_url, timeout=10)
         logger.debug(f"Azure Artifacts response status: {response.status_code}")
         
         if response.status_code == 401:
             logger.warning(f"Authentication required for Azure Artifacts (401). Package '{package_name}' may require authentication to query.")
+            return None
         elif response.status_code == 403:
             logger.warning(f"Access forbidden for Azure Artifacts (403). Package '{package_name}' may not be accessible or requires different permissions.")
+            return None
         elif response.status_code == 404:
             logger.debug(f"Package '{package_name}' not found on Azure Artifacts (404) - first release")
+            return None
         elif response.status_code != 200:
             logger.warning(f"Unexpected status code {response.status_code} from Azure Artifacts for '{package_name}'")
+            return None
         
-        # Azure Artifacts simple index returns HTML, not JSON
-        # Parsing HTML is complex and may require authentication
-        # For now, we'll return None to fall back to git tags
-        # This can be enhanced later with proper HTML parsing or API endpoint discovery
-        logger.info(f"Azure Artifacts version query not fully implemented (HTML parsing required). Falling back to git tags.")
-        return None
+        # Parse HTML to extract versions
+        parser = SimpleIndexParser(package_name)
+        try:
+            parser.feed(response.text)
+        except Exception as e:
+            logger.warning(f"Error parsing Azure Artifacts HTML for '{package_name}': {e}")
+            return None
+        
+        if not parser.versions:
+            logger.debug(f"No versions found in Azure Artifacts HTML for '{package_name}'")
+            return None
+        
+        # Find the latest version
+        versions = list(parser.versions)
+        logger.debug(f"Found {len(versions)} versions in Azure Artifacts: {versions}")
+        
+        # Sort versions to find the latest
+        try:
+            sorted_versions = sorted(versions, key=_parse_version_for_sort, reverse=True)
+            latest_version = sorted_versions[0]
+            logger.info(f"Found latest version {latest_version} on Azure Artifacts for '{package_name}'")
+            return latest_version
+        except Exception as e:
+            logger.warning(f"Error sorting versions for '{package_name}': {e}")
+            # Fallback: return the first version found
+            return versions[0]
+            
     except requests.RequestException as e:
         logger.warning(f"Network error querying Azure Artifacts for '{package_name}': {e}")
         return None

{python_package_folder-5.1.5 → python_package_folder-5.2.0}/tests/test_version_calculator.py

@@ -86,9 +86,22 @@ class TestQueryRegistryVersion:
 
     @patch("python_package_folder.version_calculator.requests.get")
     def test_query_azure_artifacts_version(self, mock_get: MagicMock) -> None:
-        """Test querying Azure Artifacts (basic support, returns None for now)."""
+        """Test querying Azure Artifacts with HTML parsing."""
         mock_response = Mock()
         mock_response.status_code = 200
+        # Simulate PEP 503 simple index HTML response
+        mock_response.text = """<!DOCTYPE html>
+<html>
+  <head>
+    <title>Links for test-package</title>
+  </head>
+  <body>
+    <h1>Links for test-package</h1>
+    <a href="test-package-0.1.0-py3-none-any.whl">test-package-0.1.0-py3-none-any.whl</a>
+    <a href="test-package-0.2.0-py3-none-any.whl">test-package-0.2.0-py3-none-any.whl</a>
+    <a href="test-package-0.1.5.tar.gz">test-package-0.1.5.tar.gz</a>
+  </body>
+</html>"""
         mock_get.return_value = mock_response
 
         version = query_registry_version(
@@ -96,7 +109,46 @@ class TestQueryRegistryVersion:
             "azure",
             repository_url="https://pkgs.dev.azure.com/ORG/PROJECT/_packaging/FEED/pypi/upload",
         )
-        # Azure Artifacts parsing not fully implemented, returns None
+        # Should parse HTML and return the latest version
+        assert version == "0.2.0"
+
+    @patch("python_package_folder.version_calculator.requests.get")
+    def test_query_azure_artifacts_version_not_found(self, mock_get: MagicMock) -> None:
+        """Test querying Azure Artifacts when package doesn't exist (404)."""
+        mock_response = Mock()
+        mock_response.status_code = 404
+        mock_get.return_value = mock_response
+
+        version = query_registry_version(
+            "test-package",
+            "azure",
+            repository_url="https://pkgs.dev.azure.com/ORG/PROJECT/_packaging/FEED/pypi/upload",
+        )
+        # Should return None for 404 (first release)
+        assert version is None
+
+    @patch("python_package_folder.version_calculator.requests.get")
+    def test_query_azure_artifacts_version_empty_html(self, mock_get: MagicMock) -> None:
+        """Test querying Azure Artifacts with empty HTML (no versions)."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = """<!DOCTYPE html>
+<html>
+  <head>
+    <title>Links for test-package</title>
+  </head>
+  <body>
+    <h1>Links for test-package</h1>
+  </body>
+</html>"""
+        mock_get.return_value = mock_response
+
+        version = query_registry_version(
+            "test-package",
+            "azure",
+            repository_url="https://pkgs.dev.azure.com/ORG/PROJECT/_packaging/FEED/pypi/upload",
+        )
+        # Should return None when no versions found in HTML
         assert version is None
 
     @patch("python_package_folder.version_calculator.requests.get")