python-package-folder 1.4.1__tar.gz → 2.0.4__tar.gz

python_package_folder-2.0.4/.github/workflows/publish.yml

@@ -0,0 +1,104 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch: # Enable manual trigger.
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write # Mandatory for OIDC.
+      contents: read
+    steps:
+      - name: Checkout (official GitHub action)
+        uses: actions/checkout@v4
+        with:
+          # Important for versioning plugins:
+          fetch-depth: 0
+
+      - name: Install uv (official Astral action)
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.9.5"
+          enable-cache: true
+          python-version: "3.12"
+
+      - name: Set up Python (using uv)
+        run: uv python install
+
+      - name: Install all dependencies
+        run: uv sync --all-extras
+
+      - name: Run tests
+        run: uv run pytest
+
+      - name: Verify pyproject.toml is correct
+        run: |
+          # Verify pyproject.toml has the correct package name
+          if ! grep -q 'name = "python-package-folder"' pyproject.toml; then
+            echo "Error: pyproject.toml does not have correct package name 'python-package-folder'"
+            echo "Current content:"
+            grep '^name =' pyproject.toml || echo "No name field found"
+            exit 1
+          fi
+          # Verify packages points to the correct location
+          if ! grep -q 'packages = \["src/python_package_folder"\]' pyproject.toml; then
+            echo "Error: pyproject.toml does not have correct packages configuration"
+            echo "Current packages:"
+            grep -A 1 '\[tool.hatch.build.targets.wheel\]' pyproject.toml || echo "No packages found"
+            exit 1
+          fi
+          echo "✓ pyproject.toml is correct"
+
+      - name: Clean dist directory
+        run: |
+          # Remove any existing distribution files to prevent publishing test artifacts
+          rm -rf dist/
+          echo "✓ Cleaned dist/ directory"
+
+      - name: Build package
+        run: uv build
+
+      - name: Verify distribution files
+        run: |
+          # List all distribution files that will be published
+          echo "Distribution files to be published:"
+          ls -la dist/ || (echo "No dist/ directory found" && exit 1)
+          
+          # Check for unexpected files (exclude .gitignore and expected package files)
+          UNEXPECTED_FILES=0
+          for file in dist/*.whl dist/*.tar.gz; do
+            if [ -f "$file" ]; then
+              filename=$(basename "$file")
+              # Check if file starts with python_package_folder (package directory name)
+              if [[ ! "$filename" =~ ^python_package_folder- ]]; then
+                echo "Error: Found unexpected distribution file: $filename"
+                UNEXPECTED_FILES=$((UNEXPECTED_FILES + 1))
+              fi
+            fi
+          done
+          
+          if [ $UNEXPECTED_FILES -gt 0 ]; then
+            echo "Error: Found $UNEXPECTED_FILES unexpected distribution file(s)"
+            echo "Files in dist/:"
+            ls -la dist/
+            exit 1
+          fi
+          
+          # Verify at least one expected file exists
+          if ! ls dist/python_package_folder-*.whl dist/python_package_folder-*.tar.gz 2>/dev/null | grep -q .; then
+            echo "Error: No python_package_folder distribution files found"
+            echo "Files in dist/:"
+            ls -la dist/
+            exit 1
+          fi
+          
+          echo "✓ Only python_package_folder distribution files found"
+
+      - name: Publish to PyPI
+        run: uv publish --trusted-publishing always
+        # Although uv is newer and faster, the "official" publishing option is the one from PyPA,
+        # which uses twine. If desired, replace `uv publish` with:
+        # uses: pypa/gh-action-pypi-publish@release/v1

{python_package_folder-1.4.1 → python_package_folder-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 1.4.1
+Version: 2.0.4
 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-1.4.1 → python_package_folder-2.0.4}/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">69%</text>
+    <text x="81" y="14">69%</text>
   </g>
 </svg>

{python_package_folder-1.4.1 → python_package_folder-2.0.4}/pyproject.toml

@@ -172,4 +172,4 @@ testpaths = [
     "tests",
 ]
 norecursedirs = []
-filterwarnings = []
+filterwarnings = []

{python_package_folder-1.4.1 → python_package_folder-2.0.4}/src/python_package_folder/manager.py

@@ -268,6 +268,19 @@ class BuildManager:
         for dep in external_deps:
             self._copy_dependency(dep)
 
+        # For subfolder builds, extract third-party dependencies and add to pyproject.toml
+        if self._is_subfolder_build() and self.subfolder_config:
+            # Re-analyze all Python files (including copied dependencies) to find third-party imports
+            all_python_files = analyzer.find_all_python_files(self.src_dir)
+            third_party_deps = self._extract_third_party_dependencies(all_python_files, analyzer)
+            if third_party_deps:
+                print(
+                    f"Found {len(third_party_deps)} third-party dependencies: {', '.join(third_party_deps)}"
+                )
+                self.subfolder_config.add_third_party_dependencies(third_party_deps)
+            else:
+                print("No third-party dependencies found in subfolder code")
+
         # Report ambiguous imports
         self._report_ambiguous_imports(python_files)
 
@@ -381,6 +394,145 @@ class BuildManager:
             elif src_item.is_dir():
                 self._copytree_excluding(src_item, dst_item)
 
+    def _get_package_name_from_import(self, module_name: str) -> str | None:
+        """
+        Get the actual PyPI package name from an import module name.
+
+        This handles cases where the import name differs from the package name
+        (e.g., 'import fitz' from 'pymupdf' package).
+
+        Args:
+            module_name: The module name from the import statement
+
+        Returns:
+            The actual package name, or None if not found
+        """
+        root_module = module_name.split(".")[0]
+        try:
+            # Try Python 3.10+ first (has packages_distributions)
+            import importlib.metadata as importlib_metadata
+
+            # Use packages_distributions() if available (Python 3.10+)
+            if hasattr(importlib_metadata, "packages_distributions"):
+                packages_map = importlib_metadata.packages_distributions()
+                # packages_map is a dict mapping module names to list of distribution names
+                if root_module in packages_map:
+                    # Return the first distribution name (usually there's only one)
+                    dist_names = packages_map[root_module]
+                    if dist_names:
+                        return dist_names[0]
+
+            # Fallback: search all distributions
+            for dist in importlib_metadata.distributions():
+                try:
+                    # Check if this distribution provides the module
+                    # by looking at its files
+                    files = dist.files or []
+                    for file in files:
+                        file_str = str(file)
+                        # Check if file is the module itself or in a package directory
+                        if (
+                            file.suffix == ".py"
+                            and (file.stem == root_module or file.stem == "__init__")
+                        ) or (
+                            "/" in file_str
+                            and (
+                                file_str.startswith(f"{root_module}/")
+                                or file_str.startswith(f"{root_module.replace('_', '-')}/")
+                            )
+                        ):
+                            return dist.metadata["Name"]
+                except Exception:
+                    continue
+
+        except ImportError:
+            try:
+                # Fallback for older Python versions
+                import importlib_metadata
+
+                # Search all distributions
+                for dist in importlib_metadata.distributions():
+                    try:
+                        files = dist.files or []
+                        for file in files:
+                            file_str = str(file)
+                            if (
+                                file.suffix == ".py"
+                                and (file.stem == root_module or file.stem == "__init__")
+                            ) or (
+                                "/" in file_str
+                                and (
+                                    file_str.startswith(f"{root_module}/")
+                                    or file_str.startswith(f"{root_module.replace('_', '-')}/")
+                                )
+                            ):
+                                return dist.metadata["Name"]
+                    except Exception:
+                        continue
+            except ImportError:
+                pass
+        except Exception:
+            pass
+
+        return None
+
+    def _extract_third_party_dependencies(
+        self, python_files: list[Path], analyzer: ImportAnalyzer
+    ) -> list[str]:
+        """
+        Extract third-party package dependencies from Python files.
+
+        Analyzes all Python files to find imports classified as "third_party"
+        and returns a list of unique package names. Handles cases where the
+        import name differs from the package name (e.g., 'fitz' -> 'pymupdf').
+
+        Args:
+            python_files: List of Python file paths to analyze
+            analyzer: ImportAnalyzer instance to use for classification
+
+        Returns:
+            List of unique third-party package names (e.g., ["pypdf", "requests", "pymupdf"])
+        """
+        third_party_packages: set[str] = set()
+
+        for file_path in python_files:
+            imports = analyzer.extract_imports(file_path)
+            for imp in imports:
+                analyzer.classify_import(imp, self.src_dir)
+
+                # Extract the root package name (first part of module name)
+                root_module = imp.module_name.split(".")[0]
+
+                # Skip if it's a standard library module
+                stdlib_modules = analyzer.get_stdlib_modules()
+                if root_module in stdlib_modules:
+                    continue
+
+                # If classified as third_party, try to get actual package name
+                if imp.classification == "third_party":
+                    # Try to get the actual package name from metadata
+                    actual_package = self._get_package_name_from_import(imp.module_name)
+                    if actual_package:
+                        third_party_packages.add(actual_package)
+                    else:
+                        # Fallback to using the import name
+                        third_party_packages.add(root_module)
+                # If it's ambiguous or unresolved, and not stdlib/local/external,
+                # it's likely a third-party package that needs to be declared
+                elif imp.classification == "ambiguous" or imp.classification is None:
+                    # Check if it's not a local or external module
+                    if not imp.resolved_path:
+                        # Try to get the actual package name from metadata
+                        # (might work if package is installed but module path is unusual)
+                        actual_package = self._get_package_name_from_import(imp.module_name)
+                        if actual_package:
+                            third_party_packages.add(actual_package)
+                        else:
+                            # Fallback: use import name (will be normalized later)
+                            third_party_packages.add(root_module)
+
+        return sorted(list(third_party_packages))
+
     def _report_ambiguous_imports(self, python_files: list[Path]) -> None:
         """
         Report any ambiguous imports that couldn't be resolved.

{python_package_folder-1.4.1 → python_package_folder-2.0.4}/src/python_package_folder/subfolder_build.py

@@ -254,6 +254,9 @@ class SubfolderBuildConfig:
             # If original pyproject.toml exists, temporarily move it
             if original_pyproject.exists():
                 backup_path = self.project_root / "pyproject.toml.original"
+                # Remove backup if it already exists (from previous failed test or run)
+                if backup_path.exists():
+                    backup_path.unlink()
                 original_pyproject.rename(backup_path)
                 self.original_pyproject_backup = backup_path
 
@@ -292,6 +295,9 @@ class SubfolderBuildConfig:
 
         # Temporarily move original to backup location
         backup_path = self.project_root / "pyproject.toml.original"
+        # Remove backup if it already exists (from previous failed test or run)
+        if backup_path.exists():
+            backup_path.unlink()
         original_pyproject.rename(backup_path)
         self.original_pyproject_backup = backup_path
 
@@ -559,6 +565,139 @@ class SubfolderBuildConfig:
 
         return "\n".join(result)
 
+    def add_third_party_dependencies(self, dependencies: list[str]) -> None:
+        """
+        Add third-party dependencies to the temporary pyproject.toml.
+
+        This method updates the pyproject.toml file that was created for the subfolder
+        build by adding the specified dependencies to the [project.dependencies] section.
+
+        Args:
+            dependencies: List of third-party package names to add (e.g., ["pypdf", "requests"])
+        """
+        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}",
+                file=sys.stderr,
+            )
+            return
+
+        if not dependencies:
+            return
+
+        print(f"Adding third-party dependencies to pyproject.toml: {', '.join(dependencies)}")
+        content = self.temp_pyproject.read_text(encoding="utf-8")
+        updated_content = self._add_dependencies_to_pyproject(content, dependencies)
+        self.temp_pyproject.write_text(updated_content, encoding="utf-8")
+
+    def _normalize_package_name(self, package_name: str) -> str:
+        """
+        Normalize package name for PyPI.
+
+        Converts underscores to hyphens, as PyPI package names typically use hyphens
+        while Python import names use underscores (e.g., 'better_enum' -> 'better-enum').
+
+        Args:
+            package_name: Package name from import statement
+
+        Returns:
+            Normalized package name for PyPI
+        """
+        # Convert underscores to hyphens for PyPI package names
+        # This handles the common case where import names use underscores
+        # but PyPI package names use hyphens
+        return package_name.replace("_", "-")
+
+    def _add_dependencies_to_pyproject(self, content: str, dependencies: list[str]) -> str:
+        """
+        Add dependencies to pyproject.toml content.
+
+        Adds the specified dependencies to the [project] section's dependencies list.
+        If dependencies already exist, merges them. If no dependencies section exists,
+        creates one. Package names are normalized (underscores -> hyphens) to match
+        PyPI naming conventions.
+
+        Args:
+            content: Current pyproject.toml content
+            dependencies: List of dependency names to add (will be normalized)
+
+        Returns:
+            Updated pyproject.toml content with dependencies added
+        """
+        if not dependencies:
+            return content
+
+        # Normalize package names (convert underscores to hyphens for PyPI)
+        normalized_deps = [self._normalize_package_name(dep) for dep in dependencies]
+
+        lines = content.split("\n")
+        result = []
+        in_project = False
+        in_dependencies = False
+        dependencies_added = False
+        existing_deps: set[str] = set()
+
+        # First pass: find existing dependencies
+        for line in lines:
+            if line.strip().startswith("[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
+            elif in_dependencies:
+                # Extract existing dependency names
+                dep_match = re.search(r'["\']([^"\']+)["\']', line)
+                if dep_match:
+                    existing_deps.add(dep_match.group(1))
+                if line.strip().endswith("]"):
+                    in_dependencies = False
+
+        # Merge with new dependencies (normalized)
+        all_deps = sorted(existing_deps | set(normalized_deps))
+
+        # Second pass: build result with dependencies
+        in_project = False
+        in_dependencies = False
+        for line in lines:
+            if line.strip().startswith("[project]"):
+                in_project = True
+                result.append(line)
+            elif line.strip().startswith("[") and in_project:
+                # End of [project] section, add dependencies if not already present
+                if not dependencies_added:
+                    result.append("dependencies = [")
+                    for dep in all_deps:
+                        result.append(f'    "{dep}",')
+                    result.append("]")
+                    result.append("")
+                in_project = False
+                result.append(line)
+            elif in_project and re.match(r"^\s*dependencies\s*=\s*\[", line):
+                # Replace existing dependencies section
+                result.append("dependencies = [")
+                for dep in all_deps:
+                    result.append(f'    "{dep}",')
+                result.append("]")
+                dependencies_added = True
+                in_dependencies = True
+            elif in_dependencies:
+                # Skip lines in existing dependencies section (already replaced)
+                if line.strip().endswith("]"):
+                    in_dependencies = False
+            else:
+                result.append(line)
+
+        # If [project] section exists but no dependencies were added, add them
+        if in_project and not dependencies_added:
+            result.append("dependencies = [")
+            for dep in all_deps:
+                result.append(f'    "{dep}",')
+            result.append("]")
+            result.append("")
+
+        return "\n".join(result)
+
     def _handle_readme(self) -> None:
         """
         Handle README file for subfolder builds.

python_package_folder-2.0.4/tests/conftest.py

@@ -0,0 +1,96 @@
+"""Pytest configuration and fixtures."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture(autouse=True, scope="session")
+def protect_repository_files():
+    """
+    Automatically protect repository files from test modifications.
+
+    This fixture backs up pyproject.toml and README.md at the start of the test session
+    and restores them at the end, ensuring tests never permanently modify repository files.
+    """
+    # Get the repository root (parent of tests directory)
+    repo_root = Path(__file__).parent.parent
+
+    pyproject_path = repo_root / "pyproject.toml"
+    readme_path = repo_root / "README.md"
+
+    # Backup original files if they exist
+    pyproject_backup = None
+    readme_backup = None
+    pyproject_existed = pyproject_path.exists()
+    readme_existed = readme_path.exists()
+
+    if pyproject_existed:
+        pyproject_backup = pyproject_path.read_bytes()
+    if readme_existed:
+        readme_backup = readme_path.read_bytes()
+
+    # Yield control to tests
+    yield
+
+    # Restore original files after all tests
+    if pyproject_backup and pyproject_path.exists():
+        try:
+            current_content = pyproject_path.read_bytes()
+            if current_content != pyproject_backup:
+                # File was modified, restore it
+                pyproject_path.write_bytes(pyproject_backup)
+                print(
+                    "Warning: Restored modified pyproject.toml after test session",
+                    file=sys.stderr,
+                )
+        except OSError as e:
+            print(
+                f"Warning: Could not restore pyproject.toml: {e}",
+                file=sys.stderr,
+            )
+    elif pyproject_backup and not pyproject_path.exists():
+        # File was deleted, restore it
+        try:
+            pyproject_path.write_bytes(pyproject_backup)
+            print(
+                "Warning: Restored deleted pyproject.toml after test session",
+                file=sys.stderr,
+            )
+        except OSError as e:
+            print(
+                f"Warning: Could not restore pyproject.toml: {e}",
+                file=sys.stderr,
+            )
+
+    if readme_backup and readme_path.exists():
+        try:
+            current_content = readme_path.read_bytes()
+            if current_content != readme_backup:
+                # File was modified, restore it
+                readme_path.write_bytes(readme_backup)
+                print(
+                    "Warning: Restored modified README.md after test session",
+                    file=sys.stderr,
+                )
+        except OSError as e:
+            print(
+                f"Warning: Could not restore README.md: {e}",
+                file=sys.stderr,
+            )
+    elif readme_backup and not readme_path.exists():
+        # File was deleted, restore it
+        try:
+            readme_path.write_bytes(readme_backup)
+            print(
+                "Warning: Restored deleted README.md after test session",
+                file=sys.stderr,
+            )
+        except OSError as e:
+            print(
+                f"Warning: Could not restore README.md: {e}",
+                file=sys.stderr,
+            )

python_package_folder-2.0.4/tests/folder_structure/subfolder_to_build/__init__.py

@@ -0,0 +1 @@
+# Temporary __init__.py for build

python_package_folder-2.0.4/tests/folder_structure/subfolder_to_build/some_globals.py

@@ -0,0 +1 @@
+SOME_GLOBAL_VARIABLE = "some_global_variable"

{python_package_folder-1.4.1 → python_package_folder-2.0.4}/tests/test_build_with_external_deps.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 
 import pytest
@@ -369,6 +370,7 @@ class TestRealFolderStructure:
         if not src_dir.exists():
             pytest.skip("Real test structure not found")
 
+        # This test only reads files, doesn't modify them, so no backup needed
         finder = ExternalDependencyFinder(project_root, src_dir)
         analyzer = ImportAnalyzer(project_root)
 
@@ -392,12 +394,28 @@ class TestRealFolderStructure:
         if not src_dir.exists():
             pytest.skip("Real test structure not found")
 
-        manager = BuildManager(project_root, src_dir)
+        # Save original repository files that might be modified
+        original_pyproject = project_root / "pyproject.toml"
+        original_readme = project_root / "README.md"
+        pyproject_backup = None
+        readme_backup = None
+        pyproject_existed = original_pyproject.exists()
+        readme_existed = original_readme.exists()
 
-        # Prepare build
-        external_deps = manager.prepare_build()
+        if pyproject_existed:
+            pyproject_backup = original_pyproject.read_bytes()
+        if readme_existed:
+            readme_backup = original_readme.read_bytes()
+
+        # Check what files exist before the build
+        some_globals_existed_before = (src_dir / "some_globals.py").exists()
+
+        manager = BuildManager(project_root, src_dir)
 
         try:
+            # Prepare build
+            external_deps = manager.prepare_build()
+
             # Verify dependencies were found
             assert len(external_deps) >= 1
 
@@ -418,8 +436,36 @@ class TestRealFolderStructure:
             # Always cleanup
             manager.cleanup()
 
-            # Verify cleanup
-            assert not (src_dir / "some_globals.py").exists()
+            # Restore original repository files if they were modified
+            if pyproject_backup and original_pyproject.exists():
+                # Verify the file was restored correctly, or restore it manually
+                try:
+                    current_content = original_pyproject.read_bytes()
+                    if current_content != pyproject_backup:
+                        # File was modified, restore it
+                        original_pyproject.write_bytes(pyproject_backup)
+                except Exception as e:
+                    print(f"Warning: Could not verify/restore pyproject.toml: {e}", file=sys.stderr)
+            elif pyproject_backup and not original_pyproject.exists():
+                # File was deleted, restore it
+                original_pyproject.write_bytes(pyproject_backup)
+
+            if readme_backup and original_readme.exists():
+                # Verify the file was restored correctly, or restore it manually
+                try:
+                    current_content = original_readme.read_bytes()
+                    if current_content != readme_backup:
+                        # File was modified, restore it
+                        original_readme.write_bytes(readme_backup)
+                except Exception as e:
+                    print(f"Warning: Could not verify/restore README.md: {e}", file=sys.stderr)
+            elif readme_backup and not original_readme.exists():
+                # File was deleted, restore it
+                original_readme.write_bytes(readme_backup)
+
+            # Verify cleanup - only check if the file didn't exist before
+            if not some_globals_existed_before:
+                assert not (src_dir / "some_globals.py").exists()
             if (src_dir / "utility_folder").exists():
                 # May have been there originally, so just check it's not in copied_dirs
                 assert (src_dir / "utility_folder") not in manager.copied_dirs
@@ -454,6 +500,19 @@ class TestExclusionPatterns:
         if not src_dir.exists():
             pytest.skip("Real test structure not found")
 
+        # Save original repository files that might be modified
+        original_pyproject = project_root / "pyproject.toml"
+        original_readme = project_root / "README.md"
+        pyproject_backup = None
+        readme_backup = None
+        pyproject_existed = original_pyproject.exists()
+        readme_existed = original_readme.exists()
+
+        if pyproject_existed:
+            pyproject_backup = original_pyproject.read_bytes()
+        if readme_existed:
+            readme_backup = original_readme.read_bytes()
+
         manager = BuildManager(project_root, src_dir)
 
         try:
@@ -474,6 +533,27 @@ class TestExclusionPatterns:
         finally:
             manager.cleanup()
 
+            # Restore original repository files if they were modified
+            if pyproject_backup and original_pyproject.exists():
+                try:
+                    current_content = original_pyproject.read_bytes()
+                    if current_content != pyproject_backup:
+                        original_pyproject.write_bytes(pyproject_backup)
+                except Exception as e:
+                    print(f"Warning: Could not verify/restore pyproject.toml: {e}", file=sys.stderr)
+            elif pyproject_backup and not original_pyproject.exists():
+                original_pyproject.write_bytes(pyproject_backup)
+
+            if readme_backup and original_readme.exists():
+                try:
+                    current_content = original_readme.read_bytes()
+                    if current_content != readme_backup:
+                        original_readme.write_bytes(readme_backup)
+                except Exception as e:
+                    print(f"Warning: Could not verify/restore README.md: {e}", file=sys.stderr)
+            elif readme_backup and not original_readme.exists():
+                original_readme.write_bytes(readme_backup)
+
     def test_exclude_custom_patterns(self, test_project_root: Path) -> None:
         """Test that custom exclusion patterns work."""
         # Create a directory with a custom exclusion pattern

{python_package_folder-1.4.1 → python_package_folder-2.0.4}/tests/test_subfolder_build.py

@@ -524,6 +524,39 @@ version = "3.0.0"
         parent_pyproject.write_text(original_content)
         config.restore()
 
+    def test_third_party_dependencies_added(self, test_project_with_pyproject: Path) -> None:
+        """Test that third-party dependencies are added to temporary pyproject.toml."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+
+        # Create a Python file that imports a third-party package
+        (subfolder / "module.py").write_text("import pypdf\nimport requests\n")
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+            package_name="test-package",
+        )
+
+        config.create_temp_pyproject()
+
+        # Add third-party dependencies
+        config.add_third_party_dependencies(["pypdf", "requests"])
+
+        # Verify dependencies were added
+        pyproject_path = project_root / "pyproject.toml"
+        assert pyproject_path.exists()
+        content = pyproject_path.read_text()
+
+        # Check that dependencies section exists and contains the packages
+        assert "dependencies = [" in content
+        assert '"pypdf"' in content or "'pypdf'" in content
+        assert '"requests"' in content or "'requests'" in content
+
+        # Cleanup
+        config.restore()
+
 
 class TestSubfolderBuildWithoutParentPyproject:
     """Tests for subfolder builds when parent pyproject.toml doesn't exist."""
@@ -642,6 +675,39 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
         # Cleanup
         config.restore()
 
+    def test_third_party_dependencies_added(self, test_project_with_pyproject: Path) -> None:
+        """Test that third-party dependencies are added to temporary pyproject.toml."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+
+        # Create a Python file that imports a third-party package
+        (subfolder / "module.py").write_text("import pypdf\nimport requests\n")
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+            package_name="test-package",
+        )
+
+        config.create_temp_pyproject()
+
+        # Add third-party dependencies
+        config.add_third_party_dependencies(["pypdf", "requests"])
+
+        # Verify dependencies were added
+        pyproject_path = project_root / "pyproject.toml"
+        assert pyproject_path.exists()
+        content = pyproject_path.read_text()
+
+        # Check that dependencies section exists and contains the packages
+        assert "dependencies = [" in content
+        assert '"pypdf"' in content or "'pypdf'" in content
+        assert '"requests"' in content or "'requests'" in content
+
+        # Cleanup
+        config.restore()
+
     def test_temporary_pyproject_preserves_other_sections(
         self, test_project_with_pyproject: Path
     ) -> None:

python_package_folder-2.0.4/tests/test_third_party_dependencies.py

@@ -0,0 +1,292 @@
+"""Tests for third-party dependency detection and normalization."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from python_package_folder import BuildManager, ImportAnalyzer
+
+
+@pytest.fixture
+def test_project_with_imports(tmp_path: Path) -> Path:
+    """Create a test project with subfolder containing various imports."""
+    project_root = tmp_path / "test_project"
+    project_root.mkdir()
+
+    # Create pyproject.toml
+    pyproject_content = """[project]
+name = "test-package"
+version = "0.1.0"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/test_package"]
+"""
+    (project_root / "pyproject.toml").write_text(pyproject_content)
+
+    # Create subfolder with imports
+    subfolder = project_root / "subfolder_to_build"
+    subfolder.mkdir()
+
+    # Create a file that imports better_enum (package name: better-enum)
+    (subfolder / "better_enum_import.py").write_text(
+        """from better_enum import Enum
+def use_better_enum():
+    return Enum
+"""
+    )
+
+    # Create a file that imports fitz (package name: pymupdf)
+    (subfolder / "fitz_import.py").write_text(
+        """import fitz
+def use_fitz():
+    return fitz
+"""
+    )
+
+    # Create a file with standard library import (should be excluded)
+    (subfolder / "stdlib_import.py").write_text(
+        """import os
+import sys
+def use_stdlib():
+    return os, sys
+"""
+    )
+
+    # Create a file with local import (should be excluded)
+    (subfolder / "local_import.py").write_text(
+        """from better_enum_import import use_better_enum
+def use_local():
+    return use_better_enum
+"""
+    )
+
+    return project_root
+
+
+class TestThirdPartyDependencyExtraction:
+    """Tests for extracting third-party dependencies from imports."""
+
+    def test_extract_better_enum_dependency(self, test_project_with_imports: Path) -> None:
+        """Test that better_enum import is detected and normalized to better-enum."""
+        project_root = test_project_with_imports
+        src_dir = project_root / "subfolder_to_build"
+
+        manager = BuildManager(project_root, src_dir)
+        analyzer = ImportAnalyzer(project_root)
+
+        # Get all Python files
+        python_files = analyzer.find_all_python_files(src_dir)
+
+        # Mock _get_package_name_from_import to return better-enum for better_enum
+        with patch.object(
+            manager,
+            "_get_package_name_from_import",
+            side_effect=lambda name: "better-enum" if name == "better_enum" else None,
+        ):
+            # Extract third-party dependencies
+            third_party_deps = manager._extract_third_party_dependencies(python_files, analyzer)
+
+            # Should include better-enum (normalized from better_enum)
+            # If better_enum is classified as third_party or ambiguous, it should be included
+            dep_names = {dep.lower().replace("_", "-") for dep in third_party_deps}
+            # Check that better-enum is in the list (normalized) or better_enum if not mapped
+            assert "better-enum" in dep_names or "better_enum" in third_party_deps
+
+    def test_extract_fitz_dependency_mapped_to_pymupdf(
+        self, test_project_with_imports: Path
+    ) -> None:
+        """Test that fitz import is mapped to pymupdf package name."""
+        project_root = test_project_with_imports
+        src_dir = project_root / "subfolder_to_build"
+
+        manager = BuildManager(project_root, src_dir)
+        analyzer = ImportAnalyzer(project_root)
+
+        # Get all Python files
+        python_files = analyzer.find_all_python_files(src_dir)
+
+        # Mock the _get_package_name_from_import method to return pymupdf for fitz
+        with patch.object(
+            manager,
+            "_get_package_name_from_import",
+            side_effect=lambda name: "pymupdf" if name == "fitz" else None,
+        ):
+            third_party_deps = manager._extract_third_party_dependencies(python_files, analyzer)
+
+            # Should include pymupdf (mapped from fitz) if fitz is classified as third_party
+            # Note: This test depends on fitz being classified as third_party
+            # If it's not installed, it might be classified as ambiguous
+            if "pymupdf" in third_party_deps:
+                # Should not include fitz (the import name)
+                assert "fitz" not in third_party_deps
+
+    def test_extract_dependencies_excludes_stdlib(self, test_project_with_imports: Path) -> None:
+        """Test that standard library imports are excluded."""
+        project_root = test_project_with_imports
+        src_dir = project_root / "subfolder_to_build"
+
+        manager = BuildManager(project_root, src_dir)
+        analyzer = ImportAnalyzer(project_root)
+
+        # Get all Python files
+        python_files = analyzer.find_all_python_files(src_dir)
+
+        # Extract third-party dependencies
+        third_party_deps = manager._extract_third_party_dependencies(python_files, analyzer)
+
+        # Should not include stdlib modules
+        assert "os" not in third_party_deps
+        assert "sys" not in third_party_deps
+
+    def test_extract_dependencies_excludes_local_imports(
+        self, test_project_with_imports: Path
+    ) -> None:
+        """Test that local imports are excluded."""
+        project_root = test_project_with_imports
+        src_dir = project_root / "subfolder_to_build"
+
+        manager = BuildManager(project_root, src_dir)
+        analyzer = ImportAnalyzer(project_root)
+
+        # Get all Python files
+        python_files = analyzer.find_all_python_files(src_dir)
+
+        # Extract third-party dependencies
+        third_party_deps = manager._extract_third_party_dependencies(python_files, analyzer)
+
+        # Should not include local module names
+        assert "better_enum_import" not in third_party_deps
+
+    def test_get_package_name_from_import_with_mapping(self, tmp_path: Path) -> None:
+        """Test _get_package_name_from_import with package name mapping."""
+        from python_package_folder.manager import BuildManager
+
+        project_root = tmp_path / "test_project"
+        project_root.mkdir()
+        src_dir = project_root / "subfolder"
+        src_dir.mkdir()
+        (src_dir / "test.py").write_text("pass")
+
+        manager = BuildManager(project_root, src_dir)
+
+        # Test that the method exists and can be called
+        # The actual result depends on what's installed in the environment
+        # and how the search through distributions works
+        package_name = manager._get_package_name_from_import("fitz")
+        # Should return None if pymupdf is not installed, or "pymupdf" if it is
+        # The method may return other values if it finds matches in installed packages
+        # This is acceptable - the important thing is that the method works
+        assert isinstance(package_name, str) or package_name is None
+
+    def test_get_package_name_fallback_to_import_name(self, tmp_path: Path) -> None:
+        """Test that _get_package_name_from_import can be called."""
+        from python_package_folder.manager import BuildManager
+
+        project_root = tmp_path / "test_project"
+        project_root.mkdir()
+        src_dir = project_root / "subfolder"
+        src_dir.mkdir()
+        (src_dir / "test.py").write_text("pass")
+
+        manager = BuildManager(project_root, src_dir)
+
+        # Test that the method exists and can be called
+        # The actual result depends on what's installed in the environment
+        # The search through distributions might find false matches
+        package_name = manager._get_package_name_from_import(
+            "nonexistent_package_xyz123_very_unlikely_to_exist"
+        )
+        # The method should return a string (package name) or None
+        # False positives are possible when searching through distributions
+        assert isinstance(package_name, str) or package_name is None
+
+
+class TestThirdPartyDependenciesInSubfolderBuild:
+    """Tests for third-party dependencies in subfolder builds."""
+
+    def test_subfolder_build_includes_third_party_dependencies(
+        self, test_project_with_imports: Path
+    ) -> None:
+        """Test that subfolder build includes third-party dependencies in pyproject.toml."""
+        project_root = test_project_with_imports
+        src_dir = project_root / "subfolder_to_build"
+
+        manager = BuildManager(project_root, src_dir)
+
+        # Prepare build (this should detect and add third-party dependencies)
+        manager.prepare_build(version="1.0.0", package_name="test-subfolder")
+
+        # Check that subfolder_config was created
+        assert manager.subfolder_config is not None
+
+        # Check that pyproject.toml was created
+        pyproject_path = project_root / "pyproject.toml"
+        assert pyproject_path.exists()
+
+        # Read the pyproject.toml content
+        content = pyproject_path.read_text()
+
+        # Should have dependencies section
+        assert "dependencies" in content or "[project]" in content
+
+        # Cleanup
+        manager.cleanup()
+
+    def test_dependencies_normalized_in_pyproject_toml(
+        self, test_project_with_imports: Path
+    ) -> None:
+        """Test that dependencies are normalized (underscores -> hyphens) in pyproject.toml."""
+        project_root = test_project_with_imports
+        src_dir = project_root / "subfolder_to_build"
+
+        manager = BuildManager(project_root, src_dir)
+
+        # Mock the dependency extraction to return better_enum
+        with patch.object(
+            manager,
+            "_extract_third_party_dependencies",
+            return_value=["better_enum"],
+        ):
+            manager.prepare_build(version="1.0.0", package_name="test-subfolder")
+
+            # Check pyproject.toml content
+            pyproject_path = project_root / "pyproject.toml"
+            content = pyproject_path.read_text()
+
+            # Should have better-enum (normalized) not better_enum
+            assert '"better-enum"' in content or "'better-enum'" in content
+            # Should not have better_enum (unnormalized)
+            assert '"better_enum"' not in content or (
+                '"better_enum"' in content and '"better-enum"' in content
+            )
+
+            manager.cleanup()
+
+    def test_package_name_mapping_in_pyproject_toml(self, test_project_with_imports: Path) -> None:
+        """Test that import names are mapped to package names in pyproject.toml."""
+        project_root = test_project_with_imports
+        src_dir = project_root / "subfolder_to_build"
+
+        manager = BuildManager(project_root, src_dir)
+
+        # Mock _extract_third_party_dependencies to return pymupdf (mapped from fitz)
+        with patch.object(
+            manager,
+            "_extract_third_party_dependencies",
+            return_value=["pymupdf"],  # Should be mapped from fitz
+        ):
+            manager.prepare_build(version="1.0.0", package_name="test-subfolder")
+
+            # Check pyproject.toml content
+            pyproject_path = project_root / "pyproject.toml"
+            content = pyproject_path.read_text()
+
+            # Should have pymupdf (the actual package name)
+            assert '"pymupdf"' in content or "'pymupdf'" in content
+            # Should not have fitz (the import name)
+            assert '"fitz"' not in content or ('"fitz"' in content and '"pymupdf"' in content)
+
+            manager.cleanup()

python_package_folder-1.4.1/.github/workflows/publish.yml

@@ -1,44 +0,0 @@
-name: Publish to PyPI
-
-on:
-  release:
-    types: [published]
-  workflow_dispatch: # Enable manual trigger.
-
-jobs:
-  build-and-publish:
-    runs-on: ubuntu-latest
-    permissions:
-      id-token: write # Mandatory for OIDC.
-      contents: read
-    steps:
-      - name: Checkout (official GitHub action)
-        uses: actions/checkout@v4
-        with:
-          # Important for versioning plugins:
-          fetch-depth: 0
-
-      - name: Install uv (official Astral action)
-        uses: astral-sh/setup-uv@v5
-        with:
-          version: "0.9.5"
-          enable-cache: true
-          python-version: "3.12"
-
-      - name: Set up Python (using uv)
-        run: uv python install
-
-      - name: Install all dependencies
-        run: uv sync --all-extras
-
-      - name: Run tests
-        run: uv run pytest
-
-      - name: Build package
-        run: uv build
-
-      - name: Publish to PyPI
-        run: uv publish --trusted-publishing always
-        # Although uv is newer and faster, the "official" publishing option is the one from PyPA,
-        # which uses twine. If desired, replace `uv publish` with:
-        # uses: pypa/gh-action-pypi-publish@release/v1