python-package-folder 5.1.6__tar.gz → 5.2.1__tar.gz

{python_package_folder-5.1.6 → python_package_folder-5.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 5.1.6
+Version: 5.2.1
 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.6 → python_package_folder-5.2.1}/pyproject.toml

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

{python_package_folder-5.1.6 → python_package_folder-5.2.1}/src/python_package_folder/publisher.py

@@ -310,11 +310,59 @@ class Publisher:
         print(f"Files to upload: {len(dist_files)}")
 
         try:
-            subprocess.run(cmd, check=True, text=True)
+            result = subprocess.run(
+                cmd,
+                check=True,
+                text=True,
+                capture_output=True,
+            )
+            # Print twine output if available
+            if result.stdout:
+                print(result.stdout)
+            if result.stderr:
+                print(result.stderr, file=sys.stderr)
             print(f"\n✓ Successfully published to {self.repository.value}")
         except subprocess.CalledProcessError as e:
             print(f"\n✗ Failed to publish to {self.repository.value}", file=sys.stderr)
-            print(f"Error: {e}", file=sys.stderr)
+            
+            # Extract and display twine's actual error message
+            error_details = []
+            if e.stdout:
+                error_details.append(f"stdout: {e.stdout}")
+            if e.stderr:
+                error_details.append(f"stderr: {e.stderr}")
+            if e.returncode is not None:
+                error_details.append(f"exit code: {e.returncode}")
+            
+            if error_details:
+                print("Twine error details:", file=sys.stderr)
+                for detail in error_details:
+                    print(f"  {detail}", file=sys.stderr)
+            else:
+                # Fallback to generic error if no output captured
+                print(f"Command failed: {' '.join(cmd)}", file=sys.stderr)
+                print(f"Return code: {e.returncode}", file=sys.stderr)
+            
+            # Provide helpful hints based on common errors
+            if e.returncode == 1:
+                if e.stderr and ("already exists" in e.stderr.lower() or "409" in e.stderr or "conflict" in e.stderr.lower()):
+                    print(
+                        "\nHint: This version may already exist on the repository. "
+                        "Use --skip-existing to skip files that already exist, "
+                        "or publish a new version.",
+                        file=sys.stderr,
+                    )
+                elif e.stderr and ("401" in e.stderr or "unauthorized" in e.stderr.lower()):
+                    print(
+                        "\nHint: Authentication failed. Check your credentials.",
+                        file=sys.stderr,
+                    )
+                elif e.stderr and ("403" in e.stderr or "forbidden" in e.stderr.lower()):
+                    print(
+                        "\nHint: Access forbidden. Check your permissions for this repository.",
+                        file=sys.stderr,
+                    )
+            
             raise
 
     def publish_interactive(self, skip_existing: bool = False) -> None:

{python_package_folder-5.1.6 → python_package_folder-5.2.1}/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,76 @@ 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 = ""
+        self.links_processed = 0
+    
+    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
+            link_text = data.strip()
+            if link_text:
+                logger.debug(f"Processing link text: '{link_text}'")
+                version = self._extract_version_from_filename(link_text)
+                if version:
+                    logger.debug(f"Extracted version '{version}' from link text: '{link_text}'")
+                    self.versions.add(version)
+            # Also check href if it contains version info
+            if self.current_href:
+                logger.debug(f"Processing href: '{self.current_href}'")
+                version = self._extract_version_from_filename(self.current_href)
+                if version:
+                    logger.debug(f"Extracted version '{version}' from href: '{self.current_href}'")
+                    self.versions.add(version)
+    
+    def handle_endtag(self, tag: str) -> None:
+        if tag == "a":
+            self.links_processed += 1
+            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 +188,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
@@ -135,35 +206,107 @@ def _query_azure_artifacts_version(
             simple_index_url = repository_url.replace("/upload", f"/simple/{package_name}/")
         else:
             simple_index_url = repository_url.rstrip("/") + f"/simple/{package_name}/"
-        logger.debug(f"Constructed Azure Artifacts simple index URL: {simple_index_url}")
+        logger.info(f"Constructed Azure Artifacts simple index URL: {simple_index_url}")
     except Exception as e:
         logger.warning(f"Error constructing Azure Artifacts URL for '{package_name}': {e}")
         return None
 
     try:
-        response = requests.get(simple_index_url, timeout=5)
-        logger.debug(f"Azure Artifacts response status: {response.status_code}")
+        logger.info(f"Fetching Azure Artifacts simple index for '{package_name}'...")
+        response = requests.get(simple_index_url, timeout=10)
+        logger.info(f"Azure Artifacts response: status={response.status_code}, content_length={len(response.text)} bytes")
         
         if response.status_code == 401:
-            logger.warning(f"Authentication required for Azure Artifacts (401). Package '{package_name}' may require authentication to query.")
+            logger.warning(
+                f"Authentication required for Azure Artifacts (401). "
+                f"Package '{package_name}' may require authentication to query. "
+                f"URL: {simple_index_url}"
+            )
+            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.")
+            logger.warning(
+                f"Access forbidden for Azure Artifacts (403). "
+                f"Package '{package_name}' may not be accessible or requires different permissions. "
+                f"URL: {simple_index_url}"
+            )
+            return None
         elif response.status_code == 404:
-            logger.debug(f"Package '{package_name}' not found on Azure Artifacts (404) - first release")
+            logger.info(
+                f"Package '{package_name}' not found on Azure Artifacts (404) - this appears to be the first release. "
+                f"URL: {simple_index_url}"
+            )
+            return None
         elif response.status_code != 200:
-            logger.warning(f"Unexpected status code {response.status_code} from Azure Artifacts for '{package_name}'")
+            logger.warning(
+                f"Unexpected status code {response.status_code} from Azure Artifacts for '{package_name}'. "
+                f"URL: {simple_index_url}, Response preview: {response.text[:200]}"
+            )
+            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
+        logger.info(f"Parsing HTML response to extract versions for '{package_name}'...")
+        parser = SimpleIndexParser(package_name)
+        try:
+            parser.feed(response.text)
+            logger.info(
+                f"HTML parsing completed: processed {parser.links_processed} link(s), "
+                f"found {len(parser.versions)} unique version(s)"
+            )
+        except Exception as e:
+            logger.warning(
+                f"Error parsing Azure Artifacts HTML for '{package_name}': {e}. "
+                f"Response length: {len(response.text)} bytes, "
+                f"Response preview: {response.text[:500]}"
+            )
+            return None
+        
+        if not parser.versions:
+            if parser.links_processed == 0:
+                logger.info(
+                    f"No links found in Azure Artifacts HTML for '{package_name}'. "
+                    f"This may indicate: (1) HTML structure differs from PEP 503 format, "
+                    f"(2) package doesn't exist, or (3) authentication required. "
+                    f"Response preview: {response.text[:500]}"
+                )
+            else:
+                logger.info(
+                    f"Found {parser.links_processed} link(s) but no versions extracted for '{package_name}'. "
+                    f"This may indicate: (1) package name mismatch (expected '{package_name}'), "
+                    f"(2) filename format differs from expected pattern, or (3) first release. "
+                    f"Response preview: {response.text[:500]}"
+                )
+            return None
+        
+        # Find the latest version
+        versions = list(parser.versions)
+        logger.info(f"Found {len(versions)} version(s) in Azure Artifacts HTML: {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"Latest version on Azure Artifacts for '{package_name}': {latest_version}")
+            return latest_version
+        except Exception as e:
+            logger.warning(
+                f"Error sorting versions for '{package_name}': {e}. "
+                f"Versions found: {versions}. Using first version as fallback."
+            )
+            # 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}")
+        logger.warning(
+            f"Network error querying Azure Artifacts for '{package_name}': {e}. "
+            f"URL: {simple_index_url}"
+        )
         return None
     except Exception as e:
-        logger.warning(f"Unexpected error querying Azure Artifacts for '{package_name}': {e}", exc_info=True)
+        logger.warning(
+            f"Unexpected error querying Azure Artifacts for '{package_name}': {e}. "
+            f"URL: {simple_index_url}",
+            exc_info=True
+        )
         return None
 
 

{python_package_folder-5.1.6 → python_package_folder-5.2.1}/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")