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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 5.2.0
+Version: 5.2.2
 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.2.0 → python_package_folder-5.2.2}/coverage.svg

@@ -14,7 +14,7 @@
   <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
     <text x="31.5" y="15" fill="#010101" fill-opacity=".3">coverage</text>
     <text x="31.5" y="14">coverage</text>
-    <text x="81" y="15" fill="#010101" fill-opacity=".3">68%</text>
-    <text x="81" y="14">68%</text>
+    <text x="81" y="15" fill="#010101" fill-opacity=".3">67%</text>
+    <text x="81" y="14">67%</text>
   </g>
 </svg>

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

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

{python_package_folder-5.2.0 → python_package_folder-5.2.2}/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.2.0 → python_package_folder-5.2.2}/src/python_package_folder/python_package_folder.py

@@ -186,6 +186,21 @@ def main() -> int:
                 repository = args.publish if args.publish else None
                 repository_url = args.repository_url if args.publish else None
                 
+                # Get credentials for authenticated registry queries (especially Azure Artifacts)
+                # Try to get them from args or environment variables
+                query_username = args.username
+                query_password = args.password
+                
+                # If not provided via args, check environment variables (for Azure Artifacts)
+                if repository == "azure" and not query_username:
+                    query_username = os.getenv("TWINE_USERNAME") or os.getenv("PYPI_USERNAME")
+                if repository == "azure" and not query_password:
+                    query_password = (
+                        os.getenv("TWINE_PASSWORD")
+                        or os.getenv("PYPI_PASSWORD")
+                        or os.getenv("AZURE_ARTIFACTS_TOKEN")
+                    )
+                
                 if is_subfolder:
                     # Workflow 1: subfolder build
                     # src_dir is guaranteed to be relative to project_root due to is_subfolder check
@@ -199,6 +214,8 @@ def main() -> int:
                         subfolder_path=subfolder_rel_path,
                         repository=repository,
                         repository_url=repository_url,
+                        username=query_username,
+                        password=query_password,
                     )
                 else:
                     # Workflow 2: main package
@@ -221,6 +238,8 @@ def main() -> int:
                         subfolder_path=None,
                         repository=repository,
                         repository_url=repository_url,
+                        username=query_username,
+                        password=query_password,
                     )
 
                 if resolved_version:

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

@@ -25,6 +25,8 @@ def query_registry_version(
     package_name: str,
     repository: str,
     repository_url: str | None = None,
+    username: str | None = None,
+    password: str | None = None,
 ) -> str | None:
     """
     Query package registry for the latest published version.
@@ -33,6 +35,8 @@ def query_registry_version(
         package_name: Package name to query
         repository: Repository type ('pypi', 'testpypi', or 'azure')
         repository_url: Repository URL (required for Azure Artifacts)
+        username: Optional username for authenticated queries (Azure Artifacts)
+        password: Optional password/token for authenticated queries (Azure Artifacts)
 
     Returns:
         Latest version string or None if not found/unsupported
@@ -54,7 +58,7 @@ def query_registry_version(
                 logger.warning("Azure Artifacts repository URL not provided")
                 return None
             logger.info(f"Querying Azure Artifacts for package '{package_name}' at {repository_url}")
-            version = _query_azure_artifacts_version(package_name, repository_url)
+            version = _query_azure_artifacts_version(package_name, repository_url, username, password)
             if version:
                 logger.info(f"Found version {version} on Azure Artifacts")
             else:
@@ -120,6 +124,7 @@ class SimpleIndexParser(HTMLParser):
         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":
@@ -134,17 +139,24 @@ class SimpleIndexParser(HTMLParser):
         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)
+            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 = ""
     
@@ -176,6 +188,8 @@ class SimpleIndexParser(HTMLParser):
 def _query_azure_artifacts_version(
     package_name: str,
     repository_url: str,
+    username: str | None = None,
+    password: str | None = None,
 ) -> str | None:
     """
     Query Azure Artifacts for the latest version.
@@ -186,6 +200,8 @@ def _query_azure_artifacts_version(
     Args:
         package_name: Package name to query
         repository_url: Azure Artifacts repository URL
+        username: Optional username for authentication
+        password: Optional password/token for authentication
 
     Returns:
         Latest version string or None if not found/unsupported
@@ -198,60 +214,114 @@ 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=10)
-        logger.debug(f"Azure Artifacts response status: {response.status_code}")
+        # Prepare authentication if credentials are provided
+        auth = None
+        if username and password:
+            auth = (username, password)
+            logger.info(f"Fetching Azure Artifacts simple index for '{package_name}' with authentication...")
+        else:
+            logger.info(f"Fetching Azure Artifacts simple index for '{package_name}' (no authentication)...")
+        
+        response = requests.get(simple_index_url, auth=auth, 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
         
         # 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}")
+            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:
-            logger.debug(f"No versions found in Azure Artifacts HTML for '{package_name}'")
+            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.debug(f"Found {len(versions)} versions in Azure Artifacts: {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"Found latest version {latest_version} on Azure Artifacts for '{package_name}'")
+            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}")
+            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
 
 
@@ -573,6 +643,8 @@ def resolve_version(
     subfolder_path: Path | None = None,
     repository: str | None = None,
     repository_url: str | None = None,
+    username: str | None = None,
+    password: str | None = None,
 ) -> tuple[str | None, str | None]:
     """
     Resolve the next version using conventional commits.
@@ -585,6 +657,8 @@ def resolve_version(
         subfolder_path: Optional path to subfolder (relative to project_root)
         repository: Optional target repository ('pypi', 'testpypi', or 'azure')
         repository_url: Optional repository URL (required for Azure Artifacts)
+        username: Optional username for authenticated registry queries (Azure Artifacts)
+        password: Optional password/token for authenticated registry queries (Azure Artifacts)
 
     Returns:
         Tuple of (version string if a release is determined, error message if any)
@@ -596,7 +670,7 @@ def resolve_version(
     baseline_version = None
     if repository and package_name:
         logger.info(f"Attempting to query {repository} for baseline version of '{package_name}'")
-        baseline_version = query_registry_version(package_name, repository, repository_url)
+        baseline_version = query_registry_version(package_name, repository, repository_url, username, password)
 
     # Step 2: Fallback to git tags if registry query failed
     if not baseline_version:

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

@@ -151,6 +151,39 @@ class TestQueryRegistryVersion:
         # Should return None when no versions found in HTML
         assert version is None
 
+    @patch("python_package_folder.version_calculator.requests.get")
+    def test_query_azure_artifacts_version_with_auth(self, mock_get: MagicMock) -> None:
+        """Test querying Azure Artifacts with authentication."""
+        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>
+    <a href="test-package-1.0.0-py3-none-any.whl">test-package-1.0.0-py3-none-any.whl</a>
+    <a href="test-package-1.1.0-py3-none-any.whl">test-package-1.1.0-py3-none-any.whl</a>
+  </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",
+            username="testuser",
+            password="testtoken",
+        )
+        # Should parse HTML and return the latest version
+        assert version == "1.1.0"
+        
+        # Verify authentication was used
+        mock_get.assert_called_once()
+        call_args = mock_get.call_args
+        assert call_args[1]["auth"] == ("testuser", "testtoken")
+
     @patch("python_package_folder.version_calculator.requests.get")
     def test_query_registry_version_error_handling(self, mock_get: MagicMock) -> None:
         """Test that registry query errors are handled gracefully."""