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

{python_package_folder-1.2.0 → python_package_folder-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 1.2.0
+Version: 1.2.2
 Summary: Python package to automatically package and build a folder, fetching all relevant dependencies.
 Project-URL: Repository, https://github.com/alelom/python-package-folder
 Author-email: Alessio Lombardi <work@alelom.com>
@@ -229,8 +229,8 @@ python-package-folder --project-root /path/to/project --src-dir /path/to/src --b
 1. **Build Verification**: Ensures distribution files exist in the `dist/` directory
 2. **File Filtering**: Automatically filters distribution files to only include those matching the current package name and version (prevents uploading old artifacts)
 3. **Credential Management**: 
-   - Prompts for credentials if not provided
-   - Uses `keyring` for secure storage (if available)
+   - Prompts for credentials if not provided via command-line arguments
+   - Credentials are not stored - you'll be prompted each time (unless provided via `--username` and `--password`)
    - Supports both username/password and API tokens
    - Auto-detects API tokens and uses `__token__` as username
 4. **Repository Configuration**: Configures the target repository (PyPI, TestPyPI, or Azure)
@@ -247,6 +247,7 @@ python-package-folder --project-root /path/to/project --src-dir /path/to/src --b
    - If found, copies the subfolder README to project root (backing up the original parent README)
    - If not found, creates a minimal README with just the folder name
 5. **Configuration Creation**: Creates temporary `pyproject.toml` with:
+   - `[build-system]` section using hatchling (replaces any existing build-system configuration)
    - Subfolder-specific package name (derived or custom)
    - Specified version
    - Correct package path for hatchling
@@ -278,8 +279,9 @@ The tool automatically:
 - Uses the current directory as the source directory if it contains Python files
 - Falls back to `project_root/src` if the current directory isn't suitable
 - **For subfolder builds**: Handles `pyproject.toml` configuration:
-  - **If `pyproject.toml` exists in subfolder**: Uses that file (copies it to project root temporarily)
+  - **If `pyproject.toml` exists in subfolder**: Uses that file (copies it to project root temporarily, adjusting package paths and ensuring `[build-system]` uses hatchling)
   - **If no `pyproject.toml` in subfolder**: Creates a temporary `pyproject.toml` with:
+    - `[build-system]` section using hatchling (always uses hatchling, even if parent uses setuptools)
     - Package name derived from the subfolder name (e.g., `empty_drawing_detection` → `empty-drawing-detection`)
     - Version from `--version` argument (defaults to `0.0.0` with a warning if not provided)
     - Proper package path configuration for hatchling
@@ -637,11 +639,22 @@ publisher.publish()
 
 ### Credential Storage
 
-The package uses the `keyring` library (if installed) to securely store credentials. Credentials are stored per repository and will be reused on subsequent runs.
+**Note**: The package does not store credentials by default. Credentials must be provided via command-line arguments (`--username` and `--password`) or will be prompted each time you run the publish command. This ensures credentials are not persisted and must be entered fresh each time.
 
-Install keyring for secure credential storage:
-```bash
-pip install keyring
+If you previously used an older version that stored credentials in keyring, you can clear them using:
+
+```python
+from python_package_folder import Publisher, Repository
+
+publisher = Publisher(repository=Repository.AZURE)
+publisher.clear_stored_credentials()
+```
+
+Or manually using Python:
+```python
+import keyring
+keyring.delete_password("python-package-folder-azure", "username")
+# Also delete the password if you know the username
 ```
 
 ## Command Line Options
@@ -811,11 +824,11 @@ config.restore()
 ```
 
 **Methods:**
-- `create_temp_pyproject() -> Path`: Use subfolder's `pyproject.toml` if it exists, otherwise create temporary `pyproject.toml` with subfolder-specific configuration
+- `create_temp_pyproject() -> Path`: Use subfolder's `pyproject.toml` if it exists (adjusting package paths and ensuring `[build-system]` uses hatchling), otherwise create temporary `pyproject.toml` with subfolder-specific configuration including `[build-system]` section using hatchling
 - `restore() -> None`: Restore original `pyproject.toml` and clean up temporary files
 
 **Note**: This class automatically:
-- **pyproject.toml handling**: If a `pyproject.toml` exists in the subfolder, it will be used (copied to project root temporarily). Otherwise, creates a temporary one from the parent configuration.
+- **pyproject.toml handling**: If a `pyproject.toml` exists in the subfolder, it will be used (copied to project root temporarily with adjusted package paths). Otherwise, creates a temporary one from the parent configuration. In both cases, the `[build-system]` section is always set to use hatchling, replacing any existing build-system configuration.
 - **README handling**: If a README exists in the subfolder, it will be used instead of the parent README. If no README exists in the subfolder, a minimal README with just the folder name will be created. The original parent README is backed up and restored after the build completes.
 - **Package initialization**: Creates `__init__.py` files if needed to make subfolders valid Python packages.
 

{python_package_folder-1.2.0 → python_package_folder-1.2.2}/README.md

@@ -209,8 +209,8 @@ python-package-folder --project-root /path/to/project --src-dir /path/to/src --b
 1. **Build Verification**: Ensures distribution files exist in the `dist/` directory
 2. **File Filtering**: Automatically filters distribution files to only include those matching the current package name and version (prevents uploading old artifacts)
 3. **Credential Management**: 
-   - Prompts for credentials if not provided
-   - Uses `keyring` for secure storage (if available)
+   - Prompts for credentials if not provided via command-line arguments
+   - Credentials are not stored - you'll be prompted each time (unless provided via `--username` and `--password`)
    - Supports both username/password and API tokens
    - Auto-detects API tokens and uses `__token__` as username
 4. **Repository Configuration**: Configures the target repository (PyPI, TestPyPI, or Azure)
@@ -227,6 +227,7 @@ python-package-folder --project-root /path/to/project --src-dir /path/to/src --b
    - If found, copies the subfolder README to project root (backing up the original parent README)
    - If not found, creates a minimal README with just the folder name
 5. **Configuration Creation**: Creates temporary `pyproject.toml` with:
+   - `[build-system]` section using hatchling (replaces any existing build-system configuration)
    - Subfolder-specific package name (derived or custom)
    - Specified version
    - Correct package path for hatchling
@@ -258,8 +259,9 @@ The tool automatically:
 - Uses the current directory as the source directory if it contains Python files
 - Falls back to `project_root/src` if the current directory isn't suitable
 - **For subfolder builds**: Handles `pyproject.toml` configuration:
-  - **If `pyproject.toml` exists in subfolder**: Uses that file (copies it to project root temporarily)
+  - **If `pyproject.toml` exists in subfolder**: Uses that file (copies it to project root temporarily, adjusting package paths and ensuring `[build-system]` uses hatchling)
   - **If no `pyproject.toml` in subfolder**: Creates a temporary `pyproject.toml` with:
+    - `[build-system]` section using hatchling (always uses hatchling, even if parent uses setuptools)
     - Package name derived from the subfolder name (e.g., `empty_drawing_detection` → `empty-drawing-detection`)
     - Version from `--version` argument (defaults to `0.0.0` with a warning if not provided)
     - Proper package path configuration for hatchling
@@ -617,11 +619,22 @@ publisher.publish()
 
 ### Credential Storage
 
-The package uses the `keyring` library (if installed) to securely store credentials. Credentials are stored per repository and will be reused on subsequent runs.
+**Note**: The package does not store credentials by default. Credentials must be provided via command-line arguments (`--username` and `--password`) or will be prompted each time you run the publish command. This ensures credentials are not persisted and must be entered fresh each time.
 
-Install keyring for secure credential storage:
-```bash
-pip install keyring
+If you previously used an older version that stored credentials in keyring, you can clear them using:
+
+```python
+from python_package_folder import Publisher, Repository
+
+publisher = Publisher(repository=Repository.AZURE)
+publisher.clear_stored_credentials()
+```
+
+Or manually using Python:
+```python
+import keyring
+keyring.delete_password("python-package-folder-azure", "username")
+# Also delete the password if you know the username
 ```
 
 ## Command Line Options
@@ -791,11 +804,11 @@ config.restore()
 ```
 
 **Methods:**
-- `create_temp_pyproject() -> Path`: Use subfolder's `pyproject.toml` if it exists, otherwise create temporary `pyproject.toml` with subfolder-specific configuration
+- `create_temp_pyproject() -> Path`: Use subfolder's `pyproject.toml` if it exists (adjusting package paths and ensuring `[build-system]` uses hatchling), otherwise create temporary `pyproject.toml` with subfolder-specific configuration including `[build-system]` section using hatchling
 - `restore() -> None`: Restore original `pyproject.toml` and clean up temporary files
 
 **Note**: This class automatically:
-- **pyproject.toml handling**: If a `pyproject.toml` exists in the subfolder, it will be used (copied to project root temporarily). Otherwise, creates a temporary one from the parent configuration.
+- **pyproject.toml handling**: If a `pyproject.toml` exists in the subfolder, it will be used (copied to project root temporarily with adjusted package paths). Otherwise, creates a temporary one from the parent configuration. In both cases, the `[build-system]` section is always set to use hatchling, replacing any existing build-system configuration.
 - **README handling**: If a README exists in the subfolder, it will be used instead of the parent README. If no README exists in the subfolder, a minimal README with just the folder name will be created. The original parent README is backed up and restored after the build completes.
 - **Package initialization**: Creates `__init__.py` files if needed to make subfolders valid Python packages.
 

{python_package_folder-1.2.0 → python_package_folder-1.2.2}/src/python_package_folder/analyzer.py

@@ -45,13 +45,55 @@ class ImportAnalyzer:
         """
         Recursively find all Python files in a directory.
 
+        Excludes common directories like .venv, venv, __pycache__, etc.
+
         Args:
             directory: Directory to search for Python files
 
         Returns:
             List of paths to all .py files found in the directory tree
         """
-        return [path for path in directory.rglob("*.py") if path.is_file()]
+        exclude_patterns = {
+            ".venv",
+            "venv",
+            "__pycache__",
+            ".git",
+            ".pytest_cache",
+            ".mypy_cache",
+            "node_modules",
+            ".tox",
+            "dist",
+            "build",
+        }
+
+        python_files = []
+        for path in directory.rglob("*.py"):
+            if not path.is_file():
+                continue
+
+            # Check if any part of the path matches exclusion patterns
+            should_exclude = False
+            for part in path.parts:
+                # Check exact matches
+                if part in exclude_patterns:
+                    should_exclude = True
+                    break
+                # Check if part starts with excluded pattern or contains .egg-info
+                for pattern in exclude_patterns:
+                    if part.startswith(pattern):
+                        should_exclude = True
+                        break
+                # Also exclude .egg-info directories
+                if ".egg-info" in part:
+                    should_exclude = True
+                    break
+                if should_exclude:
+                    break
+
+            if not should_exclude:
+                python_files.append(path)
+
+        return python_files
 
     def extract_imports(self, file_path: Path) -> list[ImportInfo]:
         """

{python_package_folder-1.2.0 → python_package_folder-1.2.2}/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.0 → python_package_folder-1.2.2}/src/python_package_folder/python_package_folder.py

@@ -122,7 +122,8 @@ def main() -> int:
             src_dir = Path(args.src_dir).resolve()
         else:
             # Auto-detect: use current directory if it has Python files, otherwise use project_root/src
-            src_dir = find_source_directory(project_root)
+            current_dir = Path.cwd()
+            src_dir = find_source_directory(project_root, current_dir=current_dir)
             if src_dir:
                 print(f"Auto-detected source directory: {src_dir}")
             else:

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

@@ -30,8 +30,11 @@ class SubfolderBuildConfig:
     Manages temporary build configuration for subfolder builds.
 
     When building a subfolder as a separate package, this class:
-    - Uses the subfolder's pyproject.toml if it exists
+    - Uses the subfolder's pyproject.toml if it exists (adjusts package paths and ensures
+      [build-system] uses hatchling)
     - Otherwise creates a temporary pyproject.toml with the appropriate package name and version
+    - 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)
     """
 
@@ -111,13 +114,96 @@ class SubfolderBuildConfig:
         # If it's a package or has subpackages, return the path
         return packages_path, [packages_path] if packages_path else []
 
+    def _adjust_subfolder_pyproject_packages_path(self, content: str) -> str:
+        """
+        Adjust packages path in subfolder pyproject.toml to be relative to project root.
+
+        When a subfolder's pyproject.toml is copied to project root, the packages path
+        needs to be adjusted to point to the subfolder relative to the project root.
+
+        Args:
+            content: Content of the subfolder's pyproject.toml
+
+        Returns:
+            Adjusted content with correct packages path
+        """
+        # Get the correct packages path relative to project root
+        _, package_dirs = self._get_package_structure()
+        if not package_dirs:
+            # No adjustment needed if we can't determine the path
+            return content
+
+        correct_packages_path = package_dirs[0]
+        lines = content.split("\n")
+        result = []
+        in_hatch_build = False
+        packages_set = False
+
+        for line in lines:
+            # Detect hatch build section
+            if line.strip().startswith("[tool.hatch.build.targets.wheel]"):
+                in_hatch_build = True
+                result.append(line)
+                continue
+            elif line.strip().startswith("[") and in_hatch_build:
+                # End of hatch build section, add packages if not set
+                if not packages_set and correct_packages_path:
+                    packages_str = f'"{correct_packages_path}"'
+                    result.append(f"packages = [{packages_str}]")
+                in_hatch_build = False
+                result.append(line)
+            elif in_hatch_build:
+                # Modify packages path if found
+                if re.match(r"^\s*packages\s*=", line):
+                    packages_str = f'"{correct_packages_path}"'
+                    result.append(f"packages = [{packages_str}]")
+                    packages_set = True
+                    continue
+                # Keep other lines in hatch build section
+                result.append(line)
+            else:
+                result.append(line)
+
+        # Add packages if we're still in hatch build section and haven't set it
+        if in_hatch_build and not packages_set and correct_packages_path:
+            packages_str = f'"{correct_packages_path}"'
+            result.append(f"packages = [{packages_str}]")
+
+        # Ensure build-system section exists (required for hatchling)
+        # Check if build-system section exists in the result
+        has_build_system = any(line.strip().startswith("[build-system]") for line in result)
+        if not has_build_system:
+            # Insert build-system at the very beginning of the file
+            build_system_lines = [
+                "[build-system]",
+                'requires = ["hatchling"]',
+                'build-backend = "hatchling.build"',
+                "",
+            ]
+            result = build_system_lines + result
+
+        # Ensure hatch build section exists if packages path is needed
+        if not packages_set and correct_packages_path:
+            # Check if we need to add the section
+            if "[tool.hatch.build.targets.wheel]" not in content:
+                result.append("")
+                result.append("[tool.hatch.build.targets.wheel]")
+                packages_str = f'"{correct_packages_path}"'
+                result.append(f"packages = [{packages_str}]")
+
+        return "\n".join(result)
+
     def create_temp_pyproject(self) -> Path | None:
         """
         Create a temporary pyproject.toml for the subfolder build.
 
-        If a pyproject.toml exists in the subfolder, it will be used instead of creating
-        a new one. Otherwise, creates a pyproject.toml in the project root based on the
-        parent pyproject.toml with the appropriate package name and version.
+        If a pyproject.toml exists in the subfolder, it will be used (copied to project root
+        with adjusted package paths and ensuring [build-system] uses hatchling). Otherwise,
+        creates a pyproject.toml in the project root based on the parent pyproject.toml with
+        the appropriate package name and version.
+
+        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).
 
         Returns:
             Path to the pyproject.toml file (either from subfolder or created temporary),
@@ -149,8 +235,13 @@ class SubfolderBuildConfig:
                 shutil.copy2(original_pyproject, backup_path)
                 self.original_pyproject_backup = backup_path
 
-            # Copy subfolder pyproject.toml to project root
-            shutil.copy2(subfolder_pyproject, original_pyproject)
+            # 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")
             self.temp_pyproject = original_pyproject
 
             # Handle README file
@@ -259,6 +350,7 @@ class SubfolderBuildConfig:
         skip_uv_dynamic = False
         in_hatch_build = False
         packages_set = False
+        build_system_set = False
 
         # Get package structure
         packages_path, package_dirs = self._get_package_structure()
@@ -266,6 +358,19 @@ class SubfolderBuildConfig:
             package_dirs = []
 
         for _i, line in enumerate(lines):
+            # Skip build-system section - we'll add our own for subfolder builds
+            if line.strip().startswith("[build-system]"):
+                build_system_set = True
+                continue  # Skip the [build-system] line
+            elif build_system_set and line.strip().startswith("["):
+                # End of build-system section
+                build_system_set = False
+                result.append(line)
+                continue
+            elif build_system_set:
+                # Skip build-system content - we'll add our own
+                continue
+
             # Skip hatch versioning and uv-dynamic-versioning sections
             if line.strip().startswith("[tool.hatch.version]"):
                 skip_hatch_version = True
@@ -361,6 +466,19 @@ class SubfolderBuildConfig:
             packages_str = ", ".join(f'"{p}"' for p in package_dirs)
             result.append(f"packages = [{packages_str}]")
 
+        # Ensure build-system section exists (required for hatchling)
+        # Check if build-system section exists in the result
+        has_build_system = any(line.strip().startswith("[build-system]") for line in result)
+        if not has_build_system:
+            # Insert build-system at the very beginning of the file
+            build_system_lines = [
+                "[build-system]",
+                'requires = ["hatchling"]',
+                'build-backend = "hatchling.build"',
+                "",
+            ]
+            result = build_system_lines + result
+
         # Ensure packages is always set for subfolder builds
         if not packages_set and package_dirs:
             # Add the section if it doesn't exist

{python_package_folder-1.2.0 → python_package_folder-1.2.2}/src/python_package_folder/utils.py

@@ -63,7 +63,8 @@ def find_source_directory(project_root: Path, current_dir: Path | None = None) -
     project_root = project_root.resolve()
 
     # Check if current directory is a subdirectory with Python files
-    if current_dir.is_relative_to(project_root) or current_dir == project_root:
+    # Prioritize current directory if it's within the project and has Python files
+    if current_dir.is_relative_to(project_root) and current_dir != project_root:
         python_files = list(current_dir.glob("*.py"))
         if python_files:
             # Current directory has Python files, use it as source
@@ -74,10 +75,11 @@ def find_source_directory(project_root: Path, current_dir: Path | None = None) -
     if src_dir.exists() and src_dir.is_dir():
         return src_dir
 
-    # Check if project_root itself has Python files
-    python_files = list(project_root.glob("*.py"))
-    if python_files:
-        return project_root
+    # Only check project_root if current_dir is the project_root
+    if current_dir == project_root:
+        python_files = list(project_root.glob("*.py"))
+        if python_files:
+            return project_root
 
     return None
 

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

@@ -584,6 +584,11 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
 
         # Verify dynamic versioning is removed
         assert 'dynamic = ["version"]' not in content
+
+        # Verify build-system section is added (required for hatchling)
+        assert "[build-system]" in content
+        assert 'requires = ["hatchling"]' in content
+        assert 'build-backend = "hatchling.build"' in content
         assert "[tool.hatch.version]" not in content
         assert "[tool.uv-dynamic-versioning]" not in content
 
@@ -648,3 +653,71 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
         restored_content = (project_root / "pyproject.toml").read_text()
         assert restored_content == original_content
         assert 'name = "test-package"' in restored_content
+
+    def test_build_system_section_replaces_setuptools(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """Test that build-system section replaces existing setuptools configuration."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+
+        # Modify parent pyproject.toml to have setuptools build-system
+        pyproject_path = project_root / "pyproject.toml"
+        original_content = pyproject_path.read_text()
+        modified_content = (
+            original_content
+            + '\n[build-system]\nrequires = ["setuptools"]\nbuild-backend = "setuptools.build_meta"\n'
+        )
+        pyproject_path.write_text(modified_content)
+
+        try:
+            config = SubfolderBuildConfig(
+                project_root=project_root,
+                src_dir=subfolder,
+                version="1.0.0",
+            )
+
+            pyproject_path = config.create_temp_pyproject()
+            content = pyproject_path.read_text()
+
+            # Verify build-system section uses hatchling, not setuptools
+            assert "[build-system]" in content
+            assert 'requires = ["hatchling"]' in content
+            assert 'build-backend = "hatchling.build"' in content
+            assert "setuptools" not in content or 'build-backend = "setuptools' not in content
+
+            config.restore()
+        finally:
+            # Restore original content
+            pyproject_path.write_text(original_content)
+
+    def test_build_system_section_with_subfolder_pyproject(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """Test that build-system section is added when using subfolder's pyproject.toml."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+
+        # Create pyproject.toml in subfolder without build-system
+        subfolder_pyproject_content = """[project]
+name = "subfolder-package"
+version = "3.0.0"
+description = "Subfolder package"
+"""
+        (subfolder / "pyproject.toml").write_text(subfolder_pyproject_content)
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        pyproject_path = config.create_temp_pyproject()
+        content = pyproject_path.read_text()
+
+        # Verify build-system section is added
+        assert "[build-system]" in content
+        assert 'requires = ["hatchling"]' in content
+        assert 'build-backend = "hatchling.build"' in content
+
+        config.restore()