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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 1.2.0
+Version: 1.2.1
 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>
@@ -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
@@ -811,11 +813,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.1}/README.md

@@ -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
@@ -791,11 +793,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.1}/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.0 → python_package_folder-1.2.1}/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.1}/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.1}/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.1}/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.1}/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()