python-package-folder 5.3.0__tar.gz → 6.0.0__tar.gz

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 5.3.0
+Version: 6.0.0
 Summary: Python package to automatically package and build a folder, fetching all relevant dependencies.
 Project-URL: Repository, https://github.com/alelom/python-package-folder
 Author-email: Alessio Lombardi <work@alelom.com>

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/coverage.svg

@@ -14,7 +14,7 @@
   <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
     <text x="31.5" y="15" fill="#010101" fill-opacity=".3">coverage</text>
     <text x="31.5" y="14">coverage</text>
-    <text x="81" y="15" fill="#010101" fill-opacity=".3">66%</text>
-    <text x="81" y="14">66%</text>
+    <text x="81" y="15" fill="#010101" fill-opacity=".3">65%</text>
+    <text x="81" y="14">65%</text>
   </g>
 </svg>

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/pyproject.toml

@@ -43,7 +43,7 @@ dependencies = [
 
 # ---- Dev dependencies ----
 
-version = "5.3.0"
+version = "6.0.0"
 [dependency-groups]
 dev = [
     "pytest>=8.3.5",

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/src/python_package_folder/analyzer.py

@@ -330,56 +330,33 @@ class ImportAnalyzer:
 
             # Check all subdirectories in parent (not just common ones)
             # This handles cases like src/data/spreadsheet_creation/spreadsheet_formatting_dataclasses.py
-            if parent.is_dir():
+            # Use recursive search to find modules in nested directories
+            if parent.is_dir() and parent.is_relative_to(self.project_root):
+                # Recursively search for the module file in subdirectories
+                # Limit search to project_root and its subdirectories to avoid searching too broadly
+                module_basename = module_name.split(".")[-1]
                 try:
-                    for subdir in parent.iterdir():
-                        if not subdir.is_dir():
+                    # Search recursively for the module file
+                    for potential_file in parent.rglob(f"{module_basename}.py"):
+                        # Only search within project_root to avoid going too far
+                        if not potential_file.is_relative_to(self.project_root):
                             continue
-                        # Skip common excluded patterns
-                        if subdir.name.startswith("_SS") or subdir.name.startswith("__SS"):
-                            continue
-                        # Check if module file exists directly in subdirectory
-                        potential_subdir_file = subdir / f"{module_name.split('.')[-1]}.py"
-                        if potential_subdir_file.exists():
-                            return potential_subdir_file
-                        # Check if module directory exists in subdirectory
-                        potential_subdir_module = subdir / module_name.replace(".", "/")
-                        if (
-                            potential_subdir_module.is_dir()
-                            and (potential_subdir_module / "__init__.py").exists()
+                        # Skip excluded patterns
+                        if any(
+                            part.startswith("_SS")
+                            or part.startswith("__SS")
+                            or part.startswith("_sandbox")
+                            or part.startswith("__sandbox")
+                            for part in potential_file.parts
                         ):
-                            return potential_subdir_module / "__init__.py"
-                        if potential_subdir_module.with_suffix(".py").is_file():
-                            return potential_subdir_module.with_suffix(".py")
-                        # Check nested subdirectories (e.g., data/spreadsheet_creation)
-                        # Recursively check subdirectories up to 2 levels deep
-                        try:
-                            for nested_subdir in subdir.iterdir():
-                                if not nested_subdir.is_dir():
-                                    continue
-                                # Check if module file exists in nested subdirectory
-                                potential_nested_file = (
-                                    nested_subdir / f"{module_name.split('.')[-1]}.py"
-                                )
-                                if potential_nested_file.exists():
-                                    return potential_nested_file
-                                # Check if module directory exists in nested subdirectory
-                                potential_nested_module = nested_subdir / module_name.replace(
-                                    ".", "/"
-                                )
-                                if (
-                                    potential_nested_module.is_dir()
-                                    and (potential_nested_module / "__init__.py").exists()
-                                ):
-                                    return potential_nested_module / "__init__.py"
-                                if potential_nested_module.with_suffix(".py").is_file():
-                                    return potential_nested_module.with_suffix(".py")
-                        except (OSError, PermissionError):
-                            # Skip nested directories we can't read
                             continue
+                        # Skip if it's in the src_dir (we're looking for external dependencies)
+                        if potential_file.is_relative_to(src_dir):
+                            continue
+                        return potential_file
                 except (OSError, PermissionError):
-                    # Skip directories we can't read
-                    continue
+                    # Skip if we can't read the directory
+                    pass
 
             # Check common subdirectories in parent (e.g., _shared, shared, common)
             # This handles cases like src/_shared/better_enum.py

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/src/python_package_folder/manager.py

@@ -239,10 +239,19 @@ class BuildManager:
                 )
 
             if not package_name:
-                # Derive package name from subfolder
-                package_name = (
+                # Derive package name from subfolder: {root_project_name}-{subfolder_name}
+                root_project_name = self._get_project_name()
+                subfolder_name = (
                     self.src_dir.name.replace("_", "-").replace(" ", "-").lower().strip("-")
                 )
+                
+                if root_project_name:
+                    # Normalize root project name (replace underscores/hyphens consistently)
+                    root_name_normalized = root_project_name.replace("_", "-").lower()
+                    package_name = f"{root_name_normalized}-{subfolder_name}"
+                else:
+                    # Fallback to just subfolder name if root project name not found
+                    package_name = subfolder_name
 
             print(
                 f"Detected subfolder build. Setting up package '{package_name}' version '{version}'..."
@@ -259,10 +268,30 @@ class BuildManager:
             # This is acceptable for tests or dependency-only operations
             if temp_pyproject is None:
                 self.subfolder_config = None
+            else:
+                # If temporary package directory was created, use it for all operations
+                # This ensures dependencies are copied to the correct location and
+                # imports are fixed in the files that will actually be packaged
+                if (
+                    self.subfolder_config
+                    and self.subfolder_config._temp_package_dir
+                    and self.subfolder_config._temp_package_dir.exists()
+                ):
+                    # Update src_dir to point to temp package directory
+                    self.src_dir = self.subfolder_config._temp_package_dir
+                    # Recreate finder with updated src_dir so it calculates target paths correctly
+                    self.finder = ExternalDependencyFinder(
+                        self.project_root,
+                        self.src_dir,
+                        exclude_patterns=self.exclude_patterns,
+                    )
+                    print(
+                        f"Using temporary package directory for build: {self.src_dir}"
+                    )
 
         analyzer = ImportAnalyzer(self.project_root)
 
-        # Find all Python files in src/
+        # Find all Python files in src/ (which may now be the temp package directory)
         python_files = analyzer.find_all_python_files(self.src_dir)
 
         # Find external dependencies using the configured finder
@@ -1191,13 +1220,23 @@ class BuildManager:
             captured_package_name = None
             if self._is_subfolder_build():
                 # We need to get the package name before run_build cleans up subfolder_config
-                if not package_name:
-                    # Derive from src_dir name (same logic as in prepare_build)
-                    captured_package_name = (
+                if package_name:
+                    # Use provided package name (from --package-name arg)
+                    captured_package_name = package_name
+                else:
+                    # Derive from root project name + src_dir name (same logic as in prepare_build)
+                    root_project_name = self._get_project_name()
+                    subfolder_name = (
                         self.src_dir.name.replace("_", "-").replace(" ", "-").lower().strip("-")
                     )
-                else:
-                    captured_package_name = package_name
+                    
+                    if root_project_name:
+                        # Normalize root project name (replace underscores/hyphens consistently)
+                        root_name_normalized = root_project_name.replace("_", "-").lower()
+                        captured_package_name = f"{root_name_normalized}-{subfolder_name}"
+                    else:
+                        # Fallback to just subfolder name if root project name not found
+                        captured_package_name = subfolder_name
 
             self.run_build(
                 build_command,
@@ -1223,10 +1262,19 @@ class BuildManager:
                     elif package_name:
                         publish_package_name = package_name
                     else:
-                        # Last resort: derive from src_dir name
-                        publish_package_name = (
+                        # Last resort: derive from root project name + src_dir name
+                        root_project_name = self._get_project_name()
+                        subfolder_name = (
                             self.src_dir.name.replace("_", "-").replace(" ", "-").lower().strip("-")
                         )
+                        
+                        if root_project_name:
+                            # Normalize root project name (replace underscores/hyphens consistently)
+                            root_name_normalized = root_project_name.replace("_", "-").lower()
+                            publish_package_name = f"{root_name_normalized}-{subfolder_name}"
+                        else:
+                            # Fallback to just subfolder name if root project name not found
+                            publish_package_name = subfolder_name
                     
                     # Log the package name being used for publishing
                     import logging

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/src/python_package_folder/python_package_folder.py

@@ -30,6 +30,45 @@ logging.basicConfig(
 
 def is_github_actions() -> bool:
     """Check if running in GitHub Actions."""
+
+
+def _get_root_project_name(project_root: Path) -> str | None:
+    """
+    Get the root project name from pyproject.toml.
+    
+    Args:
+        project_root: Root directory of the project
+        
+    Returns:
+        Project name from pyproject.toml, or None if not found
+    """
+    pyproject_path = project_root / "pyproject.toml"
+    if not pyproject_path.exists():
+        return None
+    
+    try:
+        import tomllib
+    except ImportError:
+        try:
+            import tomli as tomllib
+        except ImportError:
+            tomllib = None
+    
+    try:
+        if tomllib:
+            with open(pyproject_path, "rb") as f:
+                data = tomllib.load(f)
+                return data.get("project", {}).get("name")
+        else:
+            # Fallback: simple string parsing
+            content = pyproject_path.read_text(encoding="utf-8")
+            for line in content.split("\n"):
+                if line.strip().startswith("name ="):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    except Exception:
+        pass
+    
+    return None
     return os.getenv("GITHUB_ACTIONS") == "true"
 
 
@@ -177,6 +216,27 @@ def main() -> int:
 
         # Resolve version via conventional commits if not provided and needed
         resolved_version = args.version
+        
+        # Derive package name for subfolder builds (used for both version resolution and publishing)
+        derived_package_name = None
+        if is_subfolder:
+            if args.package_name:
+                derived_package_name = args.package_name
+            else:
+                # Derive package name: {root_project_name}-{subfolder_name}
+                root_project_name = _get_root_project_name(project_root)
+                subfolder_name = src_dir.name.replace("_", "-").replace(
+                    " ", "-"
+                ).lower().strip("-")
+                
+                if root_project_name:
+                    # Normalize root project name (replace underscores/hyphens consistently)
+                    root_name_normalized = root_project_name.replace("_", "-").lower()
+                    derived_package_name = f"{root_name_normalized}-{subfolder_name}"
+                else:
+                    # Fallback to just subfolder name if root project name not found
+                    derived_package_name = subfolder_name
+        
         if not resolved_version and not args.analyze_only:
             # Version is needed for subfolder builds or when publishing main package
             if is_subfolder or args.publish:
@@ -204,21 +264,18 @@ def main() -> int:
                 if is_subfolder:
                     # Workflow 1: subfolder build
                     # src_dir is guaranteed to be relative to project_root due to is_subfolder check
-                    package_name = args.package_name or src_dir.name.replace("_", "-").replace(
-                        " ", "-"
-                    ).lower().strip("-")
                     subfolder_rel_path = src_dir.relative_to(project_root)
                     
                     # Log the package name being used for version query
                     logger = logging.getLogger(__name__)
                     logger.info(
-                        f"Querying registry for package name: '{package_name}' "
-                        f"(derived from src_dir: '{src_dir.name}', args.package_name: {args.package_name})"
+                        f"Querying registry for package name: '{derived_package_name}' "
+                        f"(derived from src_dir: '{src_dir.name}', root_project: {_get_root_project_name(project_root)}, args.package_name: {args.package_name})"
                     )
                     
                     resolved_version, error_details = resolve_version(
                         project_root,
-                        package_name=package_name,
+                        package_name=derived_package_name,
                         subfolder_path=subfolder_rel_path,
                         repository=repository,
                         repository_url=repository_url,
@@ -279,7 +336,7 @@ def main() -> int:
                 skip_existing=args.skip_existing,
                 version=args.version,
                 restore_versioning=not args.no_restore_versioning,
-                package_name=args.package_name,
+                package_name=derived_package_name if is_subfolder else args.package_name,
                 dependency_group=args.dependency_group,
             )
         else:
@@ -289,9 +346,25 @@ def main() -> int:
                 if is_subfolder:
                     from .subfolder_build import SubfolderBuildConfig
 
-                    package_name = args.package_name or src_dir.name.replace("_", "-").replace(
-                        " ", "-"
-                    ).lower().strip("-")
+                    # Use derived_package_name if available, otherwise derive it again
+                    if derived_package_name is not None:
+                        package_name = derived_package_name
+                    elif args.package_name:
+                        package_name = args.package_name
+                    else:
+                        # Derive package name: {root_project_name}-{subfolder_name}
+                        root_project_name = _get_root_project_name(project_root)
+                        subfolder_name = src_dir.name.replace("_", "-").replace(
+                            " ", "-"
+                        ).lower().strip("-")
+                        
+                        if root_project_name:
+                            # Normalize root project name (replace underscores/hyphens consistently)
+                            root_name_normalized = root_project_name.replace("_", "-").lower()
+                            package_name = f"{root_name_normalized}-{subfolder_name}"
+                        else:
+                            # Fallback to just subfolder name if root project name not found
+                            package_name = subfolder_name
                     subfolder_config = SubfolderBuildConfig(
                         project_root=project_root,
                         src_dir=src_dir,

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/src/python_package_folder/subfolder_build.py

@@ -78,16 +78,91 @@ class SubfolderBuildConfig:
         self._used_subfolder_pyproject = False
         self._excluded_files: list[tuple[Path, Path]] = []  # List of (original_path, temp_path) tuples
         self._exclude_temp_dir: Path | None = None
+        self._temp_package_dir: Path | None = None
 
     def _derive_package_name(self) -> str:
-        """Derive package name from source directory name."""
+        """
+        Derive package name from root project name and source directory name.
+        
+        Format: {root_project_name}-{subfolder_name}
+        Falls back to just subfolder_name if root project name not found.
+        """
+        # Get root project name from pyproject.toml
+        root_project_name = None
+        pyproject_path = self.project_root / "pyproject.toml"
+        if pyproject_path.exists():
+            try:
+                if tomllib:
+                    with open(pyproject_path, "rb") as f:
+                        data = tomllib.load(f)
+                        root_project_name = data.get("project", {}).get("name")
+                else:
+                    # Fallback: simple string parsing
+                    content = pyproject_path.read_text(encoding="utf-8")
+                    for line in content.split("\n"):
+                        if line.strip().startswith("name ="):
+                            root_project_name = line.split("=", 1)[1].strip().strip('"').strip("'")
+                            break
+            except Exception:
+                pass
+        
         # Use the directory name, replacing invalid characters
-        name = self.src_dir.name
+        subfolder_name = self.src_dir.name
         # Replace invalid characters with hyphens
-        name = name.replace("_", "-").replace(" ", "-").lower()
+        subfolder_name = subfolder_name.replace("_", "-").replace(" ", "-").lower()
         # Remove any leading/trailing hyphens
-        name = name.strip("-")
-        return name
+        subfolder_name = subfolder_name.strip("-")
+        
+        # Combine with root project name if available
+        if root_project_name:
+            # Normalize root project name (replace underscores/hyphens consistently)
+            root_name_normalized = root_project_name.replace("_", "-").lower()
+            return f"{root_name_normalized}-{subfolder_name}"
+        else:
+            # Fallback to just subfolder name
+            return subfolder_name
+
+    def _create_temp_package_directory(self) -> None:
+        """
+        Create a temporary package directory with the correct import name.
+        
+        This ensures the installed package has the correct directory structure.
+        The package name (with hyphens) is converted to the import name (with underscores).
+        For example: 'ml-drawing-assistant-data' -> 'ml_drawing_assistant_data'
+        
+        The temporary directory is created in the project root and contains a copy
+        of the source directory contents.
+        """
+        if not self.package_name:
+            return
+        
+        # Convert package name (with hyphens) to import name (with underscores)
+        # PyPI package names use hyphens, but Python import names use underscores
+        import_name = self.package_name.replace("-", "_")
+        
+        # Create temporary directory name
+        temp_dir_name = f".temp_package_{import_name}"
+        temp_package_dir = self.project_root / temp_dir_name
+        
+        # Remove if it already exists (from a previous failed build)
+        if temp_package_dir.exists():
+            shutil.rmtree(temp_package_dir)
+        
+        # Copy the entire source directory contents to the temporary directory
+        try:
+            shutil.copytree(self.src_dir, temp_package_dir)
+            self._temp_package_dir = temp_package_dir
+            print(
+                f"Created temporary package directory: {temp_package_dir} "
+                f"(import name: {import_name})"
+            )
+        except Exception as e:
+            print(
+                f"Warning: Could not create temporary package directory: {e}",
+                file=sys.stderr,
+            )
+            # Fall back to using src_dir directly
+            self._temp_package_dir = None
 
     def _get_package_structure(self) -> tuple[str, list[str]]:
         """
@@ -98,21 +173,24 @@ class SubfolderBuildConfig:
             - packages_path: The path to the directory containing packages
             - package_dirs: List of package directories to include
         """
-        # Check if src_dir itself is a package (has __init__.py)
-        has_init = (self.src_dir / "__init__.py").exists()
+        # Use temporary package directory if it exists, otherwise use src_dir
+        package_dir = self._temp_package_dir if self._temp_package_dir and self._temp_package_dir.exists() else self.src_dir
+        
+        # Check if package_dir itself is a package (has __init__.py)
+        has_init = (package_dir / "__init__.py").exists()
 
-        # Check for Python files directly in src_dir
-        py_files = list(self.src_dir.glob("*.py"))
+        # Check for Python files directly in package_dir
+        py_files = list(package_dir.glob("*.py"))
         has_py_files = bool(py_files)
 
-        # Calculate relative path
+        # Calculate relative path from project root
         try:
-            rel_path = self.src_dir.relative_to(self.project_root)
+            rel_path = package_dir.relative_to(self.project_root)
             packages_path = str(rel_path).replace("\\", "/")
         except ValueError:
             packages_path = None
 
-        # If src_dir has Python files but no __init__.py, we need to make it a package
+        # If package_dir has Python files but no __init__.py, we need to make it a package
         # or include it as a module directory
         if has_py_files and not has_init:
             # For flat structures, we include the directory itself
@@ -266,7 +344,8 @@ class SubfolderBuildConfig:
         if not self.version:
             raise ValueError("Version is required for subfolder builds")
 
-        # Ensure src_dir is a package (has __init__.py) for hatchling
+        # Ensure src_dir is a package (has __init__.py) before creating temp directory
+        # This way the __init__.py will be copied to the temp directory
         init_file = self.src_dir / "__init__.py"
         if not init_file.exists():
             # Create a temporary __init__.py to make it a package
@@ -275,6 +354,13 @@ class SubfolderBuildConfig:
         else:
             self._temp_init_created = False
 
+        # Create temporary package directory with correct import name
+        # This will copy the __init__.py we just created (if any)
+        self._create_temp_package_directory()
+        
+        # Determine which directory to use (temp package dir or src_dir)
+        package_dir = self._temp_package_dir if self._temp_package_dir and self._temp_package_dir.exists() else self.src_dir
+
         # Check if pyproject.toml exists in subfolder
         subfolder_pyproject = self.src_dir / "pyproject.toml"
         if subfolder_pyproject.exists():
@@ -1174,6 +1260,18 @@ class SubfolderBuildConfig:
             self.original_pyproject_path = None
             self._used_subfolder_pyproject = False
 
+        # Remove temporary package directory if it exists
+        if self._temp_package_dir and self._temp_package_dir.exists():
+            try:
+                shutil.rmtree(self._temp_package_dir)
+                print(f"Removed temporary package directory: {self._temp_package_dir}")
+            except Exception as e:
+                print(
+                    f"Warning: Could not remove temporary package directory {self._temp_package_dir}: {e}",
+                    file=sys.stderr,
+                )
+            self._temp_package_dir = None
+
     def __enter__(self) -> Self:
         """Context manager entry."""
         return self

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/tests/test_build_with_external_deps.py

@@ -440,11 +440,15 @@ def shared_function():
 
             # Verify dependencies were copied
             assert len(external_deps) >= 2
-            assert (subfolder / "_shared").exists()
-            assert (subfolder / "_globals.py").exists()
+            # Dependencies are copied to the temp package directory (if it exists) or original subfolder
+            package_dir = manager.src_dir  # This will be temp package dir if it was created
+            assert (package_dir / "_shared").exists()
+            assert (package_dir / "_globals.py").exists()
 
             # Verify imports were converted to relative
-            modified_content = test_file.read_text()
+            # Read from package_dir which may be temp package directory
+            test_file_in_package = package_dir / test_file.name
+            modified_content = test_file_in_package.read_text()
             assert "from ._shared.image_utils import save_PIL_image" in modified_content
             assert "from ._shared.file_utils import get_filepaths_config" in modified_content
             assert "from ._globals import is_testing" in modified_content
@@ -455,12 +459,15 @@ def shared_function():
             assert "from pathlib import Path" in modified_content
 
             # Verify import statement conversion
-            modified_content2 = test_file2.read_text()
+            test_file2_in_package = package_dir / test_file2.name
+            modified_content2 = test_file2_in_package.read_text()
             assert "from . import _globals" in modified_content2
 
             # Verify relative imports in copied files were fixed
-            if (subfolder / "_shared" / "shared_utils.py").exists():
-                shared_utils_content = (subfolder / "_shared" / "shared_utils.py").read_text()
+            # Check in the package directory (which may be temp package dir)
+            shared_utils_path = package_dir / "_shared" / "shared_utils.py"
+            if shared_utils_path.exists():
+                shared_utils_content = shared_utils_path.read_text()
                 # The relative import should be converted to absolute
                 assert (
                     "from .file_utils import" not in shared_utils_content
@@ -470,6 +477,7 @@ def shared_function():
             # Cleanup should restore original imports
             manager.cleanup()
 
+            # After cleanup, check original files (not temp package dir)
             restored_content = test_file.read_text()
             assert restored_content == original_content
 

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/tests/test_preserve_directory_structure.py

@@ -161,14 +161,16 @@ packages = ["src/test_package"]
         assert len(data_deps) > 0, "data dependencies should be found"
 
         # Verify models structure was copied with full path
-        models_path = src_dir / "models" / "Information_extraction" / "_shared_ie" / "ie_enums.py"
+        # Use manager.src_dir which may point to temp package directory
+        package_dir = manager.src_dir
+        models_path = package_dir / "models" / "Information_extraction" / "_shared_ie" / "ie_enums.py"
         assert models_path.exists(), (
             "models/Information_extraction/_shared_ie/ie_enums.py should be copied with full structure"
         )
 
         # Verify data structure was copied with full path
         data_path = (
-            src_dir / "data" / "spreadsheet_creation" / "spreadsheet_formatting_dataclasses.py"
+            package_dir / "data" / "spreadsheet_creation" / "spreadsheet_formatting_dataclasses.py"
         )
         assert data_path.exists(), (
             "data/spreadsheet_creation/spreadsheet_formatting_dataclasses.py should be copied with full structure"

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/tests/test_spreadsheet_creation_imports.py

@@ -139,7 +139,9 @@ packages = ["src/test_package"]
 
         # Verify spreadsheet_creation directory was copied with full structure preserved
         # Import is "data.spreadsheet_creation.spreadsheet_formatting_dataclasses", so structure should be preserved
-        copied_dir = src_dir / "data" / "spreadsheet_creation"
+        # Use manager.src_dir which may point to temp package directory
+        package_dir = manager.src_dir
+        copied_dir = package_dir / "data" / "spreadsheet_creation"
         assert copied_dir.exists(), (
             f"spreadsheet_creation directory should be copied with structure at {copied_dir}"
         )

{python_package_folder-5.3.0 → python_package_folder-6.0.0}/tests/test_subfolder_build.py

@@ -63,7 +63,7 @@ class TestSubfolderBuildConfig:
             version="1.0.0",
         )
 
-        assert config.package_name == "subfolder"
+        assert config.package_name == "test-package-subfolder"
         assert config.version == "1.0.0"
         assert config.dependency_group is None
 
@@ -104,7 +104,7 @@ class TestSubfolderBuildConfig:
         content = pyproject_path.read_text()
 
         # Check package name and version are set
-        assert 'name = "subfolder"' in content
+        assert 'name = "test-package-subfolder"' in content
         assert 'version = "2.0.0"' in content
 
         # Check dynamic versioning is removed
@@ -226,7 +226,7 @@ class TestSubfolderBuildConfig:
         ) as config:
             config.create_temp_pyproject()
             content = (test_project_with_pyproject / "pyproject.toml").read_text()
-            assert 'name = "subfolder"' in content
+            assert 'name = "test-package-subfolder"' in content
 
         # Check restore happened automatically
         restored_content = (test_project_with_pyproject / "pyproject.toml").read_text()
@@ -262,7 +262,7 @@ class TestSubfolderBuildConfig:
             config.create_temp_pyproject()
 
     def test_package_name_derivation(self, test_project_with_pyproject: Path) -> None:
-        """Test package name derivation from directory name."""
+        """Test package name derivation from root project name and directory name."""
         # Test with underscores
         subfolder = test_project_with_pyproject / "subfolder_to_build"
         subfolder.mkdir()
@@ -271,7 +271,7 @@ class TestSubfolderBuildConfig:
             src_dir=subfolder,
             version="1.0.0",
         )
-        assert config.package_name == "subfolder-to-build"
+        assert config.package_name == "test-package-subfolder-to-build"
 
         # Test with spaces
         subfolder2 = test_project_with_pyproject / "subfolder with spaces"
@@ -281,7 +281,24 @@ class TestSubfolderBuildConfig:
             src_dir=subfolder2,
             version="1.0.0",
         )
-        assert config2.package_name == "subfolder-with-spaces"
+        assert config2.package_name == "test-package-subfolder-with-spaces"
+    
+    def test_package_name_derivation_no_root_project(self, tmp_path: Path) -> None:
+        """Test package name derivation when root project name is not found (fallback)."""
+        # Create a project without pyproject.toml
+        project_root = tmp_path / "test_project_no_pyproject"
+        project_root.mkdir()
+        
+        subfolder = project_root / "subfolder"
+        subfolder.mkdir()
+        
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+        # Should fallback to just subfolder name when root project name not found
+        assert config.package_name == "subfolder"
 
 
 def test_readme_handling_with_existing_readme(test_project_with_pyproject: Path):
@@ -666,8 +683,8 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
         assert "[tool.hatch.version]" not in content
         assert "[tool.uv-dynamic-versioning]" not in content
 
-        # Verify packages path is set correctly
-        assert 'packages = ["subfolder"]' in content or '"subfolder"' in content
+        # Verify packages path is set correctly (should use temp package directory)
+        assert '.temp_package_my_custom_package' in content
 
         # Verify backup was created
         assert (project_root / "pyproject.toml.original").exists()
@@ -717,8 +734,8 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
         # Verify only-include is present
         assert "only-include = [" in content
 
-        # Verify the subfolder is included
-        assert '"subfolder"' in content
+        # Verify the temp package directory is included (not the original subfolder)
+        assert '.temp_package_test_package' in content
 
         # Verify necessary files are included
         assert '"pyproject.toml"' in content
@@ -856,7 +873,7 @@ description = "Subfolder package"
         # Verify it was modified
         modified_content = (project_root / "pyproject.toml").read_text()
         assert modified_content != original_content
-        assert 'name = "subfolder"' in modified_content
+        assert 'name = "test-package-subfolder"' in modified_content
 
         # Restore
         config.restore()
@@ -933,3 +950,173 @@ description = "Subfolder package"
         assert 'build-backend = "hatchling.build"' in content
 
         config.restore()
+
+
+class TestTemporaryPackageDirectory:
+    """Tests for temporary package directory creation and cleanup."""
+
+    def test_temp_package_directory_created_with_correct_name(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """Test that temporary package directory is created with correct import name."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        (subfolder / "module.py").write_text("def func(): pass")
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        # Package name should be "test-package-subfolder" (with hyphens)
+        assert config.package_name == "test-package-subfolder"
+
+        # Create temp pyproject (which creates temp package directory)
+        config.create_temp_pyproject()
+
+        # Temp package directory should exist with import name (underscores)
+        temp_package_dir = project_root / ".temp_package_test_package_subfolder"
+        assert temp_package_dir.exists()
+        assert config._temp_package_dir == temp_package_dir
+
+        # Temp package directory should contain the subfolder contents
+        assert (temp_package_dir / "module.py").exists()
+
+        # Cleanup
+        config.restore()
+
+    def test_temp_package_directory_uses_import_name(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """Test that temp package directory name converts hyphens to underscores."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        (subfolder / "module.py").write_text("def func(): pass")
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+            package_name="my-custom-package",  # Package name with hyphens
+        )
+
+        config.create_temp_pyproject()
+
+        # Temp directory should use underscores (import name)
+        temp_package_dir = project_root / ".temp_package_my_custom_package"
+        assert temp_package_dir.exists()
+        assert config._temp_package_dir == temp_package_dir
+
+        config.restore()
+
+    def test_temp_package_directory_cleaned_up(self, test_project_with_pyproject: Path) -> None:
+        """Test that temporary package directory is cleaned up on restore."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        (subfolder / "module.py").write_text("def func(): pass")
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        config.create_temp_pyproject()
+
+        # Verify temp directory exists
+        temp_package_dir = config._temp_package_dir
+        assert temp_package_dir is not None
+        assert temp_package_dir.exists()
+
+        # Restore should clean it up
+        config.restore()
+
+        # Temp directory should be removed
+        assert not temp_package_dir.exists()
+        assert config._temp_package_dir is None
+
+    def test_packages_configuration_uses_temp_directory(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """Test that packages configuration uses temp directory path."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        (subfolder / "module.py").write_text("def func(): pass")
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        pyproject_path = config.create_temp_pyproject()
+        assert pyproject_path is not None
+
+        content = pyproject_path.read_text()
+
+        # Packages configuration should use temp directory path
+        # Temp directory name is ".temp_package_test_package_subfolder"
+        assert ".temp_package_test_package_subfolder" in content
+
+        config.restore()
+
+    def test_temp_package_directory_preserves_structure(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """Test that temp package directory preserves the original directory structure."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        (subfolder / "module.py").write_text("def func(): pass")
+        (subfolder / "submodule").mkdir()
+        (subfolder / "submodule" / "__init__.py").write_text("")
+        (subfolder / "submodule" / "helper.py").write_text("def helper(): pass")
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        config.create_temp_pyproject()
+
+        temp_package_dir = config._temp_package_dir
+        assert temp_package_dir is not None
+
+        # Verify structure is preserved
+        assert (temp_package_dir / "module.py").exists()
+        assert (temp_package_dir / "submodule" / "__init__.py").exists()
+        assert (temp_package_dir / "submodule" / "helper.py").exists()
+
+        config.restore()
+
+    def test_temp_package_directory_handles_existing_directory(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """Test that temp package directory creation handles existing directory."""
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        (subfolder / "module.py").write_text("def func(): pass")
+
+        # Create a directory that would conflict
+        existing_temp_dir = project_root / ".temp_package_test_package_subfolder"
+        existing_temp_dir.mkdir()
+        (existing_temp_dir / "old_file.py").write_text("# Old file")
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        # Should remove existing directory and create new one
+        config.create_temp_pyproject()
+
+        temp_package_dir = config._temp_package_dir
+        assert temp_package_dir is not None
+        assert temp_package_dir.exists()
+        # Should have new file, not old file
+        assert (temp_package_dir / "module.py").exists()
+        assert not (temp_package_dir / "old_file.py").exists()
+
+        config.restore()