python-package-folder 9.0.0__tar.gz → 9.1.0__tar.gz

{python_package_folder-9.0.0 → python_package_folder-9.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 9.0.0
+Version: 9.1.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-9.0.0 → python_package_folder-9.1.0}/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">67%</text>
-    <text x="81" y="14">67%</text>
+    <text x="81" y="15" fill="#010101" fill-opacity=".3">65%</text>
+    <text x="81" y="14">65%</text>
   </g>
 </svg>

{python_package_folder-9.0.0 → python_package_folder-9.1.0}/docs/PUBLISHING.md

@@ -51,6 +51,17 @@ When publishing, the tool automatically filters distribution files to only uploa
 
 This ensures that when building a subfolder package, only that package's distribution files are uploaded, not files from previous builds of other packages.
 
+## Version Mismatch Detection
+
+If there's a version mismatch between the built package and the expected version (e.g., when a subfolder's `pyproject.toml` has a different version than the derived version), the error message will show:
+
+- What version was actually built
+- What version is expected for publishing
+- An explanation of the mismatch
+- A solution suggestion
+
+The tool automatically updates the version in the subfolder's `pyproject.toml` to match the derived version, so this error should only occur if the build process fails before the version update takes effect.
+
 To get a PyPI API token:
 1. Go to https://pypi.org/manage/account/token/
 2. Create a new API token

{python_package_folder-9.0.0 → python_package_folder-9.1.0}/docs/USAGE.md

@@ -75,7 +75,13 @@ The tool automatically:
 - Uses the current directory as the source directory if it contains Python files
 - Falls back to `project_root/src` if the current directory isn't suitable
 - **For subfolder builds**: Handles `pyproject.toml` configuration:
-  - **If `pyproject.toml` exists in subfolder**: Uses that file (copies it to project root temporarily, adjusting package paths and ensuring `[build-system]` uses hatchling)
+  - **If `pyproject.toml` exists in subfolder**: 
+    - Uses that file (copies it to project root temporarily, adjusting package paths and ensuring `[build-system]` uses hatchling)
+    - **Version handling**: The version in the subfolder's `pyproject.toml` is automatically updated to match the derived version (from conventional commits or `--version` argument). A warning is shown if versions differ.
+    - **Name handling**: If the subfolder's `pyproject.toml` has a `name` field that differs from the derived name, a warning is shown but the subfolder's name is used (not the derived one).
+    - **Dependencies handling**: If the subfolder's `pyproject.toml` has a non-empty `dependencies` field, automatic dependency detection is skipped with a warning. To enable automatic detection, remove or empty the `dependencies` field.
+    - **Field merging**: Missing fields (like `description`, `authors`, `keywords`, `classifiers`, `license`, `urls`, etc.) are automatically filled from the parent `pyproject.toml` if available.
+    - **Exclude patterns**: Exclude patterns from the parent `pyproject.toml` are merged into the subfolder's configuration.
   - **If no `pyproject.toml` in subfolder**: Creates a temporary `pyproject.toml` with:
     - `[build-system]` section using hatchling (always uses hatchling, even if parent uses setuptools)
     - Package name derived from the subfolder name (e.g., `empty_drawing_detection` → `empty-drawing-detection`)
@@ -101,11 +107,32 @@ python-package-folder --version "0.1.0" --package-name "my-subfolder-package" --
 python-package-folder --version "0.1.0" --dependency-group "dev" --publish pypi
 
 # If subfolder has its own pyproject.toml, it will be used automatically
-# (package-name and version arguments are ignored in this case)
+# The version will be updated to match the derived version (from conventional commits)
+# The package name from the subfolder toml will be used (even if it differs from derived)
 cd src/integration/my_package  # assuming my_package/pyproject.toml exists
 python-package-folder --publish pypi
 ```
 
+**Subfolder `pyproject.toml` Behavior:**
+
+When a subfolder has its own `pyproject.toml`, the tool intelligently merges it with derived information:
+
+1. **Version**: Always updated to match the derived version (from conventional commits or `--version`). If the subfolder's version differs, a warning is shown but the derived version is used.
+
+2. **Name**: If the subfolder's `pyproject.toml` has a `name` field, it takes precedence over the derived name. A warning is shown if they differ.
+
+3. **Dependencies**: 
+   - If the subfolder's `pyproject.toml` has a non-empty `dependencies` field, automatic dependency detection is **skipped** (with a warning).
+   - To enable automatic dependency detection, remove or empty the `dependencies` field in the subfolder's `pyproject.toml`.
+   - If the `dependencies` field is empty or missing, automatic detection proceeds normally.
+
+4. **Field Merging**: Missing fields are automatically filled from the parent `pyproject.toml`:
+   - `description`, `readme`, `requires-python`, `authors`, `keywords`, `classifiers`, `license`
+   - `[project.urls]` section
+   - Other `[tool.*]` sections (except `tool.hatch.build.*` and `tool.python-package-folder.*`)
+
+5. **Exclude Patterns**: Automatically merged from parent `pyproject.toml`.
+
 **Dependency Groups**: When building a subfolder, you can specify a dependency group from the parent `pyproject.toml` to include in the subfolder's build configuration. This allows subfolders to inherit specific dependencies from the parent project:
 
 ```bash

{python_package_folder-9.0.0 → python_package_folder-9.1.0}/pyproject.toml

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

{python_package_folder-9.0.0 → python_package_folder-9.1.0}/src/python_package_folder/manager.py

@@ -255,28 +255,46 @@ class BuildManager:
                     # Fallback to just subfolder name if root project name not found
                     package_name = subfolder_name
 
-            print(
-                f"Detected subfolder build. Setting up package '{package_name}' version '{version}'..."
-            )
-            self.subfolder_config = SubfolderBuildConfig(
-                project_root=self.project_root,
-                src_dir=self.src_dir,
-                package_name=package_name,
-                version=version,
-                dependency_group=dependency_group,
-            )
-            temp_pyproject = self.subfolder_config.create_temp_pyproject()
-            # If temp_pyproject is None, it means no parent pyproject.toml exists
-            # This is acceptable for tests or dependency-only operations
-            if temp_pyproject is None:
-                self.subfolder_config = None
+            # Check if subfolder_config already exists with the same parameters
+            # This makes prepare_build() idempotent - safe to call multiple times
+            if (
+                self.subfolder_config
+                and self.subfolder_config.package_name == package_name
+                and self.subfolder_config.version == version
+                and self.subfolder_config.dependency_group == dependency_group
+                and self.subfolder_config._temp_package_dir
+                and self.subfolder_config._temp_package_dir.exists()
+            ):
+                print(
+                    f"Subfolder config already exists for '{package_name}' version '{version}', reusing it..."
+                )
+                # Still need to find external dependencies, so continue with that
+                # temp_pyproject should already exist from previous call
+                temp_pyproject = self.subfolder_config.temp_pyproject
             else:
+                print(
+                    f"Detected subfolder build. Setting up package '{package_name}' version '{version}'..."
+                )
+                self.subfolder_config = SubfolderBuildConfig(
+                    project_root=self.project_root,
+                    src_dir=self.src_dir,
+                    package_name=package_name,
+                    version=version,
+                    dependency_group=dependency_group,
+                )
+                temp_pyproject = self.subfolder_config.create_temp_pyproject()
+                # If temp_pyproject is None, it means no parent pyproject.toml exists
+                # This is acceptable for tests or dependency-only operations
+                if temp_pyproject is None:
+                    self.subfolder_config = None
+            
+            # If we have a subfolder_config (either newly created or reused), use temp package dir
+            if self.subfolder_config:
                 # If temporary package directory was created, use it for all operations
                 # This ensures dependencies are copied to the correct location and
                 # imports are fixed in the files that will actually be packaged
                 if (
-                    self.subfolder_config
-                    and self.subfolder_config._temp_package_dir
+                    self.subfolder_config._temp_package_dir
                     and self.subfolder_config._temp_package_dir.exists()
                 ):
                     # Update src_dir to point to temp package directory

{python_package_folder-9.0.0 → python_package_folder-9.1.0}/src/python_package_folder/publisher.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import getpass
 import os
+import re
 import subprocess
 import sys
 from enum import Enum
@@ -284,10 +285,40 @@ class Publisher:
 
         if not dist_files:
             if self.package_name and self.version:
-                raise ValueError(
+                # Try to find what version was actually built
+                built_versions = set()
+                for dist_file in all_dist_files:
+                    # Extract version from filename: package-name-version-*.whl
+                    # Pattern: {package_name}-{version}-{...}
+                    if self.package_name.replace("-", "_") in dist_file.name or self.package_name in dist_file.name:
+                        # Try to extract version from filename
+                        parts = dist_file.stem.split("-")
+                        # Look for version-like pattern (e.g., 1.2.3)
+                        for i, part in enumerate(parts):
+                            if re.match(r"^\d+\.\d+\.\d+", part):
+                                built_versions.add(part)
+                                break
+                
+                error_msg = (
                     f"No distribution files found matching package '{self.package_name}' "
-                    f"version '{self.version}' in {self.dist_dir}"
+                    f"version '{self.version}' in {self.dist_dir}\n"
                 )
+                
+                if built_versions:
+                    error_msg += (
+                        f"  - Built package version(s): {', '.join(sorted(built_versions))}\n"
+                        f"  - Expected version for publishing: {self.version}\n"
+                        f"  - This usually indicates a version mismatch between the built package and the expected version.\n"
+                        f"  - Solution: The version in the subfolder's pyproject.toml will be automatically updated to match the derived version."
+                    )
+                else:
+                    error_msg += (
+                        f"  - No distribution files found for package '{self.package_name}' in {self.dist_dir}\n"
+                        f"  - Available files: {[f.name for f in all_dist_files[:5]]}"
+                        + (f" (and {len(all_dist_files) - 5} more)" if len(all_dist_files) > 5 else "")
+                    )
+                
+                raise ValueError(error_msg)
             else:
                 raise ValueError(f"No distribution files found in {self.dist_dir}")
 

{python_package_folder-9.0.0 → python_package_folder-9.1.0}/src/python_package_folder/subfolder_build.py

@@ -79,6 +79,7 @@ class SubfolderBuildConfig:
         self._excluded_files: list[tuple[Path, Path]] = []  # List of (original_path, temp_path) tuples
         self._exclude_temp_dir: Path | None = None
         self._temp_package_dir: Path | None = None
+        self._has_existing_dependencies = False  # Track if subfolder toml has dependencies
 
     def _derive_package_name(self) -> str:
         """
@@ -549,6 +550,361 @@ class SubfolderBuildConfig:
 
         return "\n".join(result)
 
+    def _update_version_in_pyproject(self, content: str) -> str:
+        """
+        Update the version in pyproject.toml content to match self.version.
+        
+        Also checks if version differs and warns the user.
+        
+        Args:
+            content: Content of pyproject.toml
+            
+        Returns:
+            Content with updated version
+        """
+        if not self.version:
+            return content
+        
+        lines = content.split("\n")
+        result = []
+        in_project_section = False
+        version_set = False
+        existing_version = None
+        
+        for line in lines:
+            # Detect [project] section
+            if line.strip() == "[project]":
+                in_project_section = True
+                result.append(line)
+                continue
+            elif line.strip().startswith("[") and in_project_section:
+                # End of [project] section - add version if not set
+                if not version_set:
+                    result.append(f'version = "{self.version}"')
+                    version_set = True
+                in_project_section = False
+                result.append(line)
+            elif in_project_section:
+                # Check if this is a version line
+                version_match = re.match(r'^\s*version\s*=\s*["\']([^"\']+)["\']', line)
+                if version_match:
+                    existing_version = version_match.group(1)
+                    result.append(f'version = "{self.version}"')
+                    version_set = True
+                    continue  # Skip the original version line
+                else:
+                    result.append(line)
+            else:
+                result.append(line)
+        
+        # If we never found [project] section or version wasn't set, add it
+        if not version_set:
+            # Try to find where to insert it - after [project] if it exists
+            if "[project]" in content:
+                # Insert after [project] line
+                new_lines = []
+                inserted = False
+                for i, line in enumerate(lines):
+                    new_lines.append(line)
+                    if line.strip() == "[project]" and not inserted:
+                        # Insert version right after [project]
+                        new_lines.append(f'version = "{self.version}"')
+                        inserted = True
+                result = new_lines
+            else:
+                # No [project] section, add it at the beginning
+                result.insert(0, "[project]")
+                result.insert(1, f'version = "{self.version}"')
+        
+        # Warn if version differs
+        if existing_version and existing_version != self.version:
+            print(
+                f"\nWarning: Version mismatch in subfolder pyproject.toml",
+                file=sys.stderr,
+            )
+            print(
+                f"  - Version in file: {existing_version}",
+                file=sys.stderr,
+            )
+            print(
+                f"  - Derived version: {self.version} (from conventional commits/CLI)",
+                file=sys.stderr,
+            )
+            print(
+                f"  - Using derived version: {self.version}",
+                file=sys.stderr,
+            )
+            print(
+                f"  - The version in the subfolder's pyproject.toml will be updated for this build.\n",
+                file=sys.stderr,
+            )
+        
+        return "\n".join(result)
+
+    def _check_and_warn_about_dependencies(self, content: str) -> bool:
+        """
+        Check if subfolder pyproject.toml has a non-empty dependencies field.
+        
+        Args:
+            content: Content of pyproject.toml
+            
+        Returns:
+            True if dependencies field exists and is non-empty, False otherwise
+        """
+        if not tomllib:
+            # Fallback: simple regex check
+            # Look for dependencies = [...] pattern
+            deps_match = re.search(r'^\s*dependencies\s*=\s*\[', content, re.MULTILINE)
+            if deps_match:
+                # Try to find if there are any dependencies in the list
+                # This is a simple heuristic - look for non-empty content between [ and ]
+                lines = content.split("\n")
+                in_project = False
+                in_dependencies = False
+                dependency_count = 0
+                
+                for line in lines:
+                    if line.strip() == "[project]":
+                        in_project = True
+                    elif line.strip().startswith("[") and in_project:
+                        in_project = False
+                    elif in_project and re.match(r"^\s*dependencies\s*=\s*\[", line):
+                        in_dependencies = True
+                        # Check if line has content after [
+                        if "]" not in line:
+                            # Multi-line dependencies
+                            continue
+                        else:
+                            # Single line: dependencies = ["pkg1", "pkg2"]
+                            deps_str = line.split("[", 1)[1].rsplit("]", 1)[0]
+                            if deps_str.strip():
+                                return True
+                            return False
+                    elif in_dependencies:
+                        # Check if this line has a dependency (not just whitespace or closing bracket)
+                        stripped = line.strip()
+                        if stripped and not stripped.startswith("#") and stripped != "]":
+                            # Check if it looks like a dependency string
+                            if re.search(r'["\'][^"\']+["\']', stripped):
+                                dependency_count += 1
+                        if "]" in line:
+                            return dependency_count > 0
+                
+                return dependency_count > 0
+            return False
+        
+        # Use tomllib for more accurate parsing
+        try:
+            data = tomllib.loads(content.encode())
+            project = data.get("project", {})
+            dependencies = project.get("dependencies", [])
+            
+            # Check if dependencies list is non-empty
+            if dependencies and len(dependencies) > 0:
+                return True
+            return False
+        except Exception:
+            # If parsing fails, fall back to regex-based check
+            # Look for dependencies = [...] pattern
+            deps_match = re.search(r'^\s*dependencies\s*=\s*\[', content, re.MULTILINE)
+            if deps_match:
+                # Try to find if there are any dependencies in the list
+                lines = content.split("\n")
+                in_project = False
+                in_dependencies = False
+                dependency_count = 0
+                
+                for line in lines:
+                    if line.strip() == "[project]":
+                        in_project = True
+                    elif line.strip().startswith("[") and in_project:
+                        in_project = False
+                    elif in_project and re.match(r"^\s*dependencies\s*=\s*\[", line):
+                        in_dependencies = True
+                        # Check if line has content after [
+                        if "]" not in line:
+                            # Multi-line dependencies
+                            continue
+                        else:
+                            # Single line: dependencies = ["pkg1", "pkg2"]
+                            deps_str = line.split("[", 1)[1].rsplit("]", 1)[0]
+                            if deps_str.strip():
+                                return True
+                            return False
+                    elif in_dependencies:
+                        # Check if this line has a dependency (not just whitespace or closing bracket)
+                        stripped = line.strip()
+                        if stripped and not stripped.startswith("#") and stripped != "]":
+                            # Check if it looks like a dependency string
+                            if re.search(r'["\'][^"\']+["\']', stripped):
+                                dependency_count += 1
+                        if "]" in line:
+                            return dependency_count > 0
+                
+                return dependency_count > 0
+            return False
+
+    def _check_and_warn_about_name(self, content: str) -> str | None:
+        """
+        Check if subfolder pyproject.toml has a name field and warn if it differs from derived.
+        
+        Args:
+            content: Content of pyproject.toml
+            
+        Returns:
+            Name from subfolder toml if found, None otherwise
+        """
+        if not tomllib:
+            # Fallback: simple regex check
+            name_match = re.search(r'^\s*name\s*=\s*["\']([^"\']+)["\']', content, re.MULTILINE)
+            if name_match:
+                return name_match.group(1)
+            return None
+        
+        # Use tomllib for more accurate parsing
+        try:
+            data = tomllib.loads(content.encode())
+            project = data.get("project", {})
+            name = project.get("name")
+            return name
+        except Exception:
+            # If parsing fails, fall back to regex
+            name_match = re.search(r'^\s*name\s*=\s*["\']([^"\']+)["\']', content, re.MULTILINE)
+            if name_match:
+                return name_match.group(1)
+            return None
+
+    def _merge_from_parent_pyproject(self, subfolder_content: str, parent_content: str) -> str:
+        """
+        Merge missing fields from parent pyproject.toml into subfolder content.
+        
+        Priority: subfolder > parent (only fill missing fields from parent)
+        
+        This uses string manipulation to add missing fields since we don't have tomli-w
+        for proper TOML round-trip. Only common fields are merged.
+        
+        Args:
+            subfolder_content: Content of subfolder pyproject.toml
+            parent_content: Content of parent pyproject.toml
+            
+        Returns:
+            Merged content
+        """
+        if not tomllib:
+            # If tomllib not available, return subfolder content as-is
+            return subfolder_content
+        
+        try:
+            subfolder_data = tomllib.loads(subfolder_content.encode())
+            parent_data = tomllib.loads(parent_content.encode())
+            
+            # Fields to merge from parent if missing in subfolder
+            fields_to_merge = [
+                "description", "readme", "requires-python", "authors", 
+                "keywords", "classifiers", "license", "urls"
+            ]
+            
+            # Check what's missing and needs to be added
+            missing_fields = []
+            if "project" in parent_data and "project" in subfolder_data:
+                parent_project = parent_data["project"]
+                subfolder_project = subfolder_data["project"]
+                
+                for field in fields_to_merge:
+                    if field not in subfolder_project and field in parent_project:
+                        missing_fields.append((field, parent_project[field]))
+            
+            # If no missing fields, return as-is
+            if not missing_fields:
+                return subfolder_content
+            
+            # Add missing fields using string manipulation
+            # Find [project] section and add fields after it
+            lines = subfolder_content.split("\n")
+            result = []
+            in_project = False
+            project_section_end = -1
+            
+            for i, line in enumerate(lines):
+                if line.strip() == "[project]":
+                    in_project = True
+                    result.append(line)
+                elif line.strip().startswith("[") and in_project:
+                    # End of [project] section - insert missing fields here
+                    project_section_end = i
+                    in_project = False
+                    # Add missing fields before the next section
+                    for field_name, field_value in missing_fields:
+                        if field_name == "urls" and isinstance(field_value, dict):
+                            # Handle [project.urls] separately
+                            continue
+                        # Format the field value appropriately
+                        formatted = self._format_toml_value(field_name, field_value)
+                        if formatted:
+                            result.append(formatted)
+                    result.append(line)
+                else:
+                    result.append(line)
+            
+            # Handle [project.urls] separately if it exists in parent
+            if "project" in parent_data and "urls" in parent_data["project"]:
+                urls = parent_data["project"]["urls"]
+                if isinstance(urls, dict) and "project.urls" not in subfolder_content:
+                    # Add [project.urls] section at the end
+                    result.append("")
+                    result.append("[project.urls]")
+                    for key, value in urls.items():
+                        result.append(f'{key} = "{value}"')
+            
+            return "\n".join(result)
+            
+        except Exception as e:
+            print(
+                f"Warning: Could not merge from parent pyproject.toml: {e}. Using subfolder content as-is.",
+                file=sys.stderr,
+            )
+            return subfolder_content
+    
+    def _format_toml_value(self, field_name: str, value: any) -> str | None:
+        """
+        Format a TOML field value as a string.
+        
+        Args:
+            field_name: Name of the field
+            value: Value to format
+            
+        Returns:
+            Formatted string or None if cannot format
+        """
+        if value is None:
+            return None
+        
+        if isinstance(value, str):
+            return f'{field_name} = "{value}"'
+        elif isinstance(value, list):
+            if not value:
+                return None
+            # Format list items
+            if isinstance(value[0], dict):
+                # List of dicts (e.g., authors)
+                items = []
+                for item in value:
+                    if isinstance(item, dict):
+                        # Format as inline table: {name = "...", email = "..."}
+                        parts = [f'{k} = "{v}"' for k, v in item.items() if v]
+                        items.append("{" + ", ".join(parts) + "}")
+                return f"{field_name} = [\n    " + ",\n    ".join(items) + "\n]"
+            else:
+                # List of strings
+                items = [f'"{v}"' for v in value]
+                return f"{field_name} = [\n    " + ",\n    ".join(items) + "\n]"
+        elif isinstance(value, bool):
+            return f"{field_name} = {str(value).lower()}"
+        elif isinstance(value, (int, float)):
+            return f"{field_name} = {value}"
+        else:
+            return None
+
     def create_temp_pyproject(self) -> Path | None:
         """
         Create a temporary pyproject.toml for the subfolder build.
@@ -634,11 +990,64 @@ class SubfolderBuildConfig:
                 # Create temporary pyproject.toml file
                 temp_pyproject_path = self.project_root / "pyproject.toml.temp"
 
+                # Check for name mismatch and warn (but use subfolder name)
+                subfolder_name = self._check_and_warn_about_name(subfolder_content)
+                if subfolder_name and subfolder_name != self.package_name:
+                    print(
+                        f"\nWarning: Package name mismatch in subfolder pyproject.toml",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  - Name in file: {subfolder_name}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  - Derived name: {self.package_name}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  - Using name from subfolder toml: {subfolder_name}\n",
+                        file=sys.stderr,
+                    )
+                    # Update package_name to use subfolder's name
+                    self.package_name = subfolder_name
+                
+                # Check for dependencies and warn if automatic detection will be skipped
+                self._has_existing_dependencies = self._check_and_warn_about_dependencies(subfolder_content)
+                if self._has_existing_dependencies:
+                    print(
+                        f"\nWarning: Subfolder pyproject.toml contains a non-empty 'dependencies' field.",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  - Automatic dependency detection will be SKIPPED.",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  - To enable automatic dependency detection, remove or empty the 'dependencies' field in the subfolder's pyproject.toml.\n",
+                        file=sys.stderr,
+                    )
+                
+                # Merge missing fields from parent pyproject.toml if it exists
+                if original_pyproject.exists():
+                    try:
+                        parent_content = original_pyproject.read_text(encoding="utf-8")
+                        subfolder_content = self._merge_from_parent_pyproject(subfolder_content, parent_content)
+                    except Exception as e:
+                        print(
+                            f"Warning: Could not merge from parent pyproject.toml: {e}",
+                            file=sys.stderr,
+                        )
+                
                 # Adjust packages path to be relative to project root
                 # This must be called AFTER _create_temp_package_directory() so _get_package_structure() 
                 # can find the temporary directory
                 adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
                 
+                # Update version in subfolder pyproject.toml to match calculated version
+                # This ensures the built package version matches what we're trying to publish
+                adjusted_content = self._update_version_in_pyproject(adjusted_content)
+                
                 # Read exclude patterns from root pyproject.toml and inject them (if it exists)
                 exclude_patterns = []
                 if original_pyproject.exists():
@@ -1213,6 +1622,14 @@ class SubfolderBuildConfig:
         Args:
             dependencies: List of third-party package names to add (e.g., ["pypdf", "requests"])
         """
+        # Skip if subfolder toml already has dependencies
+        if self._has_existing_dependencies:
+            print(
+                f"Skipping automatic dependency detection - subfolder pyproject.toml already has dependencies defined.",
+                file=sys.stderr,
+            )
+            return
+        
         if not self.temp_pyproject or not self.temp_pyproject.exists():
             print(
                 f"Warning: Cannot add third-party dependencies - pyproject.toml not found at {self.temp_pyproject}",