python-package-folder 5.4.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

python_package_folder/analyzer.py

@@ -227,9 +227,22 @@ class ImportAnalyzer:
             import_info.classification = "stdlib"
             return
 
+        # Check if it's a third-party package (in site-packages) FIRST
+        # This must be checked before resolve_local_import to avoid incorrectly
+        # classifying site-packages modules as "external" when they're found
+        # by the recursive search
+        if self.is_third_party(module_name):
+            import_info.classification = "third_party"
+            return
+
         # Try to resolve as a local import
         resolved = self.resolve_local_import(import_info, src_dir)
         if resolved is not None:
+            # Double-check: if resolved path is in site-packages, it's actually third-party
+            # (this can happen if the recursive search finds it before importlib does)
+            if "site-packages" in str(resolved) or "dist-packages" in str(resolved):
+                import_info.classification = "third_party"
+                return
             if resolved.is_relative_to(src_dir):
                 import_info.classification = "local"
             else:
@@ -237,11 +250,6 @@ class ImportAnalyzer:
             import_info.resolved_path = resolved
             return
 
-        # Check if it's a third-party package (in site-packages)
-        if self.is_third_party(module_name):
-            import_info.classification = "third_party"
-            return
-
         # Mark as ambiguous if we can't determine
         import_info.classification = "ambiguous"
 
@@ -330,56 +338,36 @@ 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"):
+                        # Skip site-packages and dist-packages (these are third-party, not external)
+                        if "site-packages" in str(potential_file) or "dist-packages" in str(potential_file):
                             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/manager.py

@@ -268,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

python_package_folder/subfolder_build.py

@@ -78,6 +78,7 @@ 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:
         """
@@ -121,6 +122,70 @@ class SubfolderBuildConfig:
             # 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 with the import name directly.
+        This way, hatchling will install it with the correct name without needing force-include.
+        """
+        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 with the import name directly
+        # This way, hatchling will install it with the correct name
+        import_name_dir = self.project_root / import_name
+        
+        # Check if the directory already exists and is the correct one
+        if import_name_dir.exists() and import_name_dir == self._temp_package_dir:
+            # Directory already exists and is the correct one, no need to recreate
+            return
+        
+        # Remove if it already exists (from a previous build)
+        if import_name_dir.exists():
+            shutil.rmtree(import_name_dir)
+        
+        # Copy the entire source directory contents directly to the import name directory
+        # Check if src_dir exists and is a directory before copying
+        if not self.src_dir.exists():
+            print(
+                f"Warning: Source directory does not exist: {self.src_dir}",
+                file=sys.stderr,
+            )
+            self._temp_package_dir = None
+            return
+        
+        if not self.src_dir.is_dir():
+            print(
+                f"Warning: Source path is not a directory: {self.src_dir}",
+                file=sys.stderr,
+            )
+            self._temp_package_dir = None
+            return
+        
+        try:
+            shutil.copytree(self.src_dir, import_name_dir)
+            self._temp_package_dir = import_name_dir
+            print(
+                f"Created temporary package directory: {import_name_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]]:
         """
         Determine the package structure for hatchling.
@@ -130,21 +195,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
@@ -298,80 +366,133 @@ 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
-        init_file = self.src_dir / "__init__.py"
-        if not init_file.exists():
-            # Create a temporary __init__.py to make it a package
-            init_file.write_text("# Temporary __init__.py for build\n", encoding="utf-8")
-            self._temp_init_created = True
-        else:
-            self._temp_init_created = False
-
-        # Check if pyproject.toml exists in subfolder
-        subfolder_pyproject = self.src_dir / "pyproject.toml"
-        if subfolder_pyproject.exists():
-            # Use the subfolder's pyproject.toml
-            print(f"Using existing pyproject.toml from subfolder: {subfolder_pyproject}")
-            self._used_subfolder_pyproject = True
-
-            # Store reference to original project root pyproject.toml
-            original_pyproject = self.project_root / "pyproject.toml"
-            self.original_pyproject_path = original_pyproject
-
-            # Create temporary pyproject.toml file
-            temp_pyproject_path = self.project_root / "pyproject.toml.temp"
-
-            # 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)
-            
-            # Read exclude patterns from root pyproject.toml and inject them
-            exclude_patterns = read_exclude_patterns(original_pyproject)
+        # Check if pyproject.toml exists in subfolder FIRST
+        # This allows us to handle subfolder pyproject.toml even when parent doesn't exist
+        # But first ensure src_dir exists
+        if not self.src_dir.exists() or not self.src_dir.is_dir():
+            # If src_dir doesn't exist, we can't proceed
             print(
-                f"INFO: Read exclude patterns from {original_pyproject}: {exclude_patterns}",
+                f"Warning: Source directory does not exist or is not a directory: {self.src_dir}",
                 file=sys.stderr,
             )
-            if exclude_patterns:
-                adjusted_content = self._inject_exclude_patterns(adjusted_content, exclude_patterns)
-
-            # Write adjusted content to temporary file
-            temp_pyproject_path.write_text(adjusted_content, encoding="utf-8")
-            self.temp_pyproject = temp_pyproject_path
+            return None
+        
+        subfolder_pyproject = self.src_dir / "pyproject.toml"
+        if subfolder_pyproject.exists() and subfolder_pyproject.is_file():
+            # Read the subfolder pyproject.toml content IMMEDIATELY after checking it exists
+            # This prevents any issues if the file is affected by subsequent operations
+            try:
+                subfolder_content = subfolder_pyproject.read_text(encoding="utf-8")
+            except (FileNotFoundError, OSError) as e:
+                # File was deleted or inaccessible between check and read
+                print(
+                    f"Warning: Could not read subfolder pyproject.toml at {subfolder_pyproject}: {e}. "
+                    "Falling back to creating from parent.",
+                    file=sys.stderr,
+                )
+                subfolder_content = None
+            
+            if subfolder_content is not None:
+                # 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
+                    init_file.write_text("# Temporary __init__.py for build\n", encoding="utf-8")
+                    self._temp_init_created = True
+                else:
+                    self._temp_init_created = False
 
-            # Print the temporary pyproject.toml content for debugging
-            print("\n" + "=" * 80)
-            print("Temporary pyproject.toml content (from subfolder pyproject.toml):")
-            print("=" * 80)
-            print(adjusted_content)
-            print("=" * 80 + "\n")
+                # 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
+                # Use the subfolder's pyproject.toml
+                print(f"Using existing pyproject.toml from subfolder: {subfolder_pyproject}")
+                self._used_subfolder_pyproject = True
 
-            # If original pyproject.toml exists, temporarily move it
-            if original_pyproject.exists():
-                backup_path = self.project_root / "pyproject.toml.original"
-                # Remove backup if it already exists (from previous failed test or run)
-                if backup_path.exists():
-                    backup_path.unlink()
-                original_pyproject.rename(backup_path)
-                self.original_pyproject_backup = backup_path
-
-            # Move temp file to pyproject.toml for the build
-            temp_pyproject_path.rename(original_pyproject)
-            self.temp_pyproject = original_pyproject
-
-            # Handle README file
-            self._handle_readme()
+                # Store reference to original project root pyproject.toml
+                original_pyproject = self.project_root / "pyproject.toml"
+                self.original_pyproject_path = original_pyproject
 
-            # Exclude files matching exclude patterns
-            if exclude_patterns:
-                self._exclude_files_by_patterns(exclude_patterns)
+                # Create temporary pyproject.toml file
+                temp_pyproject_path = self.project_root / "pyproject.toml.temp"
 
-            return original_pyproject
+                # Adjust packages path to be relative to project root
+                adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
+                
+                # Read exclude patterns from root pyproject.toml and inject them (if it exists)
+                exclude_patterns = []
+                if original_pyproject.exists():
+                    exclude_patterns = read_exclude_patterns(original_pyproject)
+                    print(
+                        f"INFO: Read exclude patterns from {original_pyproject}: {exclude_patterns}",
+                        file=sys.stderr,
+                    )
+                else:
+                    print(
+                        f"INFO: No parent pyproject.toml found at {original_pyproject}, skipping exclude patterns",
+                        file=sys.stderr,
+                    )
+                if exclude_patterns:
+                    adjusted_content = self._inject_exclude_patterns(adjusted_content, exclude_patterns)
+
+                # Write adjusted content to temporary file
+                temp_pyproject_path.write_text(adjusted_content, encoding="utf-8")
+                self.temp_pyproject = temp_pyproject_path
+
+                # Print the temporary pyproject.toml content for debugging
+                print("\n" + "=" * 80)
+                print("Temporary pyproject.toml content (from subfolder pyproject.toml):")
+                print("=" * 80)
+                print(adjusted_content)
+                print("=" * 80 + "\n")
+
+                # If original pyproject.toml exists, temporarily move it
+                if original_pyproject.exists():
+                    backup_path = self.project_root / "pyproject.toml.original"
+                    # Remove backup if it already exists (from previous failed test or run)
+                    if backup_path.exists():
+                        backup_path.unlink()
+                    original_pyproject.rename(backup_path)
+                    self.original_pyproject_backup = backup_path
+
+                # Move temp file to pyproject.toml for the build
+                temp_pyproject_path.rename(original_pyproject)
+                self.temp_pyproject = original_pyproject
+
+                # Handle README file
+                self._handle_readme()
+
+                # Exclude files matching exclude patterns
+                if exclude_patterns:
+                    self._exclude_files_by_patterns(exclude_patterns)
+
+                return original_pyproject
 
         # No pyproject.toml in subfolder, create one from parent
         self._used_subfolder_pyproject = False
         print("No pyproject.toml found in subfolder, creating temporary one from parent")
 
+        # 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
+            init_file.write_text("# Temporary __init__.py for build\n", encoding="utf-8")
+            self._temp_init_created = True
+        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
+
         # Read the original pyproject.toml
         original_pyproject = self.project_root / "pyproject.toml"
         if not original_pyproject.exists():
@@ -1206,6 +1327,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.4.0.dist-info → python_package_folder-7.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 5.4.0
+Version: 7.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.4.0.dist-info → python_package_folder-7.0.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 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=cmTNUDCWBIh3XZ_mShlQVG1P9NN_oe3FUBTirVtYfTQ,16709
+python_package_folder/analyzer.py,sha256=8DCc5AaVpYF9qh8NbMJ5igeW5AVYnQqy_XqRtl16ZLc,15981
 python_package_folder/finder.py,sha256=RPidZ7LKCFuQ_KgCFIZdHWPXsZIDor3M4C0hKeYW7EI,11799
-python_package_folder/manager.py,sha256=SFHpQMhrn_kgJFcPIUcAF_hrCTQPussQZNxqcoXEEQs,58280
+python_package_folder/manager.py,sha256=erX8uPu3KA593wsSH9o15O8MNc6mwIZgGGqUJf7Z5i0,59423
 python_package_folder/publisher.py,sha256=fmf3l0zMY9CD49gurxlXyvm9mOP0FzDjmiSt0yDqt1M,18813
 python_package_folder/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 python_package_folder/python_package_folder.py,sha256=QZ-vdOZ40wF-eGbp39JotDhMwIhhT3Z_sC5obQj3i4s,17024
-python_package_folder/subfolder_build.py,sha256=6ht9vURMHm99AbM99NCBOKHrVeAOwzaVzhf_sG_zK4A,52764
+python_package_folder/subfolder_build.py,sha256=tkZuaKFNgSTptOVu6v2sjxPfgShUmpMkapZSSyZ4UTk,59465
 python_package_folder/types.py,sha256=3yeSRR5p_3PDKEAaehW_RJ7NwJHexOIeA08bGaT1iSY,2368
 python_package_folder/utils.py,sha256=b6Ukcc0fctXdxS5zhGLS86kqn0vz1yOEK7XjCY9fjfY,5621
 python_package_folder/version.py,sha256=kIDP6S9trEfs9gj7lBYGxrWm4RPssRla24UtlO9Jkh4,9111
 python_package_folder/version_calculator.py,sha256=_gcc8IbMjt27UxePcc7RZlFTMCG3AGnRI_-Mp_4qRG0,39568
-python_package_folder-5.4.0.dist-info/METADATA,sha256=iLkfFZoVJF3IVE-gR6LOmHfb95JpkMNe7bkShze-k20,7838
-python_package_folder-5.4.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_package_folder-5.4.0.dist-info/entry_points.txt,sha256=ttu4wAhoYSHGhWQNercLz9IVTTpXxhVlRA9vSTvaLe0,91
-python_package_folder-5.4.0.dist-info/licenses/LICENSE,sha256=vNgRJh8YiecqZoZld7TtwPI5I72HIymKD9g32fiJjCE,1073
-python_package_folder-5.4.0.dist-info/RECORD,,
+python_package_folder-7.0.0.dist-info/METADATA,sha256=mGdHt_HrzSDGj-tBuvwG2axyjGUxoAIZhTLrgPCBPZQ,7838
+python_package_folder-7.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_package_folder-7.0.0.dist-info/entry_points.txt,sha256=ttu4wAhoYSHGhWQNercLz9IVTTpXxhVlRA9vSTvaLe0,91
+python_package_folder-7.0.0.dist-info/licenses/LICENSE,sha256=vNgRJh8YiecqZoZld7TtwPI5I72HIymKD9g32fiJjCE,1073
+python_package_folder-7.0.0.dist-info/RECORD,,