python-package-folder 1.2.2__tar.gz → 1.3.0__tar.gz

python_package_folder-1.3.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: python-package-folder
+Version: 1.3.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>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: <4.0,>=3.11
+Description-Content-Type: text/markdown
+
+# Example subfolder 
+
+Example subfolder built and published with https://github.com/alelom/python-package-folder.

{python_package_folder-1.2.2 → python_package_folder-1.3.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">68%</text>
+    <text x="81" y="14">68%</text>
   </g>
 </svg>

{python_package_folder-1.2.2 → python_package_folder-1.3.0}/src/python_package_folder/manager.py

@@ -415,7 +415,9 @@ class BuildManager:
 
         This method removes all files and directories that were copied during prepare_build().
         It also restores the original pyproject.toml if a temporary one was created for a
-        subfolder build. It handles errors gracefully and clears the internal tracking lists.
+        subfolder build. Additionally, it removes all .egg-info directories created during
+        the build process and cleans up any empty directories that remain after removing
+        copied files. It handles errors gracefully and clears the internal tracking lists.
 
         This is automatically called by run_build(), but you can call it manually if you
         use prepare_build() directly.
@@ -425,7 +427,7 @@ class BuildManager:
             manager = BuildManager(project_root=Path("."), src_dir=Path("src"))
             deps = manager.prepare_build()
             # ... do your build ...
-            manager.cleanup()  # Restores pyproject.toml and removes copied files
+            manager.cleanup()  # Restores pyproject.toml, removes copied files, .egg-info dirs, and empty dirs
             ```
         """
         # Restore subfolder config if it was created
@@ -458,6 +460,77 @@ class BuildManager:
         self.copied_files.clear()
         self.copied_dirs.clear()
 
+        # Remove all .egg-info directories in src_dir and project_root
+        self._cleanup_egg_info_dirs()
+
+        # Remove empty directories that may remain after cleanup
+        self._cleanup_empty_dirs()
+
+    def _cleanup_egg_info_dirs(self) -> None:
+        """
+        Remove all .egg-info directories in the source directory and project root.
+
+        These directories are created by setuptools during the build process and
+        should be cleaned up after the build completes.
+        """
+        # Search in src_dir and project_root
+        search_dirs = [self.src_dir, self.project_root]
+
+        for search_dir in search_dirs:
+            if not search_dir.exists():
+                continue
+
+            # Find all .egg-info directories
+            for egg_info_dir in search_dir.rglob("*.egg-info"):
+                if egg_info_dir.is_dir():
+                    try:
+                        shutil.rmtree(egg_info_dir)
+                        print(f"Removed .egg-info directory: {egg_info_dir}")
+                    except Exception as e:
+                        print(
+                            f"Warning: Could not remove .egg-info directory {egg_info_dir}: {e}",
+                            file=sys.stderr,
+                        )
+
+    def _cleanup_empty_dirs(self) -> None:
+        """
+        Remove empty directories in the source directory after cleanup.
+
+        After removing copied files and directories, some parent directories may
+        become empty. This method recursively removes empty directories starting
+        from the deepest level.
+        """
+        if not self.src_dir.exists():
+            return
+
+        # Collect all directories in src_dir, sorted by depth (deepest first)
+        all_dirs: list[Path] = []
+        for item in self.src_dir.rglob("*"):
+            if item.is_dir():
+                all_dirs.append(item)
+
+        # Sort by path depth (deepest first) so we remove children before parents
+        all_dirs.sort(key=lambda p: len(p.parts), reverse=True)
+
+        # Remove empty directories (but not src_dir itself)
+        for dir_path in all_dirs:
+            if dir_path == self.src_dir:
+                continue
+
+            try:
+                # Check if directory is empty
+                if dir_path.exists() and not any(dir_path.iterdir()):
+                    dir_path.rmdir()
+                    print(f"Removed empty directory: {dir_path}")
+            except (OSError, PermissionError):
+                # Directory not empty or permission error - skip it
+                pass
+            except Exception as e:
+                print(
+                    f"Warning: Could not remove directory {dir_path}: {e}",
+                    file=sys.stderr,
+                )
+
     def run_build(
         self,
         build_command: Callable[[], None],
@@ -604,6 +677,7 @@ class BuildManager:
                 # Determine package name and version for filtering
                 publish_package_name = None
                 publish_version = version
+                publish_package_name = None
                 is_subfolder_build = self._is_subfolder_build()
 
                 if is_subfolder_build:

{python_package_folder-1.2.2 → python_package_folder-1.3.0}/src/python_package_folder/publisher.py

@@ -201,13 +201,21 @@ class Publisher:
                     # Handle .tar.gz files
                     stem = stem[:-4]  # Remove .tar
 
-                # Check if filename starts with any name variant followed by version
+                # Check if filename matches any name variant with exact version
                 matches = False
                 for name_variant in name_variants:
                     # Pattern: {name}-{version} or {name}-{version}-{tag}
-                    if stem.startswith(f"{name_variant}-{version_str}"):
-                        matches = True
-                        break
+                    # Use exact match: must start with name-version and next char (if any) must be - or end of string
+                    expected_prefix = f"{name_variant}-{version_str}"
+                    if stem.startswith(expected_prefix):
+                        # Ensure exact version match (not a longer version like 1.0.10 matching 1.0.1)
+                        # Check that after the version, we have either:
+                        # - End of string (for source dists: name-version)
+                        # - A hyphen followed by more characters (for wheels: name-version-tag)
+                        remaining = stem[len(expected_prefix) :]
+                        if not remaining or remaining.startswith("-"):
+                            matches = True
+                            break
 
                 if matches:
                     dist_files.append(f)

{python_package_folder-1.2.2 → python_package_folder-1.3.0}/src/python_package_folder/subfolder_build.py

@@ -36,6 +36,8 @@ class SubfolderBuildConfig:
     - Always ensures [build-system] section uses hatchling (replaces any existing build-system
       configuration from parent or subfolder)
     - Handles README files similarly (uses subfolder README if present)
+    - **Never modifies the root pyproject.toml**: The original file is temporarily moved to
+      pyproject.toml.original and restored after the build, ensuring the original is never modified
     """
 
     def __init__(
@@ -66,6 +68,7 @@ class SubfolderBuildConfig:
         self.dependency_group = dependency_group
         self.temp_pyproject: Path | None = None
         self.original_pyproject_backup: Path | None = None
+        self.original_pyproject_path: Path | None = None
         self._temp_init_created = False
         self.temp_readme: Path | None = None
         self.original_readme_backup: Path | None = None
@@ -205,6 +208,10 @@ class SubfolderBuildConfig:
         The [build-system] section is always set to use hatchling, even if the parent or
         subfolder pyproject.toml uses a different build backend (e.g., setuptools).
 
+        **Important**: The root pyproject.toml is never modified. Instead, it is temporarily
+        moved to pyproject.toml.original and restored after the build completes. This ensures
+        the original file remains unchanged.
+
         Returns:
             Path to the pyproject.toml file (either from subfolder or created temporary),
             or None if no parent pyproject.toml exists (in which case subfolder config is skipped)
@@ -228,20 +235,30 @@ class SubfolderBuildConfig:
             print(f"Using existing pyproject.toml from subfolder: {subfolder_pyproject}")
             self._used_subfolder_pyproject = True
 
-            # Backup the original project root pyproject.toml if it exists
+            # Store reference to original project root pyproject.toml
             original_pyproject = self.project_root / "pyproject.toml"
-            if original_pyproject.exists():
-                backup_path = self.project_root / "pyproject.toml.backup"
-                shutil.copy2(original_pyproject, backup_path)
-                self.original_pyproject_backup = backup_path
+            self.original_pyproject_path = original_pyproject
+
+            # Create temporary pyproject.toml file
+            temp_pyproject_path = self.project_root / "pyproject.toml.temp"
 
             # Read and adjust the subfolder pyproject.toml
             subfolder_content = subfolder_pyproject.read_text(encoding="utf-8")
             # Adjust packages path to be relative to project root
             adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
 
-            # Write adjusted content to project root
-            original_pyproject.write_text(adjusted_content, encoding="utf-8")
+            # Write adjusted content to temporary file
+            temp_pyproject_path.write_text(adjusted_content, encoding="utf-8")
+            self.temp_pyproject = temp_pyproject_path
+
+            # If original pyproject.toml exists, temporarily move it
+            if original_pyproject.exists():
+                backup_path = self.project_root / "pyproject.toml.original"
+                original_pyproject.rename(backup_path)
+                self.original_pyproject_backup = backup_path
+
+            # Move temp file to pyproject.toml for the build
+            temp_pyproject_path.rename(original_pyproject)
             self.temp_pyproject = original_pyproject
 
             # Handle README file
@@ -270,9 +287,12 @@ class SubfolderBuildConfig:
 
         original_content = original_pyproject.read_text(encoding="utf-8")
 
-        # Create a backup
-        backup_path = self.project_root / "pyproject.toml.backup"
-        shutil.copy2(original_pyproject, backup_path)
+        # Store reference to original
+        self.original_pyproject_path = original_pyproject
+
+        # Temporarily move original to backup location
+        backup_path = self.project_root / "pyproject.toml.original"
+        original_pyproject.rename(backup_path)
         self.original_pyproject_backup = backup_path
 
         # Parse and modify the pyproject.toml
@@ -327,8 +347,12 @@ class SubfolderBuildConfig:
                 original_content, parent_dependency_group
             )
 
-        # Write the modified content
-        original_pyproject.write_text(modified_content, encoding="utf-8")
+        # Write the modified content to a temporary file
+        temp_pyproject_path = self.project_root / "pyproject.toml.temp"
+        temp_pyproject_path.write_text(modified_content, encoding="utf-8")
+
+        # Move temp file to pyproject.toml for the build
+        temp_pyproject_path.rename(original_pyproject)
         self.temp_pyproject = original_pyproject
 
         # Handle README file
@@ -585,9 +609,10 @@ class SubfolderBuildConfig:
         """
         Restore the original pyproject.toml and remove temporary __init__.py if created.
 
-        If a subfolder pyproject.toml was used, it restores the original project root
-        pyproject.toml from backup. If a temporary pyproject.toml was created, it
-        restores the original as well.
+        The root pyproject.toml is never modified during subfolder builds. Instead, it is
+        temporarily moved to pyproject.toml.original and then restored after the build.
+        This method removes the temporary pyproject.toml and restores the original from
+        the backup location, ensuring the original file is never modified.
         """
         # Remove temporary __init__.py if we created it
         if self._temp_init_created:
@@ -630,16 +655,26 @@ class SubfolderBuildConfig:
             self.temp_readme = None
 
         # Restore original pyproject.toml (only if we created/used one)
-        if (
-            self.temp_pyproject
-            and self.original_pyproject_backup
-            and self.original_pyproject_backup.exists()
-        ):
-            original_pyproject = self.project_root / "pyproject.toml"
-            shutil.copy2(self.original_pyproject_backup, original_pyproject)
-            self.original_pyproject_backup.unlink()
-            self.original_pyproject_backup = None
+        if self.temp_pyproject and self.original_pyproject_path:
+            original_pyproject = self.original_pyproject_path
+
+            # Remove the temporary pyproject.toml we created
+            if original_pyproject.exists():
+                try:
+                    original_pyproject.unlink()
+                except Exception as e:
+                    print(
+                        f"Warning: Could not remove temporary pyproject.toml: {e}",
+                        file=sys.stderr,
+                    )
+
+            # Restore the original pyproject.toml from backup if it existed
+            if self.original_pyproject_backup and self.original_pyproject_backup.exists():
+                self.original_pyproject_backup.rename(original_pyproject)
+                self.original_pyproject_backup = None
+
             self.temp_pyproject = None
+            self.original_pyproject_path = None
             self._used_subfolder_pyproject = False
 
     def __enter__(self) -> Self:

python_package_folder-1.3.0/tests/folder_structure/subfolder_to_build/README.md

@@ -0,0 +1,3 @@
+# Example subfolder 
+
+Example subfolder built and published with https://github.com/alelom/python-package-folder.

{python_package_folder-1.2.2 → python_package_folder-1.3.0}/tests/test_build_with_external_deps.py

@@ -277,6 +277,36 @@ class TestBuildManager:
         assert len(manager.copied_files) == 0
         assert len(manager.copied_dirs) == 0
 
+    def test_cleanup_removes_egg_info_dirs(self, test_project_root: Path) -> None:
+        """Test that cleanup removes .egg-info directories."""
+        src_dir = test_project_root / "folder_structure" / "subfolder_to_build"
+        manager = BuildManager(test_project_root, src_dir)
+
+        # Create a fake .egg-info directory
+        egg_info_dir = src_dir / "package.egg-info"
+        egg_info_dir.mkdir()
+        (egg_info_dir / "PKG-INFO").write_text("test")
+
+        manager.cleanup()
+
+        # Verify .egg-info directory was removed
+        assert not egg_info_dir.exists()
+
+    def test_cleanup_removes_empty_dirs(self, test_project_root: Path) -> None:
+        """Test that cleanup removes empty directories."""
+        src_dir = test_project_root / "folder_structure" / "subfolder_to_build"
+        manager = BuildManager(test_project_root, src_dir)
+
+        # Create a nested empty directory structure
+        empty_dir = src_dir / "empty_parent" / "empty_child"
+        empty_dir.mkdir(parents=True)
+
+        manager.cleanup()
+
+        # Verify empty directories were removed
+        assert not empty_dir.exists()
+        assert not (src_dir / "empty_parent").exists()
+
     def test_cleanup_handles_missing_files(self, test_project_root: Path) -> None:
         """Test that cleanup handles already-removed files gracefully."""
         src_dir = test_project_root / "folder_structure" / "subfolder_to_build"

{python_package_folder-1.2.2 → python_package_folder-1.3.0}/tests/test_publisher.py

@@ -19,6 +19,9 @@ def test_dist_dir(tmp_path: Path) -> Path:
     # Create some distribution files
     (dist_dir / "package-1.0.0-py3-none-any.whl").write_text("fake wheel")
     (dist_dir / "package-1.0.0.tar.gz").write_text("fake source")
+    (dist_dir / "package-1.0.1-py3-none-any.whl").write_text("fake wheel")
+    (dist_dir / "package-1.0.1.tar.gz").write_text("fake source")
+    (dist_dir / "package-1.0.10-py3-none-any.whl").write_text("fake wheel")
     (dist_dir / "other-package-2.0.0-py3-none-any.whl").write_text("fake wheel")
 
     return dist_dir
@@ -125,6 +128,30 @@ class TestPublisher:
             assert all("package-1.0.0" in str(f) for f in file_args)
             assert not any("other-package" in str(f) for f in file_args)
 
+    def test_publish_filters_exact_version(self, test_dist_dir: Path) -> None:
+        """Test that publish filters files by exact version (not partial matches)."""
+        publisher = Publisher(
+            repository=Repository.PYPI,
+            dist_dir=test_dist_dir,
+            package_name="package",
+            version="1.0.1",
+        )
+
+        with patch("python_package_folder.publisher.subprocess.run") as mock_run:
+            mock_run.return_value = MagicMock(returncode=0)
+
+            with patch.object(publisher, "_get_credentials", return_value=("user", "pass")):
+                publisher.publish()
+
+            call_args = mock_run.call_args[0][0]
+            file_args = [arg for arg in call_args if str(test_dist_dir) in str(arg)]
+
+            # Should only include 1.0.1 files, not 1.0.0 or 1.0.10
+            assert all("1.0.1" in str(f) for f in file_args)
+            assert not any("1.0.0" in str(f) for f in file_args)
+            assert not any("1.0.10" in str(f) for f in file_args)
+            assert len(file_args) == 2  # wheel and source dist
+
     def test_publish_filters_by_version(self, test_dist_dir: Path) -> None:
         """Test that publish filters files by version."""
         publisher = Publisher(
@@ -143,8 +170,11 @@ class TestPublisher:
             call_args = mock_run.call_args[0][0]
             file_args = [arg for arg in call_args if str(test_dist_dir) in str(arg)]
 
-            # Should only include 1.0.0 files, not 2.0.0
+            # Should only include 1.0.0 files, not 1.0.1, 1.0.10, or 2.0.0
             assert all("1.0.0" in str(f) for f in file_args)
+            assert not any("1.0.1" in str(f) for f in file_args)
+            assert not any("1.0.10" in str(f) for f in file_args)
+            assert not any("2.0.0" in str(f) for f in file_args)
 
     def test_publish_no_filtering(self, test_dist_dir: Path) -> None:
         """Test that publish includes all files when no filter specified."""
@@ -162,8 +192,8 @@ class TestPublisher:
             call_args = mock_run.call_args[0][0]
             file_args = [arg for arg in call_args if str(test_dist_dir) in str(arg)]
 
-            # Should include all distribution files
-            assert len(file_args) == 3
+            # Should include all distribution files (6 files: 4 wheels + 2 source dists)
+            assert len(file_args) == 6
 
     def test_publish_raises_when_no_files(self, tmp_path: Path) -> None:
         """Test that publish raises when no distribution files found."""

{python_package_folder-1.2.2 → python_package_folder-1.3.0}/tests/test_subfolder_build.py

@@ -169,7 +169,7 @@ class TestSubfolderBuildConfig:
         assert restored_content == original_content
 
         # Check backup is removed
-        assert not (test_project_with_pyproject / "pyproject.toml.backup").exists()
+        assert not (test_project_with_pyproject / "pyproject.toml.original").exists()
 
     def test_restore_removes_temp_init(self, test_project_with_pyproject: Path) -> None:
         """Test that restore removes temporary __init__.py."""
@@ -405,9 +405,9 @@ requests = ">=2.0.0"
         assert 'name = "test-package"' not in content
         assert 'name = "subfolder"' not in content
 
-        # Verify backup was created
-        assert (project_root / "pyproject.toml.backup").exists()
-        backup_content = (project_root / "pyproject.toml.backup").read_text()
+        # Verify original was moved to backup location
+        assert (project_root / "pyproject.toml.original").exists()
+        backup_content = (project_root / "pyproject.toml.original").read_text()
         assert 'name = "test-package"' in backup_content
 
         # Verify flag is set
@@ -434,6 +434,11 @@ requests = ">=2.0.0"
         )
 
         config.create_temp_pyproject()
+
+        # Verify original content is preserved in backup (not modified)
+        backup_content = (project_root / "pyproject.toml.original").read_text()
+        assert backup_content == original_content
+
         config.restore()
 
         # Verify original is restored
@@ -441,7 +446,43 @@ requests = ">=2.0.0"
         assert restored_content == original_content
 
         # Verify backup is removed
-        assert not (project_root / "pyproject.toml.backup").exists()
+        assert not (project_root / "pyproject.toml.original").exists()
+
+    def test_root_pyproject_toml_never_modified(self, test_project_with_pyproject: Path) -> None:
+        """Test that root pyproject.toml is never modified, only moved and restored."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        original_pyproject = project_root / "pyproject.toml"
+        original_content = original_pyproject.read_text()
+
+        # Create pyproject.toml in subfolder
+        (subfolder / "pyproject.toml").write_text(
+            '[project]\nname = "subfolder-package"\nversion = "3.0.0"\n'
+        )
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        config.create_temp_pyproject()
+
+        # Verify original was moved (not modified in place)
+        assert not original_pyproject.exists() or original_pyproject.read_text() != original_content
+        assert (project_root / "pyproject.toml.original").exists()
+        backup_content = (project_root / "pyproject.toml.original").read_text()
+        assert backup_content == original_content  # Original content preserved exactly
+
+        config.restore()
+
+        # Verify original is restored with exact same content
+        assert original_pyproject.exists()
+        restored_content = original_pyproject.read_text()
+        assert restored_content == original_content
+
+        # Verify backup is removed
+        assert not (project_root / "pyproject.toml.original").exists()
 
     def test_subfolder_pyproject_toml_without_parent_backup(
         self, test_project_with_pyproject: Path
@@ -477,7 +518,7 @@ version = "3.0.0"
         assert 'name = "subfolder-package"' in content
 
         # No backup should be created since parent didn't exist
-        assert not (project_root / "pyproject.toml.backup").exists()
+        assert not (project_root / "pyproject.toml.original").exists()
 
         # Restore original for cleanup
         parent_pyproject.write_text(original_content)
@@ -596,7 +637,7 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
         assert 'packages = ["subfolder"]' in content or '"subfolder"' in content
 
         # Verify backup was created
-        assert (project_root / "pyproject.toml.backup").exists()
+        assert (project_root / "pyproject.toml.original").exists()
 
         # Cleanup
         config.restore()