python-package-folder 9.1.0__tar.gz → 9.2.0__tar.gz

{python_package_folder-9.1.0 → python_package_folder-9.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 9.1.0
+Version: 9.2.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-9.1.0 → python_package_folder-9.2.0}/pyproject.toml

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

{python_package_folder-9.1.0 → python_package_folder-9.2.0}/src/python_package_folder/analyzer.py

@@ -310,6 +310,15 @@ class ImportAnalyzer:
             self.project_root / module_path_str / "__init__.py",
             (self.project_root / module_path_str).with_suffix(".py"),
         ]
+        
+        # Also check project_root/src/ for files at src/ root (like _globals.py)
+        # This is important when building subfolders where src_dir points to temp directory
+        src_base = self.project_root / "src"
+        if src_base.exists():
+            potential_paths.extend([
+                src_base / module_path_str / "__init__.py",
+                (src_base / module_path_str).with_suffix(".py"),
+            ])
 
         for path in potential_paths:
             if path.exists():
@@ -335,6 +344,13 @@ class ImportAnalyzer:
             potential_file = parent / f"{module_name.split('.')[-1]}.py"
             if potential_file.exists():
                 return potential_file
+            
+            # Also check project_root/src/ for files at src/ root
+            # This handles cases like _globals.py at src/_globals.py when building subfolders
+            if parent == self.project_root and src_base.exists():
+                src_file = src_base / f"{module_name.split('.')[-1]}.py"
+                if src_file.exists():
+                    return src_file
 
             # Check all subdirectories in parent (not just common ones)
             # This handles cases like src/data/spreadsheet_creation/spreadsheet_formatting_dataclasses.py

python_package_folder-9.2.0/tests/test_subfolder_build.py

@@ -0,0 +1,62 @@
+"""Tests for subfolder build functionality."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+import venv
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from python_package_folder import BuildManager, SubfolderBuildConfig
+
+
+@pytest.fixture
+def test_project_with_pyproject(tmp_path: Path) -> Path:
+    """Create a test project with pyproject.toml."""
+    project_root = tmp_path / "test_project"
+    project_root.mkdir()
+
+    # Create pyproject.toml
+    pyproject_content = """[project]
+name = "test-package"
+version = "0.1.0"
+dynamic = ["version"]
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "pep440"
+bump = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/test_package"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+test = [
+    "pytest>=8.0.0",
+    "mypy>=1.0.0",
+]
+"""
+    (project_root / "pyproject.toml").write_text(pyproject_content)
+
+    # Create subfolder
+    subfolder = project_root / "subfolder"
+    subfolder.mkdir(exist_ok=True)
+    (subfolder / "module.py").write_text("def func(): pass")
+
+    return project_root
+
+
+
+# This file has been split into multiple test files.
+# See test_subfolder_*.py files for the actual tests.

python_package_folder-9.2.0/tests/test_subfolder_build_config.py

@@ -0,0 +1,399 @@
+"""Tests for subfolder build functionality."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+import venv
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from python_package_folder import BuildManager, SubfolderBuildConfig
+
+
+@pytest.fixture
+def test_project_with_pyproject(tmp_path: Path) -> Path:
+    """Create a test project with pyproject.toml."""
+    project_root = tmp_path / "test_project"
+    project_root.mkdir()
+
+    # Create pyproject.toml
+    pyproject_content = """[project]
+name = "test-package"
+version = "0.1.0"
+dynamic = ["version"]
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "pep440"
+bump = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/test_package"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+test = [
+    "pytest>=8.0.0",
+    "mypy>=1.0.0",
+]
+"""
+    (project_root / "pyproject.toml").write_text(pyproject_content)
+
+    # Create subfolder
+    subfolder = project_root / "subfolder"
+    subfolder.mkdir(exist_ok=True)
+    (subfolder / "module.py").write_text("def func(): pass")
+
+    return project_root
+
+
+class TestSubfolderBuildConfig:
+    """
+    Tests for SubfolderBuildConfig class.
+    
+    This class tests the core functionality of SubfolderBuildConfig, including:
+    - Initialization with default and custom package names
+    - Temporary pyproject.toml creation and configuration
+    - Dependency group handling
+    - __init__.py file creation
+    
+    File: test_subfolder_build_config.py
+    When to add tests here: Tests for SubfolderBuildConfig initialization, configuration,
+    and temporary file management should go in this class.
+    """
+
+    def test_init_with_defaults(self, test_project_with_pyproject: Path) -> None:
+        """Test initialization with default package name."""
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+            version="1.0.0",
+        )
+
+        assert config.package_name == "test-package-subfolder"
+        assert config.version == "1.0.0"
+        assert config.dependency_group is None
+
+    def test_init_with_custom_name(self, test_project_with_pyproject: Path) -> None:
+        """Test initialization with custom package name."""
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+            package_name="custom-package",
+            version="1.0.0",
+        )
+
+        assert config.package_name == "custom-package"
+        assert config.version == "1.0.0"
+
+    def test_init_with_dependency_group(self, test_project_with_pyproject: Path) -> None:
+        """Test initialization with dependency group."""
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+            version="1.0.0",
+            dependency_group="dev",
+        )
+
+        assert config.dependency_group == "dev"
+
+    def test_create_temp_pyproject(self, test_project_with_pyproject: Path) -> None:
+        """Test creating temporary pyproject.toml."""
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+            version="2.0.0",
+        )
+
+        pyproject_path = config.create_temp_pyproject()
+
+        assert pyproject_path.exists()
+        content = pyproject_path.read_text()
+
+        # Check package name and version are set
+        assert 'name = "test-package-subfolder"' in content
+        assert 'version = "2.0.0"' in content
+
+        # Check dynamic versioning is removed
+        assert 'dynamic = ["version"]' not in content
+        assert "[tool.hatch.version]" not in content
+        assert "[tool.uv-dynamic-versioning]" not in content
+
+    def test_create_temp_pyproject_with_dependency_group(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """Test creating temporary pyproject.toml with dependency group."""
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+            version="2.0.0",
+            dependency_group="dev",
+        )
+
+        pyproject_path = config.create_temp_pyproject()
+        content = pyproject_path.read_text()
+
+        # Check dependency group is included
+        assert "[dependency-groups]" in content
+        assert "dev = [" in content
+        assert '"pytest>=8.0.0"' in content
+
+    def test_create_temp_pyproject_creates_init(self, test_project_with_pyproject: Path) -> None:
+        """Test that __init__.py is created if missing."""
+        subfolder = test_project_with_pyproject / "subfolder"
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        # Ensure __init__.py doesn't exist
+        init_file = subfolder / "__init__.py"
+        if init_file.exists():
+            init_file.unlink()
+
+        config.create_temp_pyproject()
+
+        # Check __init__.py was created
+        assert init_file.exists()
+        assert config._temp_init_created
+
+    def test_restore_pyproject(self, test_project_with_pyproject: Path) -> None:
+        """Test restoring original pyproject.toml."""
+        original_content = (test_project_with_pyproject / "pyproject.toml").read_text()
+
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+            version="1.0.0",
+        )
+
+        config.create_temp_pyproject()
+        config.restore()
+
+        # Check original content is restored
+        restored_content = (test_project_with_pyproject / "pyproject.toml").read_text()
+        assert restored_content == original_content
+
+        # Check backup is removed
+        assert not (test_project_with_pyproject / "pyproject.toml.original").exists()
+
+    def test_restore_removes_temp_init(self, test_project_with_pyproject: Path) -> None:
+        """Test that restore removes temporary __init__.py."""
+        subfolder = test_project_with_pyproject / "subfolder"
+        init_file = subfolder / "__init__.py"
+
+        # Ensure __init__.py doesn't exist
+        if init_file.exists():
+            init_file.unlink()
+
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        config.create_temp_pyproject()
+        assert init_file.exists()
+
+        config.restore()
+
+        # Check __init__.py was removed
+        assert not init_file.exists()
+
+    def test_restore_preserves_existing_init(self, test_project_with_pyproject: Path) -> None:
+        """Test that restore preserves existing __init__.py."""
+        subfolder = test_project_with_pyproject / "subfolder"
+        init_file = subfolder / "__init__.py"
+
+        # Create existing __init__.py
+        init_file.write_text("# Original content")
+
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+
+        config.create_temp_pyproject()
+        config.restore()
+
+        # Check original __init__.py is preserved
+        assert init_file.exists()
+        assert init_file.read_text() == "# Original content"
+
+    def test_context_manager(self, test_project_with_pyproject: Path) -> None:
+        """Test using SubfolderBuildConfig as context manager."""
+        original_content = (test_project_with_pyproject / "pyproject.toml").read_text()
+
+        with SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+            version="1.0.0",
+        ) as config:
+            config.create_temp_pyproject()
+            content = (test_project_with_pyproject / "pyproject.toml").read_text()
+            assert 'name = "test-package-subfolder"' in content
+
+        # Check restore happened automatically
+        restored_content = (test_project_with_pyproject / "pyproject.toml").read_text()
+        assert restored_content == original_content
+
+    def test_missing_dependency_group_warning(
+        self, test_project_with_pyproject: Path, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        """Test warning when dependency group doesn't exist."""
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+            version="1.0.0",
+            dependency_group="nonexistent",
+        )
+
+        # Create temp pyproject - this should print a warning
+        config.create_temp_pyproject()
+
+        # The warning is printed to stderr during create_temp_pyproject
+        # Since capsys might not capture it properly, we'll just verify
+        # that the build still works (warning is non-fatal)
+        assert config.temp_pyproject is not None
+
+    def test_version_required(self, test_project_with_pyproject: Path) -> None:
+        """Test that version is required."""
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=test_project_with_pyproject / "subfolder",
+        )
+
+        with pytest.raises(ValueError, match="Version is required"):
+            config.create_temp_pyproject()
+
+    def test_package_name_derivation(self, test_project_with_pyproject: Path) -> None:
+        """Test package name derivation from root project name and directory name."""
+        # Test with underscores
+        subfolder = test_project_with_pyproject / "subfolder_to_build"
+        subfolder.mkdir(exist_ok=True)
+        config = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=subfolder,
+            version="1.0.0",
+        )
+        assert config.package_name == "test-package-subfolder-to-build"
+
+        # Test with spaces
+        subfolder2 = test_project_with_pyproject / "subfolder with spaces"
+        subfolder2.mkdir()
+        config2 = SubfolderBuildConfig(
+            project_root=test_project_with_pyproject,
+            src_dir=subfolder2,
+            version="1.0.0",
+        )
+        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(exist_ok=True)
+        
+        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):
+    """Test that subfolder README is used when it exists."""
+    project_root = test_project_with_pyproject
+    subfolder = project_root / "subfolder"
+
+    # Create README in subfolder
+    subfolder_readme = subfolder / "README.md"
+    subfolder_readme.write_text("# Subfolder Package\n\nThis is the subfolder README.")
+
+    # Create README in project root
+    project_readme = project_root / "README.md"
+    project_readme.write_text("# Parent Package\n\nThis is the parent README.")
+
+    config = SubfolderBuildConfig(
+        project_root=project_root,
+        src_dir=subfolder,
+        version="1.0.0",
+    )
+
+    try:
+        config.create_temp_pyproject()
+
+        # Check that subfolder README was copied to project root
+        assert (project_root / "README.md").exists()
+        content = (project_root / "README.md").read_text()
+        assert "Subfolder Package" in content
+        assert "This is the subfolder README" in content
+        assert "Parent Package" not in content
+
+        # Check that backup was created
+        assert (project_root / "README.md.backup").exists()
+        backup_content = (project_root / "README.md.backup").read_text()
+        assert "Parent Package" in backup_content
+    finally:
+        config.restore()
+
+        # Verify original README was restored
+        assert (project_root / "README.md").exists()
+        restored_content = (project_root / "README.md").read_text()
+        assert "Parent Package" in restored_content
+        assert "Subfolder Package" not in restored_content
+        assert not (project_root / "README.md.backup").exists()
+
+
+def test_readme_handling_without_readme(test_project_with_pyproject: Path):
+    """Test that minimal README is created when subfolder has no README."""
+    project_root = test_project_with_pyproject
+    subfolder = project_root / "subfolder"
+
+    # Ensure no README exists
+    assert not (subfolder / "README.md").exists()
+    assert not (subfolder / "README.rst").exists()
+
+    config = SubfolderBuildConfig(
+        project_root=project_root,
+        src_dir=subfolder,
+        version="1.0.0",
+    )
+
+    try:
+        config.create_temp_pyproject()
+
+        # Check that minimal README was created
+        assert (project_root / "README.md").exists()
+        content = (project_root / "README.md").read_text()
+        assert content.strip() == f"# {subfolder.name}"
+    finally:
+        config.restore()
+
+        # Verify README was removed if it didn't exist before
+        if not (project_root / "README.md.backup").exists():
+            # No backup means no original README, so temp should be removed
+            assert (
+                not (project_root / "README.md").exists()
+                or (project_root / "README.md").read_text() != f"# {subfolder.name}\n"
+            )
+
+
+