python-package-folder 1.2.1__tar.gz → 1.2.3__tar.gz

python_package_folder-1.2.3/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: python-package-folder
+Version: 1.2.3
+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.1 → python_package_folder-1.2.3}/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],

{python_package_folder-1.2.1 → python_package_folder-1.2.3}/src/python_package_folder/publisher.py

@@ -41,12 +41,15 @@ class Publisher:
     This class manages the publishing process, including credential handling
     and repository configuration. It uses twine under the hood for actual publishing.
 
+    Credentials are not stored - they must be provided via command-line arguments
+    or will be prompted each time. This ensures credentials are not persisted.
+
     Attributes:
         repository: Target repository for publishing
         dist_dir: Directory containing built distribution files
         repository_url: Custom repository URL (for Azure or custom PyPI servers)
-        username: Username for authentication (optional, can be prompted)
-        password: Password/token for authentication (optional, can be prompted)
+        username: Username for authentication (optional, will be prompted if not provided)
+        password: Password/token for authentication (optional, will be prompted if not provided)
     """
 
     def __init__(
@@ -109,8 +112,9 @@ class Publisher:
         """
         Get credentials for publishing.
 
-        Prompts for username and password/token if not already provided.
-        Uses keyring if available to store/retrieve credentials securely.
+        Always prompts for username and password/token if not already provided.
+        Does not use keyring to store/retrieve credentials - credentials must be
+        provided via command-line arguments or will be prompted each time.
 
         Returns:
             Tuple of (username, password/token)
@@ -118,24 +122,8 @@ class Publisher:
         username = self.username
         password = self.password
 
-        # Try to get from keyring if available
-        if keyring and not username:
-            try:
-                username = keyring.get_password(
-                    f"python-package-folder-{self.repository.value}", "username"
-                )
-            except Exception:
-                pass
-
-        if keyring and not password:
-            try:
-                password = keyring.get_password(
-                    f"python-package-folder-{self.repository.value}", username or "token"
-                )
-            except Exception:
-                pass
-
-        # Prompt if still not available
+        # Always prompt if not provided via command-line arguments
+        # We don't use keyring to avoid storing credentials
         if not username:
             username = input(f"Enter username for {self.repository.value}: ").strip()
             if not username:
@@ -160,18 +148,7 @@ class Publisher:
                 )
                 username = "__token__"
 
-        # Store in keyring if available
-        if keyring:
-            try:
-                keyring.set_password(
-                    f"python-package-folder-{self.repository.value}", "username", username
-                )
-                keyring.set_password(
-                    f"python-package-folder-{self.repository.value}", username, password
-                )
-            except Exception:
-                # Keyring storage is optional, continue if it fails
-                pass
+        # Do not store in keyring - credentials are not persisted
 
         return username, password
 
@@ -253,6 +230,9 @@ class Publisher:
         cmd = ["twine", "upload"]
         if skip_existing:
             cmd.append("--skip-existing")
+        # Always use verbose for Azure Artifacts to get better error details
+        if self.repository == Repository.AZURE:
+            cmd.append("--verbose")
         cmd.extend(["--repository-url", repo_url])
         cmd.extend(["--username", username])
         cmd.extend(["--password", password])
@@ -284,6 +264,31 @@ class Publisher:
         self.password = None
         self.publish(skip_existing=skip_existing)
 
+    def clear_stored_credentials(self) -> None:
+        """
+        Clear any stored credentials from keyring for this repository.
+
+        This method can be used to remove previously stored credentials.
+        Note: The current implementation does not store credentials, but this
+        method is provided for compatibility and to clear any old stored credentials.
+        """
+        if keyring:
+            try:
+                service_name = f"python-package-folder-{self.repository.value}"
+                # Try to get and delete stored username
+                stored_username = keyring.get_password(service_name, "username")
+                if stored_username:
+                    try:
+                        keyring.delete_password(service_name, stored_username)
+                    except Exception:
+                        pass
+                    try:
+                        keyring.delete_password(service_name, "username")
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+
 
 def get_repository_help() -> str:
     """

{python_package_folder-1.2.1 → python_package_folder-1.2.3}/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.2.3/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.1 → python_package_folder-1.2.3}/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.1 → python_package_folder-1.2.3}/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()