python-package-folder 5.2.4__tar.gz → 5.4.0__tar.gz

{python_package_folder-5.2.4 → python_package_folder-5.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 5.2.4
+Version: 5.4.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.2.4 → python_package_folder-5.4.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">67%</text>
-    <text x="81" y="14">67%</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.2.4 → python_package_folder-5.4.0}/pyproject.toml

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

{python_package_folder-5.2.4 → python_package_folder-5.4.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}'..."
@@ -1191,13 +1200,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 +1242,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.2.4 → python_package_folder-5.4.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.2.4 → python_package_folder-5.4.0}/src/python_package_folder/subfolder_build.py

@@ -80,14 +80,46 @@ class SubfolderBuildConfig:
         self._exclude_temp_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 _get_package_structure(self) -> tuple[str, list[str]]:
         """

{python_package_folder-5.2.4 → python_package_folder-5.4.0}/src/python_package_folder/version_calculator.py

@@ -820,6 +820,7 @@ def parse_commit_for_bump(commit_message: str) -> str | None:
 def calculate_next_version(
     baseline_version: str,
     commits: list[str],
+    auto_bump_minor: bool = False,
 ) -> str | None:
     """
     Calculate next version from baseline and commits.
@@ -827,11 +828,21 @@ def calculate_next_version(
     Args:
         baseline_version: Current baseline version (e.g., "1.2.3")
         commits: List of commit messages since baseline
+        auto_bump_minor: If True and no conventional commits found, bump minor version
 
     Returns:
         Next version string or None if no changes require a version bump
     """
     if not commits:
+        # If no commits and auto_bump_minor is enabled, bump minor version
+        if auto_bump_minor:
+            try:
+                parts = baseline_version.split(".")
+                major = int(parts[0])
+                minor = int(parts[1]) if len(parts) > 1 else 0
+                return f"{major}.{minor + 1}.0"
+            except (ValueError, IndexError):
+                return None
         return None
 
     # Parse each commit to determine bump type
@@ -842,6 +853,16 @@ def calculate_next_version(
             bump_types.append(bump)
 
     if not bump_types:
+        # No conventional commits found
+        # If auto_bump_minor is enabled, bump minor version
+        if auto_bump_minor:
+            try:
+                parts = baseline_version.split(".")
+                major = int(parts[0])
+                minor = int(parts[1]) if len(parts) > 1 else 0
+                return f"{major}.{minor + 1}.0"
+            except (ValueError, IndexError):
+                return None
         return None
 
     # Determine highest bump (major > minor > patch)
@@ -975,7 +996,9 @@ def resolve_version(
 
     # Step 5: Calculate next version
     logger.info(f"Calculating next version from baseline {baseline_version} and {len(commits)} commits")
-    next_version = calculate_next_version(baseline_version, commits)
+    # Auto-bump minor version if no conventional commits found (but baseline exists)
+    auto_bump_minor = baseline_version is not None and baseline_version != "0.0.0"
+    next_version = calculate_next_version(baseline_version, commits, auto_bump_minor=auto_bump_minor)
 
     if next_version:
         logger.info(f"Calculated next version: {next_version}")

{python_package_folder-5.2.4 → python_package_folder-5.4.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):
@@ -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()