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

python_package_folder/analyzer.py

@@ -45,13 +45,55 @@ class ImportAnalyzer:
         """
         Recursively find all Python files in a directory.
 
+        Excludes common directories like .venv, venv, __pycache__, etc.
+
         Args:
             directory: Directory to search for Python files
 
         Returns:
             List of paths to all .py files found in the directory tree
         """
-        return [path for path in directory.rglob("*.py") if path.is_file()]
+        exclude_patterns = {
+            ".venv",
+            "venv",
+            "__pycache__",
+            ".git",
+            ".pytest_cache",
+            ".mypy_cache",
+            "node_modules",
+            ".tox",
+            "dist",
+            "build",
+        }
+
+        python_files = []
+        for path in directory.rglob("*.py"):
+            if not path.is_file():
+                continue
+
+            # Check if any part of the path matches exclusion patterns
+            should_exclude = False
+            for part in path.parts:
+                # Check exact matches
+                if part in exclude_patterns:
+                    should_exclude = True
+                    break
+                # Check if part starts with excluded pattern or contains .egg-info
+                for pattern in exclude_patterns:
+                    if part.startswith(pattern):
+                        should_exclude = True
+                        break
+                # Also exclude .egg-info directories
+                if ".egg-info" in part:
+                    should_exclude = True
+                    break
+                if should_exclude:
+                    break
+
+            if not should_exclude:
+                python_files.append(path)
+
+        return python_files
 
     def extract_imports(self, file_path: Path) -> list[ImportInfo]:
         """

python_package_folder/python_package_folder.py

@@ -122,7 +122,8 @@ def main() -> int:
             src_dir = Path(args.src_dir).resolve()
         else:
             # Auto-detect: use current directory if it has Python files, otherwise use project_root/src
-            src_dir = find_source_directory(project_root)
+            current_dir = Path.cwd()
+            src_dir = find_source_directory(project_root, current_dir=current_dir)
             if src_dir:
                 print(f"Auto-detected source directory: {src_dir}")
             else:

python_package_folder/subfolder_build.py

@@ -30,8 +30,11 @@ class SubfolderBuildConfig:
     Manages temporary build configuration for subfolder builds.
 
     When building a subfolder as a separate package, this class:
-    - Uses the subfolder's pyproject.toml if it exists
+    - Uses the subfolder's pyproject.toml if it exists (adjusts package paths and ensures
+      [build-system] uses hatchling)
     - Otherwise creates a temporary pyproject.toml with the appropriate package name and version
+    - Always ensures [build-system] section uses hatchling (replaces any existing build-system
+      configuration from parent or subfolder)
     - Handles README files similarly (uses subfolder README if present)
     """
 
@@ -111,13 +114,96 @@ class SubfolderBuildConfig:
         # If it's a package or has subpackages, return the path
         return packages_path, [packages_path] if packages_path else []
 
+    def _adjust_subfolder_pyproject_packages_path(self, content: str) -> str:
+        """
+        Adjust packages path in subfolder pyproject.toml to be relative to project root.
+
+        When a subfolder's pyproject.toml is copied to project root, the packages path
+        needs to be adjusted to point to the subfolder relative to the project root.
+
+        Args:
+            content: Content of the subfolder's pyproject.toml
+
+        Returns:
+            Adjusted content with correct packages path
+        """
+        # Get the correct packages path relative to project root
+        _, package_dirs = self._get_package_structure()
+        if not package_dirs:
+            # No adjustment needed if we can't determine the path
+            return content
+
+        correct_packages_path = package_dirs[0]
+        lines = content.split("\n")
+        result = []
+        in_hatch_build = False
+        packages_set = False
+
+        for line in lines:
+            # Detect hatch build section
+            if line.strip().startswith("[tool.hatch.build.targets.wheel]"):
+                in_hatch_build = True
+                result.append(line)
+                continue
+            elif line.strip().startswith("[") and in_hatch_build:
+                # End of hatch build section, add packages if not set
+                if not packages_set and correct_packages_path:
+                    packages_str = f'"{correct_packages_path}"'
+                    result.append(f"packages = [{packages_str}]")
+                in_hatch_build = False
+                result.append(line)
+            elif in_hatch_build:
+                # Modify packages path if found
+                if re.match(r"^\s*packages\s*=", line):
+                    packages_str = f'"{correct_packages_path}"'
+                    result.append(f"packages = [{packages_str}]")
+                    packages_set = True
+                    continue
+                # Keep other lines in hatch build section
+                result.append(line)
+            else:
+                result.append(line)
+
+        # Add packages if we're still in hatch build section and haven't set it
+        if in_hatch_build and not packages_set and correct_packages_path:
+            packages_str = f'"{correct_packages_path}"'
+            result.append(f"packages = [{packages_str}]")
+
+        # Ensure build-system section exists (required for hatchling)
+        # Check if build-system section exists in the result
+        has_build_system = any(line.strip().startswith("[build-system]") for line in result)
+        if not has_build_system:
+            # Insert build-system at the very beginning of the file
+            build_system_lines = [
+                "[build-system]",
+                'requires = ["hatchling"]',
+                'build-backend = "hatchling.build"',
+                "",
+            ]
+            result = build_system_lines + result
+
+        # Ensure hatch build section exists if packages path is needed
+        if not packages_set and correct_packages_path:
+            # Check if we need to add the section
+            if "[tool.hatch.build.targets.wheel]" not in content:
+                result.append("")
+                result.append("[tool.hatch.build.targets.wheel]")
+                packages_str = f'"{correct_packages_path}"'
+                result.append(f"packages = [{packages_str}]")
+
+        return "\n".join(result)
+
     def create_temp_pyproject(self) -> Path | None:
         """
         Create a temporary pyproject.toml for the subfolder build.
 
-        If a pyproject.toml exists in the subfolder, it will be used instead of creating
-        a new one. Otherwise, creates a pyproject.toml in the project root based on the
-        parent pyproject.toml with the appropriate package name and version.
+        If a pyproject.toml exists in the subfolder, it will be used (copied to project root
+        with adjusted package paths and ensuring [build-system] uses hatchling). Otherwise,
+        creates a pyproject.toml in the project root based on the parent pyproject.toml with
+        the appropriate package name and version.
+
+        The [build-system] section is always set to use hatchling, even if the parent or
+        subfolder pyproject.toml uses a different build backend (e.g., setuptools).
 
         Returns:
             Path to the pyproject.toml file (either from subfolder or created temporary),
@@ -149,8 +235,13 @@ class SubfolderBuildConfig:
                 shutil.copy2(original_pyproject, backup_path)
                 self.original_pyproject_backup = backup_path
 
-            # Copy subfolder pyproject.toml to project root
-            shutil.copy2(subfolder_pyproject, original_pyproject)
+            # Read and adjust the subfolder pyproject.toml
+            subfolder_content = subfolder_pyproject.read_text(encoding="utf-8")
+            # Adjust packages path to be relative to project root
+            adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
+
+            # Write adjusted content to project root
+            original_pyproject.write_text(adjusted_content, encoding="utf-8")
             self.temp_pyproject = original_pyproject
 
             # Handle README file
@@ -259,6 +350,7 @@ class SubfolderBuildConfig:
         skip_uv_dynamic = False
         in_hatch_build = False
         packages_set = False
+        build_system_set = False
 
         # Get package structure
         packages_path, package_dirs = self._get_package_structure()
@@ -266,6 +358,19 @@ class SubfolderBuildConfig:
             package_dirs = []
 
         for _i, line in enumerate(lines):
+            # Skip build-system section - we'll add our own for subfolder builds
+            if line.strip().startswith("[build-system]"):
+                build_system_set = True
+                continue  # Skip the [build-system] line
+            elif build_system_set and line.strip().startswith("["):
+                # End of build-system section
+                build_system_set = False
+                result.append(line)
+                continue
+            elif build_system_set:
+                # Skip build-system content - we'll add our own
+                continue
+
             # Skip hatch versioning and uv-dynamic-versioning sections
             if line.strip().startswith("[tool.hatch.version]"):
                 skip_hatch_version = True
@@ -361,6 +466,19 @@ class SubfolderBuildConfig:
             packages_str = ", ".join(f'"{p}"' for p in package_dirs)
             result.append(f"packages = [{packages_str}]")
 
+        # Ensure build-system section exists (required for hatchling)
+        # Check if build-system section exists in the result
+        has_build_system = any(line.strip().startswith("[build-system]") for line in result)
+        if not has_build_system:
+            # Insert build-system at the very beginning of the file
+            build_system_lines = [
+                "[build-system]",
+                'requires = ["hatchling"]',
+                'build-backend = "hatchling.build"',
+                "",
+            ]
+            result = build_system_lines + result
+
         # Ensure packages is always set for subfolder builds
         if not packages_set and package_dirs:
             # Add the section if it doesn't exist

python_package_folder/utils.py

@@ -63,7 +63,8 @@ def find_source_directory(project_root: Path, current_dir: Path | None = None) -
     project_root = project_root.resolve()
 
     # Check if current directory is a subdirectory with Python files
-    if current_dir.is_relative_to(project_root) or current_dir == project_root:
+    # Prioritize current directory if it's within the project and has Python files
+    if current_dir.is_relative_to(project_root) and current_dir != project_root:
         python_files = list(current_dir.glob("*.py"))
         if python_files:
             # Current directory has Python files, use it as source
@@ -74,10 +75,11 @@ def find_source_directory(project_root: Path, current_dir: Path | None = None) -
     if src_dir.exists() and src_dir.is_dir():
         return src_dir
 
-    # Check if project_root itself has Python files
-    python_files = list(project_root.glob("*.py"))
-    if python_files:
-        return project_root
+    # Only check project_root if current_dir is the project_root
+    if current_dir == project_root:
+        python_files = list(project_root.glob("*.py"))
+        if python_files:
+            return project_root
 
     return None
 

{python_package_folder-1.2.0.dist-info → python_package_folder-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 1.2.0
+Version: 1.2.1
 Summary: Python package to automatically package and build a folder, fetching all relevant dependencies.
 Project-URL: Repository, https://github.com/alelom/python-package-folder
 Author-email: Alessio Lombardi <work@alelom.com>
@@ -247,6 +247,7 @@ python-package-folder --project-root /path/to/project --src-dir /path/to/src --b
    - If found, copies the subfolder README to project root (backing up the original parent README)
    - If not found, creates a minimal README with just the folder name
 5. **Configuration Creation**: Creates temporary `pyproject.toml` with:
+   - `[build-system]` section using hatchling (replaces any existing build-system configuration)
    - Subfolder-specific package name (derived or custom)
    - Specified version
    - Correct package path for hatchling
@@ -278,8 +279,9 @@ The tool automatically:
 - Uses the current directory as the source directory if it contains Python files
 - Falls back to `project_root/src` if the current directory isn't suitable
 - **For subfolder builds**: Handles `pyproject.toml` configuration:
-  - **If `pyproject.toml` exists in subfolder**: Uses that file (copies it to project root temporarily)
+  - **If `pyproject.toml` exists in subfolder**: Uses that file (copies it to project root temporarily, adjusting package paths and ensuring `[build-system]` uses hatchling)
   - **If no `pyproject.toml` in subfolder**: Creates a temporary `pyproject.toml` with:
+    - `[build-system]` section using hatchling (always uses hatchling, even if parent uses setuptools)
     - Package name derived from the subfolder name (e.g., `empty_drawing_detection` → `empty-drawing-detection`)
     - Version from `--version` argument (defaults to `0.0.0` with a warning if not provided)
     - Proper package path configuration for hatchling
@@ -811,11 +813,11 @@ config.restore()
 ```
 
 **Methods:**
-- `create_temp_pyproject() -> Path`: Use subfolder's `pyproject.toml` if it exists, otherwise create temporary `pyproject.toml` with subfolder-specific configuration
+- `create_temp_pyproject() -> Path`: Use subfolder's `pyproject.toml` if it exists (adjusting package paths and ensuring `[build-system]` uses hatchling), otherwise create temporary `pyproject.toml` with subfolder-specific configuration including `[build-system]` section using hatchling
 - `restore() -> None`: Restore original `pyproject.toml` and clean up temporary files
 
 **Note**: This class automatically:
-- **pyproject.toml handling**: If a `pyproject.toml` exists in the subfolder, it will be used (copied to project root temporarily). Otherwise, creates a temporary one from the parent configuration.
+- **pyproject.toml handling**: If a `pyproject.toml` exists in the subfolder, it will be used (copied to project root temporarily with adjusted package paths). Otherwise, creates a temporary one from the parent configuration. In both cases, the `[build-system]` section is always set to use hatchling, replacing any existing build-system configuration.
 - **README handling**: If a README exists in the subfolder, it will be used instead of the parent README. If no README exists in the subfolder, a minimal README with just the folder name will be created. The original parent README is backed up and restored after the build completes.
 - **Package initialization**: Creates `__init__.py` files if needed to make subfolders valid Python packages.
 

{python_package_folder-1.2.0.dist-info → python_package_folder-1.2.1.dist-info}/RECORD

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