python-package-folder 7.1.0__tar.gz → 8.0.0__tar.gz

{python_package_folder-7.1.0 → python_package_folder-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 7.1.0
+Version: 8.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-7.1.0 → python_package_folder-8.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">65%</text>
-    <text x="81" y="14">65%</text>
+    <text x="81" y="15" fill="#010101" fill-opacity=".3">66%</text>
+    <text x="81" y="14">66%</text>
   </g>
 </svg>

{python_package_folder-7.1.0 → python_package_folder-8.0.0}/pyproject.toml

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

{python_package_folder-7.1.0 → python_package_folder-8.0.0}/src/python_package_folder/manager.py

@@ -933,6 +933,9 @@ class BuildManager:
         ambiguous: list[ImportInfo] = []
 
         for file_path in python_files:
+            # Skip files that don't exist (might be in temp directory that wasn't fully created)
+            if not file_path.exists():
+                continue
             imports = analyzer.extract_imports(file_path)
             for imp in imports:
                 analyzer.classify_import(imp, self.src_dir)

{python_package_folder-7.1.0 → python_package_folder-8.0.0}/src/python_package_folder/subfolder_build.py

@@ -280,9 +280,19 @@ class SubfolderBuildConfig:
                 in_sdist_section = False
                 result.append(line)
             elif in_sdist_section:
-                # Track if only-include already exists
+                # Replace only-include path if it exists
                 if re.match(r"^\s*only-include\s*=", line):
                     only_include_set = True
+                    # Replace with correct path
+                    only_include_paths = [correct_packages_path]
+                    only_include_paths.append("pyproject.toml")
+                    only_include_paths.append("README.md")
+                    only_include_paths.append("README.rst")
+                    only_include_paths.append("README.txt")
+                    only_include_paths.append("README")
+                    only_include_str = ", ".join(f'"{p}"' for p in only_include_paths)
+                    result.append(f"only-include = [{only_include_str}]")
+                    continue
                 result.append(line)
             elif in_hatch_build_section:
                 result.append(line)
@@ -327,19 +337,27 @@ class SubfolderBuildConfig:
 
         # Use only-include for source distributions to ensure only the subfolder is included
         # This prevents including files from the project root
-        if correct_packages_path and not only_include_set:
-            result.append("")
-            result.append("[tool.hatch.build.targets.sdist]")
-            # Include only the subfolder directory and necessary files
-            only_include_paths = [correct_packages_path]
-            # Also include pyproject.toml and README if they exist
-            only_include_paths.append("pyproject.toml")
-            only_include_paths.append("README.md")
-            only_include_paths.append("README.rst")
-            only_include_paths.append("README.txt")
-            only_include_paths.append("README")
-            only_include_str = ", ".join(f'"{p}"' for p in only_include_paths)
-            result.append(f"only-include = [{only_include_str}]")
+        # Only add sdist section if it doesn't already exist and only-include wasn't set
+        if correct_packages_path:
+            # Check if sdist section already exists in result
+            sdist_section_exists = any(
+                line.strip().startswith("[tool.hatch.build.targets.sdist]")
+                for line in result
+            )
+            # Only add section and only-include if they don't already exist
+            if not sdist_section_exists and not only_include_set:
+                result.append("")
+                result.append("[tool.hatch.build.targets.sdist]")
+                # Include only the subfolder directory and necessary files
+                only_include_paths = [correct_packages_path]
+                # Also include pyproject.toml and README if they exist
+                only_include_paths.append("pyproject.toml")
+                only_include_paths.append("README.md")
+                only_include_paths.append("README.rst")
+                only_include_paths.append("README.txt")
+                only_include_paths.append("README")
+                only_include_str = ", ".join(f'"{p}"' for p in only_include_paths)
+                result.append(f"only-include = [{only_include_str}]")
 
         return "\n".join(result)
 
@@ -407,6 +425,14 @@ class SubfolderBuildConfig:
                 # This will copy the __init__.py we just created (if any)
                 self._create_temp_package_directory()
                 
+                # Verify temporary package directory was created
+                if not self._temp_package_dir or not self._temp_package_dir.exists():
+                    print(
+                        f"Warning: Temporary package directory was not created. "
+                        f"Falling back to using src_dir: {self.src_dir}",
+                        file=sys.stderr,
+                    )
+                
                 # 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
                 # Use the subfolder's pyproject.toml
@@ -421,6 +447,8 @@ class SubfolderBuildConfig:
                 temp_pyproject_path = self.project_root / "pyproject.toml.temp"
 
                 # Adjust packages path to be relative to project root
+                # This must be called AFTER _create_temp_package_directory() so _get_package_structure() 
+                # can find the temporary directory
                 adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
                 
                 # Read exclude patterns from root pyproject.toml and inject them (if it exists)

{python_package_folder-7.1.0 → python_package_folder-8.0.0}/tests/test_subfolder_build.py

@@ -1353,4 +1353,393 @@ build-backend = "hatchling.build"
         
         # Verify dist-info also exists
         dist_info_dir = site_packages / f"{import_name}-{version}.dist-info"
-        assert dist_info_dir.exists(), f"dist-info directory should exist: {dist_info_dir}"
+        assert dist_info_dir.exists(), f"dist-info directory should exist: {dist_info_dir}"
+
+    def test_wheel_with_subfolder_pyproject_toml_uses_temp_directory(self, tmp_path: Path) -> None:
+        """Test that when subfolder has pyproject.toml with only-include, it's replaced with temp directory."""
+        project_root = tmp_path / "test_project"
+        project_root.mkdir()
+
+        # Create parent pyproject.toml
+        pyproject_content = """[project]
+name = "test-package"
+version = "0.1.0"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+"""
+        (project_root / "pyproject.toml").write_text(pyproject_content)
+
+        # Create subfolder with pyproject.toml that has only-include
+        subfolder = project_root / "src" / "data"
+        subfolder.mkdir(parents=True)
+        
+        # Create some Python files
+        (subfolder / "__init__.py").write_text("# Package init")
+        (subfolder / "module.py").write_text("def hello(): return 'world'")
+        
+        # Create subfolder pyproject.toml with only-include pointing to src/data
+        subfolder_pyproject = """[project]
+name = "ml-drawing-assistant-data"
+version = "1.0.0"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/data"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src/data", "pyproject.toml", "README.md"]
+"""
+        (subfolder / "pyproject.toml").write_text(subfolder_pyproject)
+
+        # Package name with hyphens
+        package_name = "ml-drawing-assistant-data"
+        import_name = "ml_drawing_assistant_data"  # Expected import name
+        version = "1.0.0"
+
+        # Build the wheel
+        manager = BuildManager(project_root=project_root, src_dir=subfolder)
+        
+        def build_wheel() -> None:
+            """Build the wheel using uv build."""
+            subprocess.run(
+                ["uv", "build", "--wheel"],
+                cwd=project_root,
+                check=True,
+                capture_output=True,
+            )
+
+        try:
+            manager.run_build(build_wheel, version=version, package_name=package_name)
+        finally:
+            manager.cleanup()
+
+        # Find the built wheel
+        dist_dir = project_root / "dist"
+        assert dist_dir.exists(), "dist directory should exist after build"
+        
+        wheel_files = list(dist_dir.glob("*.whl"))
+        assert len(wheel_files) > 0, "At least one wheel should be built"
+        
+        wheel_file = wheel_files[0]
+        
+        # Extract and inspect the wheel
+        with zipfile.ZipFile(wheel_file, "r") as wheel:
+            file_names = wheel.namelist()
+            
+            # Verify the package directory exists with the correct import name
+            package_dir_prefix = f"{import_name}/"
+            package_files = [f for f in file_names if f.startswith(package_dir_prefix)]
+            
+            assert len(package_files) > 0, (
+                f"Wheel should contain files in {import_name}/ directory, not 'data/'. "
+                f"Found files: {[f for f in file_names if '/' in f and '.dist-info' not in f][:10]}"
+            )
+            
+            # Verify the expected files are present
+            assert f"{import_name}/__init__.py" in file_names, (
+                f"Wheel should contain {import_name}/__init__.py"
+            )
+            assert f"{import_name}/module.py" in file_names, (
+                f"Wheel should contain {import_name}/module.py"
+            )
+            
+            # Verify 'data/' is NOT in the wheel (should be replaced with import_name)
+            data_files = [f for f in file_names if f.startswith("data/") and ".dist-info" not in f]
+            assert len(data_files) == 0, (
+                f"Wheel should not contain 'data/' directory, should use '{import_name}/' instead. "
+                f"Found: {data_files[:5]}"
+            )
+
+    def test_real_world_ml_drawing_assistant_data_scenario(self, tmp_path: Path) -> None:
+        """
+        Integration test that mimics publishing src/data as ml-drawing-assistant-data.
+        
+        This test verifies the complete workflow:
+        1. Project structure with src/data subfolder
+        2. External dependencies (_shared, models, etc.)
+        3. Subfolder pyproject.toml with only-include
+        4. Building and installing the wheel
+        5. Verifying the package directory exists with correct name
+        """
+        project_root = tmp_path / "ml_drawing_assistant"
+        project_root.mkdir()
+
+        # Create parent pyproject.toml (similar to ml-drawing-assistant)
+        parent_pyproject = """[project]
+name = "ml-drawing-assistant"
+version = "0.1.0"
+description = "ML Drawing Assistant"
+requires-python = ">=3.12, <3.13"
+dependencies = [
+    "numpy>=2.2.5",
+    "pillow>=11.2.1",
+]
+
+[tool.python-package-folder]
+exclude-patterns = ["_SS", "__SS", ".*_test.*", ".*test_.*", "sandbox"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+"""
+        (project_root / "pyproject.toml").write_text(parent_pyproject)
+
+        # Create external dependency: _shared
+        shared_dir = project_root / "src" / "_shared"
+        shared_dir.mkdir(parents=True)
+        (shared_dir / "__init__.py").write_text("# Shared utilities")
+        (shared_dir / "image_utils.py").write_text("def process_image(): return 'processed'")
+
+        # Create external dependency: models/Information_extraction/_shared_ie
+        models_ie_dir = project_root / "src" / "models" / "Information_extraction" / "_shared_ie"
+        models_ie_dir.mkdir(parents=True)
+        (models_ie_dir / "__init__.py").write_text("# IE shared")
+        (models_ie_dir / "ie_enums.py").write_text("class IEEnum: pass")
+
+        # Create external dependency: _globals.py
+        (project_root / "src" / "_globals.py").write_text("IS_TESTING = False")
+
+        # Create the subfolder to publish: src/data
+        data_dir = project_root / "src" / "data"
+        data_dir.mkdir(parents=True)
+        
+        # Create some Python files in data/
+        (data_dir / "__init__.py").write_text("# ML Drawing Assistant Data Package")
+        # Use imports that will be found as external dependencies
+        # These will be copied into the temp package directory during build
+        (data_dir / "datacollection.py").write_text(
+            """# Import external dependencies that will be copied during build
+try:
+    from _shared.image_utils import process_image
+    from models.Information_extraction._shared_ie.ie_enums import IEEnum
+    from _globals import IS_TESTING
+except ImportError:
+    # During analysis, these might not be available yet
+    pass
+
+def collect_data():
+    try:
+        return process_image()
+    except NameError:
+        return "data collected"
+"""
+        )
+        (data_dir / "data_storage").mkdir(parents=True)
+        (data_dir / "data_storage" / "storage.py").write_text("def store(): pass")
+        (data_dir / "data_storage" / "__init__.py").write_text("")
+
+        # Create subfolder pyproject.toml (similar to real scenario)
+        # This has only-include pointing to src/data which should be replaced
+        subfolder_pyproject = """[project]
+name = "ml-drawing-assistant-data"
+version = "1.0.0"
+description = "Data package for ML Drawing Assistant"
+requires-python = ">=3.12, <3.13"
+dependencies = [
+    "numpy>=2.2.5",
+    "pillow>=11.2.1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/data"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src/data", "pyproject.toml", "README.md"]
+"""
+        (data_dir / "pyproject.toml").write_text(subfolder_pyproject)
+
+        # Package name with hyphens (like ml-drawing-assistant-data)
+        package_name = "ml-drawing-assistant-data"
+        import_name = "ml_drawing_assistant_data"  # Expected import name
+        version = "1.0.0"
+
+        # Build the wheel
+        manager = BuildManager(project_root=project_root, src_dir=data_dir)
+        
+        def build_wheel() -> None:
+            """Build the wheel using uv build."""
+            result = subprocess.run(
+                ["uv", "build", "--wheel"],
+                cwd=project_root,
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode != 0:
+                print(f"Build failed with return code {result.returncode}")
+                print(f"stdout: {result.stdout}")
+                print(f"stderr: {result.stderr}")
+                raise subprocess.CalledProcessError(result.returncode, result.args, result.stdout, result.stderr)
+
+        try:
+            manager.run_build(build_wheel, version=version, package_name=package_name)
+        finally:
+            manager.cleanup()
+
+        # Find the built wheel
+        dist_dir = project_root / "dist"
+        assert dist_dir.exists(), "dist directory should exist after build"
+        
+        wheel_files = list(dist_dir.glob("*.whl"))
+        assert len(wheel_files) > 0, "At least one wheel should be built"
+        
+        wheel_file = wheel_files[0]
+        
+        # Extract and inspect the wheel
+        with zipfile.ZipFile(wheel_file, "r") as wheel:
+            file_names = wheel.namelist()
+            
+            # Verify the package directory exists with the correct import name
+            package_dir_prefix = f"{import_name}/"
+            package_files = [f for f in file_names if f.startswith(package_dir_prefix)]
+            
+            assert len(package_files) > 0, (
+                f"Wheel should contain files in {import_name}/ directory, not 'data/'. "
+                f"Found files: {[f for f in file_names if '/' in f and '.dist-info' not in f][:15]}"
+            )
+            
+            # Verify the expected files are present
+            # Note: When src/data is copied, it becomes ml_drawing_assistant_data/data/
+            # because copytree copies the directory structure
+            init_paths = [f"{import_name}/data/__init__.py", f"{import_name}/__init__.py"]
+            assert any(path in file_names for path in init_paths), (
+                f"Wheel should contain {import_name}/__init__.py or {import_name}/data/__init__.py"
+            )
+            datacollection_paths = [
+                f"{import_name}/data/datacollection.py",
+                f"{import_name}/datacollection.py"
+            ]
+            assert any(path in file_names for path in datacollection_paths), (
+                f"Wheel should contain datacollection.py. "
+                f"Found: {[f for f in file_names if 'datacollection' in f]}"
+            )
+            # data_storage should be under data/ if data/ is preserved
+            data_storage_paths = [
+                f"{import_name}/data/data_storage/storage.py",
+                f"{import_name}/data_storage/storage.py"
+            ]
+            assert any(path in file_names for path in data_storage_paths), (
+                f"Wheel should contain data_storage/storage.py. "
+                f"Found: {[f for f in file_names if 'storage.py' in f]}"
+            )
+            
+            # Verify external dependencies were copied
+            assert f"{import_name}/_shared/image_utils.py" in file_names, (
+                f"Wheel should contain copied external dependency {import_name}/_shared/image_utils.py"
+            )
+            assert f"{import_name}/models/Information_extraction/_shared_ie/ie_enums.py" in file_names, (
+                f"Wheel should contain copied external dependency {import_name}/models/Information_extraction/_shared_ie/ie_enums.py"
+            )
+            assert f"{import_name}/_globals.py" in file_names, (
+                f"Wheel should contain copied external dependency {import_name}/_globals.py"
+            )
+            
+            # Verify 'data/' is NOT in the wheel (should be replaced with import_name)
+            data_files = [f for f in file_names if f.startswith("data/") and ".dist-info" not in f]
+            assert len(data_files) == 0, (
+                f"Wheel should not contain 'data/' directory, should use '{import_name}/' instead. "
+                f"Found: {data_files[:5]}"
+            )
+            
+            # Verify 'src/data' is NOT in the wheel
+            src_data_files = [f for f in file_names if "src/data" in f and ".dist-info" not in f]
+            assert len(src_data_files) == 0, (
+                f"Wheel should not contain 'src/data' paths, should use '{import_name}/' instead. "
+                f"Found: {src_data_files[:5]}"
+            )
+
+        # Try to install the wheel to verify it works (optional - skip if installation fails)
+        # This verifies the package can be installed and the package directory exists
+        try:
+            # Create a temporary virtual environment and install the wheel
+            venv_dir = tmp_path / "test_venv"
+            venv.create(venv_dir, with_pip=True)
+            
+            # Determine the Python executable in the venv
+            if sys.platform == "win32":
+                python_exe = venv_dir / "Scripts" / "python.exe"
+                pip_exe = venv_dir / "Scripts" / "pip.exe"
+            else:
+                python_exe = venv_dir / "bin" / "python"
+                pip_exe = venv_dir / "bin" / "pip"
+            
+            # Install the wheel
+            install_result = subprocess.run(
+                [str(pip_exe), "install", str(wheel_file)],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            
+            if install_result.returncode != 0:
+                # Installation failed - skip installation verification but wheel packaging is still verified
+                print(f"Note: Wheel installation failed (this is OK for testing): {install_result.stderr}")
+                return  # Wheel contents verification above is the main test
+            
+            # Find the site-packages directory
+            if sys.platform == "win32":
+                site_packages = venv_dir / "Lib" / "site-packages"
+            else:
+                # Get Python version
+                version_result = subprocess.run(
+                    [str(python_exe), "-c", "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                py_version = version_result.stdout.strip()
+                site_packages = venv_dir / "lib" / f"python{py_version}" / "site-packages"
+            
+            assert site_packages.exists(), f"site-packages directory should exist at {site_packages}"
+            
+            # Verify the package directory exists (not just dist-info)
+            package_dir = site_packages / import_name
+            assert package_dir.exists(), (
+                f"Package directory {import_name}/ should exist in site-packages after installation. "
+                f"Found in site-packages: {list(site_packages.iterdir())[:20]}"
+            )
+            assert package_dir.is_dir(), f"{import_name} should be a directory, not a file"
+            
+            # Verify the expected files are present
+            # Check both possible structures (with or without data/ subdirectory)
+            init_exists = (package_dir / "__init__.py").exists() or (package_dir / "data" / "__init__.py").exists()
+            assert init_exists, f"{import_name}/__init__.py or {import_name}/data/__init__.py should exist"
+            
+            datacollection_exists = (package_dir / "datacollection.py").exists() or (package_dir / "data" / "datacollection.py").exists()
+            assert datacollection_exists, f"{import_name}/datacollection.py or {import_name}/data/datacollection.py should exist"
+            
+            storage_exists = (
+                (package_dir / "data_storage" / "storage.py").exists() or
+                (package_dir / "data" / "data_storage" / "storage.py").exists()
+            )
+            assert storage_exists, f"{import_name}/data_storage/storage.py should exist"
+            
+            # Verify external dependencies were installed
+            assert (package_dir / "_shared" / "image_utils.py").exists(), (
+                f"{import_name}/_shared/image_utils.py should exist after installation"
+            )
+            assert (package_dir / "models" / "Information_extraction" / "_shared_ie" / "ie_enums.py").exists(), (
+                f"{import_name}/models/Information_extraction/_shared_ie/ie_enums.py should exist after installation"
+            )
+            assert (package_dir / "_globals.py").exists(), (
+                f"{import_name}/_globals.py should exist after installation"
+            )
+            
+            # Verify dist-info also exists
+            dist_info_dir = site_packages / f"{import_name}-{version}.dist-info"
+            assert dist_info_dir.exists(), f"dist-info directory should exist: {dist_info_dir}"
+            
+            # Verify we can import the package
+            import_result = subprocess.run(
+                [str(python_exe), "-c", f"import {import_name}; print('OK')"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            assert "OK" in import_result.stdout, f"Should be able to import {import_name}"
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            # Installation or import failed - this is acceptable if dependencies are missing
+            # The main verification (wheel contents) has already passed
+            print(f"Note: Installation/import test skipped due to: {e}")
+            # The wheel packaging verification above is the main test