python-package-folder 1.1.3__py3-none-any.whl → 1.2.1__py3-none-any.whl

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/manager.py

@@ -85,15 +85,13 @@ class BuildManager:
         self.finder = ExternalDependencyFinder(
             self.project_root, self.src_dir, exclude_patterns=exclude_patterns
         )
+        self.subfolder_config: SubfolderBuildConfig | None = None
 
         # Check if it's a valid Python package directory
         if not any(self.src_dir.glob("*.py")) and not (self.src_dir / "__init__.py").exists():
             # Allow empty directories for now, but warn
             pass
 
-        self.copied_files: list[Path] = []
-        self.copied_dirs: list[Path] = []
-
     def find_src_package_dir(self) -> Path | None:
         """
         Find the main package directory within src/.
@@ -125,6 +123,21 @@ class BuildManager:
         # Return the first one or src_dir itself
         return package_dirs[0] if package_dirs else self.src_dir
 
+    def _is_subfolder_build(self) -> bool:
+        """
+        Check if we're building a subfolder (not the main src/ directory).
+
+        Returns:
+            True if this is a subfolder build, False otherwise
+        """
+        # Check if src_dir is not the main src/ directory
+        main_src = self.project_root / "src"
+        return (
+            self.src_dir != main_src
+            and self.src_dir != self.project_root
+            and self.src_dir.is_relative_to(self.project_root)
+        )
+
     def _get_project_name(self) -> str | None:
         """
         Get the project name from pyproject.toml.
@@ -155,19 +168,94 @@ class BuildManager:
 
         return None
 
-    def prepare_build(self) -> list[ExternalDependency]:
+    def prepare_build(
+        self,
+        version: str | None = None,
+        package_name: str | None = None,
+        dependency_group: str | None = None,
+    ) -> list[ExternalDependency]:
         """
         Prepare for build by finding and copying external dependencies.
 
-        This method:
-        1. Finds all Python files in the source directory
-        2. Analyzes them for external dependencies
-        3. Copies external files/directories into the source directory
-        4. Reports any ambiguous imports
+        This method automatically detects if you're building a subfolder (not the main src/
+        directory) and sets up pyproject.toml appropriately:
+        - If pyproject.toml exists in the subfolder, it will be used
+        - Otherwise, creates a temporary pyproject.toml with the correct package configuration
+        For subfolder builds without their own pyproject.toml, if no version is provided,
+        it defaults to "0.0.0" with a warning.
+
+        Process:
+        1. Detects if this is a subfolder build and sets up pyproject.toml if needed:
+           - If pyproject.toml exists in subfolder: uses that file
+           - If no pyproject.toml in subfolder: creates temporary one from parent
+        2. Finds all Python files in the source directory
+        3. Analyzes them for external dependencies
+        4. Copies external files/directories into the source directory
+        5. Reports any ambiguous imports
+
+        Args:
+            version: Version for subfolder builds. If building a subfolder and version is None,
+                defaults to "0.0.0" with a warning. Only used when creating temporary pyproject.toml
+                (ignored if subfolder has its own pyproject.toml). For regular builds, this parameter
+                is ignored.
+            package_name: Package name for subfolder builds. If None, derived from src_dir name
+                (e.g., "empty_drawing_detection" -> "empty-drawing-detection"). Only used when
+                creating temporary pyproject.toml (ignored if subfolder has its own pyproject.toml).
+                Ignored for regular builds.
+            dependency_group: Name of dependency group to copy from parent pyproject.toml.
+                Only used for subfolder builds when creating temporary pyproject.toml.
 
         Returns:
             List of ExternalDependency objects that were copied
+
+        Example:
+            ```python
+            # Regular build (main src/ directory)
+            manager = BuildManager(project_root=Path("."), src_dir=Path("src"))
+            deps = manager.prepare_build()  # No version needed
+
+            # Subfolder build (automatic detection)
+            manager = BuildManager(
+                project_root=Path("."),
+                src_dir=Path("src/integration/empty_drawing_detection")
+            )
+            # Version defaults to "0.0.0" if not provided
+            deps = manager.prepare_build(version="1.0.0", package_name="my-package")
+            ```
         """
+        # Check if this is a subfolder build and set up config if needed
+        if self._is_subfolder_build():
+            # For subfolder builds, we need a version
+            # If not provided, use a default version
+            if not version:
+                version = "0.0.0"
+                print(
+                    f"Warning: No version specified for subfolder build. Using default version '{version}'",
+                    file=sys.stderr,
+                )
+
+            if not package_name:
+                # Derive package name from subfolder
+                package_name = (
+                    self.src_dir.name.replace("_", "-").replace(" ", "-").lower().strip("-")
+                )
+
+            print(
+                f"Detected subfolder build. Setting up package '{package_name}' version '{version}'..."
+            )
+            self.subfolder_config = SubfolderBuildConfig(
+                project_root=self.project_root,
+                src_dir=self.src_dir,
+                package_name=package_name,
+                version=version,
+                dependency_group=dependency_group,
+            )
+            temp_pyproject = self.subfolder_config.create_temp_pyproject()
+            # If temp_pyproject is None, it means no parent pyproject.toml exists
+            # This is acceptable for tests or dependency-only operations
+            if temp_pyproject is None:
+                self.subfolder_config = None
+
         analyzer = ImportAnalyzer(self.project_root)
 
         # Find all Python files in src/
@@ -325,10 +413,30 @@ class BuildManager:
         """
         Remove all copied files and directories.
 
-        This method removes all files and directories that were copied
-        during prepare_build(). It handles errors gracefully and clears
-        the internal tracking lists.
+        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.
+
+        This is automatically called by run_build(), but you can call it manually if you
+        use prepare_build() directly.
+
+        Example:
+            ```python
+            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
+            ```
         """
+        # Restore subfolder config if it was created
+        if self.subfolder_config:
+            try:
+                self.subfolder_config.restore()
+                print("Restored original pyproject.toml")
+            except Exception as e:
+                print(f"Warning: Could not restore pyproject.toml: {e}", file=sys.stderr)
+            self.subfolder_config = None
+
         # Remove copied directories first (they may contain files)
         for dir_path in reversed(self.copied_dirs):
             if dir_path.exists():
@@ -350,29 +458,59 @@ class BuildManager:
         self.copied_files.clear()
         self.copied_dirs.clear()
 
-    def run_build(self, build_command: Callable[[], None]) -> None:
+    def run_build(
+        self,
+        build_command: Callable[[], None],
+        version: str | None = None,
+        package_name: str | None = None,
+        dependency_group: str | None = None,
+    ) -> None:
         """
         Run the build process with dependency management.
 
-        This is a convenience method that:
-        1. Calls prepare_build() to find and copy dependencies
+        This is a convenience method that automatically handles the full build lifecycle:
+        1. Calls prepare_build() to find and copy dependencies (with automatic subfolder detection)
         2. Executes the provided build_command
         3. Always calls cleanup() afterward, even if build fails
 
+        For subfolder builds, this method automatically detects the subfolder and creates a
+        temporary pyproject.toml with the correct package configuration. The build command
+        should be runnable from the project root (e.g., "uv build", "python -m build").
+
         Args:
-            build_command: Callable that executes the build process
+            build_command: Callable that executes the build process. Should run from project root.
+            version: Version for subfolder builds. If building a subfolder and version is None,
+                defaults to "0.0.0" with a warning. Ignored for regular builds.
+            package_name: Package name for subfolder builds. If None, derived from src_dir name.
+                Ignored for regular builds.
+            dependency_group: Name of dependency group to copy from parent pyproject.toml.
+                Only used for subfolder builds.
 
         Example:
             ```python
+            from pathlib import Path
+            from python_package_folder import BuildManager
+            import subprocess
+
+            # Regular build
+            manager = BuildManager(project_root=Path("."), src_dir=Path("src"))
             def build():
                 subprocess.run(["uv", "build"], check=True)
-
             manager.run_build(build)
+
+            # Subfolder build (automatic detection)
+            manager = BuildManager(
+                project_root=Path("."),
+                src_dir=Path("src/integration/empty_drawing_detection")
+            )
+            manager.run_build(build, version="1.0.0")
             ```
         """
         try:
             print("Analyzing project for external dependencies...")
-            external_deps = self.prepare_build()
+            external_deps = self.prepare_build(
+                version=version, package_name=package_name, dependency_group=dependency_group
+            )
 
             if external_deps:
                 print(f"\nFound {len(external_deps)} external dependencies")
@@ -444,49 +582,37 @@ class BuildManager:
 
         version_manager = None
         original_version = None
-        subfolder_config = None
-
-        # Check if we're building a subfolder (not the main src/ directory)
-        is_subfolder_build = not self.src_dir.is_relative_to(self.project_root / "src") or (
-            self.src_dir != self.project_root / "src" and self.src_dir != self.project_root
-        )
 
         try:
-            # For subfolder builds, create a temporary pyproject.toml
-            if is_subfolder_build and version:
-                if not package_name:
-                    # Derive package name from subfolder
-                    package_name = (
-                        self.src_dir.name.replace("_", "-").replace(" ", "-").lower().strip("-")
-                    )
-                print(f"Building subfolder as package '{package_name}' version '{version}'...")
-                subfolder_config = SubfolderBuildConfig(
-                    project_root=self.project_root,
-                    src_dir=self.src_dir,
-                    package_name=package_name,
-                    version=version,
-                    dependency_group=dependency_group,
-                )
-                subfolder_config.create_temp_pyproject()
-            elif version:
-                # Regular build with version override
+            # For non-subfolder builds with version, use VersionManager
+            if version and not self._is_subfolder_build():
                 version_manager = VersionManager(self.project_root)
                 original_version = version_manager.get_current_version()
                 print(f"Setting version to {version}...")
                 version_manager.set_version(version)
 
-            # Build the package
-            self.run_build(build_command)
+            # Build the package (prepare_build will handle subfolder config if needed)
+            self.run_build(
+                build_command,
+                version=version,
+                package_name=package_name,
+                dependency_group=dependency_group,
+            )
 
             # Publish if repository is specified
             if repository:
                 # Determine package name and version for filtering
                 publish_package_name = None
                 publish_version = version
-
-                if is_subfolder_build and package_name:
-                    publish_package_name = package_name
-                elif not is_subfolder_build:
+                is_subfolder_build = self._is_subfolder_build()
+
+                if is_subfolder_build:
+                    # Get package name from subfolder_config if it was created, otherwise use provided
+                    if self.subfolder_config:
+                        publish_package_name = self.subfolder_config.package_name
+                    elif package_name:
+                        publish_package_name = package_name
+                else:
                     # For regular builds, get package name from pyproject.toml
                     try:
                         import tomllib
@@ -515,15 +641,7 @@ class BuildManager:
                 )
                 publisher.publish(skip_existing=skip_existing)
         finally:
-            # Restore subfolder config if used
-            if subfolder_config and restore_versioning:
-                try:
-                    subfolder_config.restore()
-                    print("Restored original pyproject.toml")
-                except Exception as e:
-                    print(f"Warning: Could not restore pyproject.toml: {e}", file=sys.stderr)
-
-            # Restore versioning if needed
+            # Restore versioning if needed (subfolder config is handled by cleanup)
             if version_manager and restore_versioning:
                 try:
                     if original_version:

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/subfolder_build.py

@@ -29,8 +29,13 @@ class SubfolderBuildConfig:
     """
     Manages temporary build configuration for subfolder builds.
 
-    When building a subfolder as a separate package, this class creates
-    a temporary pyproject.toml with the appropriate package name and version.
+    When building a subfolder as a separate package, this class:
+    - 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)
     """
 
     def __init__(
@@ -47,9 +52,12 @@ class SubfolderBuildConfig:
         Args:
             project_root: Root directory containing the main pyproject.toml
             src_dir: Source directory being built (subfolder)
-            package_name: Name for the subfolder package (default: derived from src_dir name)
-            version: Version for the subfolder package (required if building subfolder)
-            dependency_group: Name of dependency group to copy from parent pyproject.toml
+            package_name: Name for the subfolder package (default: derived from src_dir name).
+                Only used if subfolder doesn't have its own pyproject.toml.
+            version: Version for the subfolder package (required if building subfolder).
+                Only used if subfolder doesn't have its own pyproject.toml.
+            dependency_group: Name of dependency group to copy from parent pyproject.toml.
+                Only used if subfolder doesn't have its own pyproject.toml.
         """
         self.project_root = project_root.resolve()
         self.src_dir = src_dir.resolve()
@@ -61,6 +69,7 @@ class SubfolderBuildConfig:
         self._temp_init_created = False
         self.temp_readme: Path | None = None
         self.original_readme_backup: Path | None = None
+        self._used_subfolder_pyproject = False
 
     def _derive_package_name(self) -> str:
         """Derive package name from source directory name."""
@@ -105,15 +114,100 @@ class SubfolderBuildConfig:
         # If it's a package or has subpackages, return the path
         return packages_path, [packages_path] if packages_path else []
 
-    def create_temp_pyproject(self) -> Path:
+    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.
 
-        This creates a pyproject.toml in the project root that overrides
-        the package name and version for building the subfolder.
+        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 temporary pyproject.toml file
+            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)
         """
         if not self.version:
             raise ValueError("Version is required for subfolder builds")
@@ -127,10 +221,52 @@ class SubfolderBuildConfig:
         else:
             self._temp_init_created = False
 
+        # Check if pyproject.toml exists in subfolder
+        subfolder_pyproject = self.src_dir / "pyproject.toml"
+        if subfolder_pyproject.exists():
+            # Use the subfolder's pyproject.toml
+            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
+            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
+
+            # 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
+            self._handle_readme()
+
+            return original_pyproject
+
+        # No pyproject.toml in subfolder, create one from parent
+        self._used_subfolder_pyproject = False
+        print("No pyproject.toml found in subfolder, creating temporary one from parent")
+
         # Read the original pyproject.toml
         original_pyproject = self.project_root / "pyproject.toml"
         if not original_pyproject.exists():
-            raise FileNotFoundError(f"pyproject.toml not found: {original_pyproject}")
+            # If no parent pyproject.toml exists, we can't create a temporary one
+            # This is acceptable for tests or cases where only dependency copying is needed
+            print(
+                f"Warning: No pyproject.toml found in project root ({original_pyproject}). "
+                "Skipping subfolder build configuration. Only dependency copying will be performed.",
+                file=sys.stderr,
+            )
+            # Still handle README file
+            self._handle_readme()
+            # Return None to indicate no pyproject.toml was created
+            return None
 
         original_content = original_pyproject.read_text(encoding="utf-8")
 
@@ -214,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()
@@ -221,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
@@ -316,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
@@ -419,7 +582,13 @@ class SubfolderBuildConfig:
             self.temp_readme = target_readme
 
     def restore(self) -> None:
-        """Restore the original pyproject.toml and remove temporary __init__.py if created."""
+        """
+        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.
+        """
         # Remove temporary __init__.py if we created it
         if self._temp_init_created:
             init_file = self.src_dir / "__init__.py"
@@ -460,13 +629,18 @@ class SubfolderBuildConfig:
                     pass  # Ignore errors during cleanup
             self.temp_readme = None
 
-        # Restore original pyproject.toml
-        if self.original_pyproject_backup and self.original_pyproject_backup.exists():
+        # 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
             self.temp_pyproject = None
+            self._used_subfolder_pyproject = False
 
     def __enter__(self) -> Self:
         """Context manager entry."""

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.1.3.dist-info → python_package_folder-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 1.1.3
+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>
@@ -125,9 +125,11 @@ This package will automatically:
 
 ## Features
 
-- **Subfolder Build Support**: Build subfolders as separate packages with automatic project root detection
+- **Subfolder Build Support**: Build subfolders as separate packages with automatic detection and configuration
+  - **Automatic subfolder detection**: Detects when building a subfolder (not the main `src/` directory)
   - Creates any needed file for publishing automatically, cleaning up if not originally in the subfolder after the build/publish process. E.g. copies external dependencies into the source directory before build and cleans them up afterward; temporary `__init__.py` creation for non-package subfolders; uses subfolder README if present, otherwise creates minimal README
   - Automatic package name derivation from subfolder name
+  - Automatic temporary `pyproject.toml` creation with correct package structure
   - Dependency group selection: specify which dependency group from parent `pyproject.toml` to include.
   
 - **Smart Import Classification and analysis**:
@@ -245,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
@@ -268,16 +271,21 @@ cd my_project/subfolder_to_build
 python-package-folder --version "1.0.0" --publish pypi
 ```
 
-When building from a subdirectory, you **must** specify `--version` because subfolders are built as separate packages with their own version.
+The tool **automatically detects** when you're building a subfolder (any directory that's not the main `src/` directory) and sets up the appropriate build configuration.
 
 The tool automatically:
+- **Detects subfolder builds**: Automatically identifies when building from a subdirectory
 - Finds the project root by looking for `pyproject.toml` in parent directories
 - 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: creates a temporary `pyproject.toml` with:
-  - Package name derived from the subfolder name (or use `--package-name` to override)
-  - Version from `--version` argument
-  - Proper package path configuration for hatchling
+- **For subfolder builds**: Handles `pyproject.toml` configuration:
+  - **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
+    - Dependency groups from parent `pyproject.toml` if specified
 - Creates temporary `__init__.py` files if needed to make subfolders valid Python packages
 - **README handling for subfolder builds**:
   - If a README file (README.md, README.rst, README.txt, or README) exists in the subfolder, it will be used instead of the parent README
@@ -285,6 +293,8 @@ The tool automatically:
 - Restores the original `pyproject.toml` after build (unless `--no-restore-versioning` is used)
 - Cleans up temporary `__init__.py` files after build
 
+**Note**: While version is not strictly required (defaults to `0.0.0`), it's recommended to specify `--version` for subfolder builds to ensure proper versioning.
+
 **Subfolder Build Example:**
 ```bash
 # Build a subfolder as a separate package
@@ -293,6 +303,11 @@ python-package-folder --version "0.1.0" --package-name "my-subfolder-package" --
 
 # Build with a specific dependency group from parent pyproject.toml
 python-package-folder --version "0.1.0" --dependency-group "dev" --publish pypi
+
+# If subfolder has its own pyproject.toml, it will be used automatically
+# (package-name and version arguments are ignored in this case)
+cd src/integration/my_package  # assuming my_package/pyproject.toml exists
+python-package-folder --publish pypi
 ```
 
 **Dependency Groups**: When building a subfolder, you can specify a dependency group from the parent `pyproject.toml` to include in the subfolder's build configuration. This allows subfolders to inherit specific dependencies from the parent project:
@@ -308,6 +323,8 @@ The specified dependency group will be copied from the parent `pyproject.toml`'s
 
 You can also use the package programmatically:
 
+### Basic Usage
+
 ```python
 from pathlib import Path
 from python_package_folder import BuildManager
@@ -328,11 +345,11 @@ for dep in external_deps:
 # Run your build process here
 # ...
 
-# Cleanup copied files
+# Cleanup copied files (also restores pyproject.toml if subfolder build)
 manager.cleanup()
 ```
 
-Or use the convenience method:
+### Using the Convenience Method
 
 ```python
 from pathlib import Path
@@ -348,6 +365,55 @@ def build_command():
 manager.run_build(build_command)
 ```
 
+### Subfolder Builds (Automatic Detection)
+
+The tool automatically detects when you're building a subfolder and sets up the appropriate configuration:
+
+```python
+from pathlib import Path
+from python_package_folder import BuildManager
+import subprocess
+
+# Building a subfolder - automatic detection!
+manager = BuildManager(
+    project_root=Path("."),
+    src_dir=Path("src/integration/empty_drawing_detection")
+)
+
+def build_command():
+    subprocess.run(["uv", "build"], check=True)
+
+# prepare_build() automatically:
+# - Detects this is a subfolder build
+# - If pyproject.toml exists in subfolder: uses that file
+# - If no pyproject.toml in subfolder: creates temporary one with package name "empty-drawing-detection"
+# - Uses version "0.0.0" (or pass version="1.0.0" to override) if creating temporary pyproject.toml
+external_deps = manager.prepare_build(version="1.0.0")
+
+# Run build - uses the pyproject.toml (either from subfolder or temporary)
+build_command()
+
+# Cleanup restores original pyproject.toml and removes copied files
+manager.cleanup()
+```
+
+**Note**: If the subfolder has its own `pyproject.toml`, it will be used automatically. The `version` and `package_name` parameters are only used when creating a temporary `pyproject.toml` from the parent configuration.
+
+Or use the convenience method:
+
+```python
+manager = BuildManager(
+    project_root=Path("."),
+    src_dir=Path("src/integration/empty_drawing_detection")
+)
+
+def build_command():
+    subprocess.run(["uv", "build"], check=True)
+
+# All handled automatically: subfolder detection, pyproject.toml setup, build, cleanup
+manager.run_build(build_command, version="1.0.0", package_name="my-custom-name")
+```
+
 ## Working with sysappend
 
 This package works well with projects using [sysappend](https://pypi.org/project/sysappend/) for flexible import management. When you have imports like:
@@ -393,20 +459,28 @@ The `--version` option:
 
 ### Subfolder Versioning
 
-When building from a subdirectory (not the main `src/` directory), you **must** specify `--version`:
+When building from a subdirectory (not the main `src/` directory), the tool automatically detects the subfolder and sets up the build configuration:
 
 ```bash
-# Build a subfolder as a separate package
+# Build a subfolder as a separate package (version recommended but not required)
 cd my_project/subfolder_to_build
 python-package-folder --version "1.0.0" --publish pypi
 
 # With custom package name
 python-package-folder --version "1.0.0" --package-name "my-custom-name" --publish pypi
+
+# Version defaults to "0.0.0" if not specified (with a warning)
+python-package-folder --publish pypi
 ```
 
 For subfolder builds:
-- **Version is required**: The tool will error if `--version` is not provided
-- **Package name**: Automatically derived from the subfolder name (e.g., `subfolder_to_build` → `subfolder-to-build`)
+- **Automatic detection**: The tool automatically detects subfolder builds
+- **pyproject.toml handling**:
+  - If `pyproject.toml` exists in subfolder: Uses that file (copied to project root temporarily)
+  - If no `pyproject.toml` in subfolder: Creates temporary one with correct package structure
+- **Version**: Recommended but not required when creating temporary pyproject.toml. If not provided, defaults to `0.0.0` with a warning. Ignored if subfolder has its own `pyproject.toml`.
+- **Package name**: Automatically derived from the subfolder name (e.g., `subfolder_to_build` → `subfolder-to-build`). Only used when creating temporary pyproject.toml.
+- **Restoration**: Original `pyproject.toml` is restored after build
 - **Temporary configuration**: Creates a temporary `pyproject.toml` with:
   - Custom package name (from `--package-name` or derived)
   - Specified version
@@ -715,7 +789,8 @@ version_manager.restore_dynamic_versioning()
 
 ### SubfolderBuildConfig
 
-Manages temporary build configuration for subfolder builds.
+Manages temporary build configuration for subfolder builds. If a `pyproject.toml` exists
+in the subfolder, it will be used instead of creating a new one.
 
 ```python
 from python_package_folder import SubfolderBuildConfig
@@ -724,11 +799,11 @@ from pathlib import Path
 config = SubfolderBuildConfig(
     project_root=Path("."),
     src_dir=Path("subfolder"),
-    package_name="my-subfolder",
-    version="1.0.0"
+    package_name="my-subfolder",  # Only used if subfolder has no pyproject.toml
+    version="1.0.0"  # Only used if subfolder has no pyproject.toml
 )
 
-# Create temporary pyproject.toml
+# Create temporary pyproject.toml (or use subfolder's if it exists)
 config.create_temp_pyproject()
 
 # ... build process ...
@@ -738,13 +813,13 @@ config.restore()
 ```
 
 **Methods:**
-- `create_temp_pyproject() -> Path`: 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 creates `__init__.py` files if needed to make subfolders valid Python packages. It also handles README files:
-- 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
+**Note**: This class automatically:
+- **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.
 
 
 ## Development

python_package_folder-1.2.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+python_package_folder/__init__.py,sha256=DQt-uldOEKfh0MUqCvKdeNKOnpuOvpb7blYvXMyO9Wc,719
+python_package_folder/__main__.py,sha256=a-__-VLhYw-J7S7CsHdhtEvQr3RiAZxiYDvKhKTgMX4,291
+python_package_folder/analyzer.py,sha256=w7hc2oyOoPK7tvlwcJDXnB3eiJsuGZc4BkOpTfZP7Vo,12257
+python_package_folder/finder.py,sha256=_LvJ9xBVKv41UK5sbwbNyKmuYjAOqUbzvZhK7NCYQF8,9130
+python_package_folder/manager.py,sha256=AlzEqI7q0Q2mVmc_HjIEBmomlT053qqLBMZZ52X7IDQ,26360
+python_package_folder/publisher.py,sha256=1xa6PuduOXNVTTp4IrJcx4qOskugX2fTeJ9QsLDLuUM,11535
+python_package_folder/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_package_folder/python_package_folder.py,sha256=RPsqRcIy_LjzzTHdp4qdtFJ4-4xhtR_0YLIC0RlUxFo,8841
+python_package_folder/subfolder_build.py,sha256=C_Hksc7JqeNfYvP1HUqXnxlaFFYde3ACXCAE-8SYh9M,27712
+python_package_folder/types.py,sha256=3yeSRR5p_3PDKEAaehW_RJ7NwJHexOIeA08bGaT1iSY,2368
+python_package_folder/utils.py,sha256=lIkWsFKeAYAJ9TDUM99T4pUBHJVbUvCdUgkWQN-LUho,3111
+python_package_folder/version.py,sha256=kIDP6S9trEfs9gj7lBYGxrWm4RPssRla24UtlO9Jkh4,9111
+python_package_folder-1.2.1.dist-info/METADATA,sha256=rkIOYmrjFZxN0AMgT6LshC4qxRbQW1s0CzBgWNsalaQ,32711
+python_package_folder-1.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_package_folder-1.2.1.dist-info/entry_points.txt,sha256=ttu4wAhoYSHGhWQNercLz9IVTTpXxhVlRA9vSTvaLe0,91
+python_package_folder-1.2.1.dist-info/licenses/LICENSE,sha256=vNgRJh8YiecqZoZld7TtwPI5I72HIymKD9g32fiJjCE,1073
+python_package_folder-1.2.1.dist-info/RECORD,,

python_package_folder-1.1.3.dist-info/RECORD

@@ -1,17 +0,0 @@
-python_package_folder/__init__.py,sha256=DQt-uldOEKfh0MUqCvKdeNKOnpuOvpb7blYvXMyO9Wc,719
-python_package_folder/__main__.py,sha256=a-__-VLhYw-J7S7CsHdhtEvQr3RiAZxiYDvKhKTgMX4,291
-python_package_folder/analyzer.py,sha256=Iw5bdg9NahO57L3CZgGYbhU-m2mh0DpQQ-xqIINUfic,10976
-python_package_folder/finder.py,sha256=_LvJ9xBVKv41UK5sbwbNyKmuYjAOqUbzvZhK7NCYQF8,9130
-python_package_folder/manager.py,sha256=VZ2e6ydQUPlDnve-PlqGfa86XksSCCqFDZ46GDwZr2A,20549
-python_package_folder/publisher.py,sha256=1xa6PuduOXNVTTp4IrJcx4qOskugX2fTeJ9QsLDLuUM,11535
-python_package_folder/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_package_folder/python_package_folder.py,sha256=3ECayVwjXQAnujr2e21xvsuwetcqgRF5Zawt3qgtI9M,8779
-python_package_folder/subfolder_build.py,sha256=NIlQRMjBQvBJdxYpwYyOcQWqijPKmgRogsRyY9rElkk,19567
-python_package_folder/types.py,sha256=3yeSRR5p_3PDKEAaehW_RJ7NwJHexOIeA08bGaT1iSY,2368
-python_package_folder/utils.py,sha256=hoCNRiTHe_-zjAFztxyqjNEMKiEl7XCkSDl36iaMcjM,2966
-python_package_folder/version.py,sha256=kIDP6S9trEfs9gj7lBYGxrWm4RPssRla24UtlO9Jkh4,9111
-python_package_folder-1.1.3.dist-info/METADATA,sha256=7dD2K5qmYNEBJS8m6i-I5_lrZeAm_jab21rULqHp2mw,28134
-python_package_folder-1.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_package_folder-1.1.3.dist-info/entry_points.txt,sha256=ttu4wAhoYSHGhWQNercLz9IVTTpXxhVlRA9vSTvaLe0,91
-python_package_folder-1.1.3.dist-info/licenses/LICENSE,sha256=vNgRJh8YiecqZoZld7TtwPI5I72HIymKD9g32fiJjCE,1073
-python_package_folder-1.1.3.dist-info/RECORD,,