python-package-folder 8.2.0__tar.gz → 8.4.0__tar.gz

{python_package_folder-8.2.0 → python_package_folder-8.4.0}/PKG-INFO

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

{python_package_folder-8.2.0 → python_package_folder-8.4.0}/pyproject.toml

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

{python_package_folder-8.2.0 → python_package_folder-8.4.0}/src/python_package_folder/analyzer.py

@@ -396,7 +396,9 @@ class ImportAnalyzer:
         Check if a module is a third-party package.
 
         Uses importlib to find the module and checks if its location
-        is in site-packages or dist-packages.
+        is in site-packages or dist-packages. Also tries to import the module
+        to check if it's available, which helps catch cases where packages
+        are installed but metadata lookup fails.
 
         Args:
             module_name: Name of the module to check
@@ -405,12 +407,69 @@ class ImportAnalyzer:
             True if the module is a third-party package, False otherwise
         """
         root_module = module_name.split(".")[0]
+
+        # Skip if already known as stdlib
+        stdlib_modules = self.get_stdlib_modules()
+        if root_module in stdlib_modules:
+            return False
+
         try:
             spec = importlib.util.find_spec(root_module)
             if spec and spec.origin:
                 origin_path = Path(spec.origin)
-                # Check if it's in site-packages
-                return "site-packages" in str(origin_path) or "dist-packages" in str(origin_path)
-        except (ImportError, ValueError, AttributeError):
-            pass
+                origin_str = str(origin_path)
+
+                # Check if it's in site-packages or dist-packages
+                if "site-packages" in origin_str or "dist-packages" in origin_str:
+                    return True
+
+                # Check if it's outside the standard library directory
+                # Standard library is typically in the Python installation directory
+                # and not in site-packages
+                stdlib_paths = [
+                    "lib/python",
+                    "Lib\\python",  # Windows
+                    "lib64/python",
+                    "Lib64\\python",  # Windows
+                ]
+                is_stdlib_path = any(stdlib_path in origin_str for stdlib_path in stdlib_paths)
+                if not is_stdlib_path and "site-packages" not in origin_str:
+                    # If it's not in stdlib paths and not in site-packages,
+                    # and it's not in the project directory, it might be third-party
+                    # Check if it's outside the project directory
+                    try:
+                        origin_path.resolve().relative_to(self.project_root.resolve())
+                        # It's in the project, so it's not third-party
+                        return False
+                    except ValueError:
+                        # It's outside the project, might be third-party
+                        # Try to import it to verify
+                        try:
+                            __import__(root_module)
+                            # If import succeeds and it's outside project, likely third-party
+                            return True
+                        except ImportError:
+                            pass
+
+        except (ImportError, ValueError, AttributeError, Exception):
+            # If importlib fails, try direct import as fallback
+            try:
+                imported_module = __import__(root_module)
+                # Check if the module's __file__ points to site-packages
+                if hasattr(imported_module, "__file__") and imported_module.__file__:
+                    module_file = str(imported_module.__file__)
+                    if "site-packages" in module_file or "dist-packages" in module_file:
+                        return True
+                    # Check if it's outside the project
+                    try:
+                        Path(imported_module.__file__).resolve().relative_to(
+                            self.project_root.resolve()
+                        )
+                        return False  # It's in the project
+                    except ValueError:
+                        # It's outside the project, likely third-party
+                        return True
+            except ImportError:
+                pass
+
         return False

{python_package_folder-8.2.0 → python_package_folder-8.4.0}/src/python_package_folder/manager.py

@@ -605,6 +605,51 @@ class BuildManager:
         Returns:
             List of unique third-party package names (e.g., ["pypdf", "requests", "pymupdf"])
         """
+        # Common third-party packages that are often misclassified as ambiguous
+        COMMON_THIRD_PARTY_PACKAGES = {
+            "torch",
+            "torchvision",
+            "numpy",
+            "pandas",
+            "matplotlib",
+            "scipy",
+            "sklearn",
+            "tensorflow",
+            "keras",
+            "pillow",
+            "PIL",
+            "cv2",
+            "opencv",
+            "requests",
+            "flask",
+            "django",
+            "pytest",
+            "pydantic",
+            "fastapi",
+            "sqlalchemy",
+            "pymongo",
+            "redis",
+            "celery",
+            "boto3",
+            "azure",
+            "google",
+            "openai",
+            "langchain",
+            "fiftyone",
+            "pycocotools",
+            "albumentations",
+            "loguru",
+            "tqdm",
+            "rich",
+            "pypdf",
+            "pymupdf",
+            "networkx",
+            "openpyxl",
+            "nltk",
+            "spacy",
+            "textdistance",
+            "IPython",
+        }
         third_party_packages: set[str] = set()
         # Cache package name lookups to avoid repeated expensive searches
         package_name_cache: dict[str, str | None] = {}
@@ -648,23 +693,34 @@ class BuildManager:
                         # Fallback to using the import name
                         third_party_packages.add(root_module)
                 # If it's ambiguous or unresolved, and not stdlib/local/external,
-                # only add as dependency if we can verify it's actually an installed package
+                # check if it's a common third-party package or can be verified
                 elif imp.classification == "ambiguous" or imp.classification is None:
                     # Check if it's not a local or external module
                     if not imp.resolved_path:
-                        # Try to verify it's actually an installed package before adding
-                        # Check cache first
-                        if root_module not in package_name_cache:
-                            package_name_cache[root_module] = self._get_package_name_from_import(
-                                imp.module_name
-                            )
-                        actual_package = package_name_cache[root_module]
-                        # Only add if we can verify it's an actual installed package
-                        # Don't add ambiguous imports that we can't verify
-                        if actual_package:
-                            third_party_packages.add(actual_package)
-                        # If we can't verify it's a package, don't add it
-                        # (it's likely a local file that wasn't resolved properly)
+                        # Check if it's a common third-party package
+                        if root_module in COMMON_THIRD_PARTY_PACKAGES:
+                            # Try to get package name, or use module name as fallback
+                            if root_module not in package_name_cache:
+                                package_name_cache[root_module] = self._get_package_name_from_import(
+                                    imp.module_name
+                                )
+                            actual_package = package_name_cache[root_module]
+                            if actual_package:
+                                third_party_packages.add(actual_package)
+                            else:
+                                # Fallback: use module name (common packages like torch, numpy)
+                                third_party_packages.add(root_module)
+                        else:
+                            # For other ambiguous imports, only add if verified
+                            if root_module not in package_name_cache:
+                                package_name_cache[root_module] = self._get_package_name_from_import(
+                                    imp.module_name
+                                )
+                            actual_package = package_name_cache[root_module]
+                            if actual_package:
+                                third_party_packages.add(actual_package)
+                            # If we can't verify it's a package, don't add it
+                            # (it's likely a local file that wasn't resolved properly)
 
         if total_files > 50:
             print()  # New line after progress indicator
@@ -765,6 +821,44 @@ class BuildManager:
                     file=sys.stderr,
                 )
 
+    def _calculate_relative_import_depth(
+        self, file_path: Path, module_path: Path, src_dir: Path
+    ) -> str:
+        """
+        Calculate the relative import prefix (., .., ...) based on directory depth.
+
+        Args:
+            file_path: Path to the file containing the import
+            module_path: Path to the imported module (file or directory)
+            src_dir: Source directory (package root)
+
+        Returns:
+            String with appropriate number of dots (e.g., ".", "..", "...")
+        """
+        try:
+            # Get relative paths from src_dir
+            file_rel = file_path.parent.relative_to(src_dir)
+            module_rel = module_path.parent.relative_to(src_dir)
+
+            # Calculate depth difference
+            # If paths are ".", depth is 0
+            file_depth = len(file_rel.parts) if file_rel.parts != (".",) else 0
+            module_depth = len(module_rel.parts) if module_rel.parts != (".",) else 0
+
+            depth_diff = file_depth - module_depth
+
+            if depth_diff == 0:
+                return "."  # Same level
+            elif depth_diff > 0:
+                # File is deeper than module, need to go up
+                return "." * (depth_diff + 1)  # Go up depth_diff levels
+            else:
+                # Module is deeper than file, use single dot
+                return "."
+        except ValueError:
+            # If paths are not relative to src_dir, fall back to single dot
+            return "."
+
     def _convert_imports_to_relative(
         self, python_files: list[Path], external_deps: list[ExternalDependency]
     ) -> None:
@@ -777,6 +871,9 @@ class BuildManager:
         1. Imports of copied dependencies (e.g., `from _shared.image_utils` -> `from ._shared.image_utils`)
         2. Imports of local files within the subfolder (e.g., `from detect_empty_drawings_utils` -> `from .detect_empty_drawings_utils`)
 
+        Only imports classified as "external" or "local" are converted. Imports classified
+        as "ambiguous", "third_party", or "stdlib" are left unchanged.
+
         Args:
             python_files: List of Python files in the source directory
             external_deps: List of external dependencies that were copied
@@ -784,6 +881,9 @@ class BuildManager:
         import ast
         import re
 
+        # Create analyzer for classifying imports
+        analyzer = ImportAnalyzer(self.project_root)
+
         # Build a set of import names that were copied
         copied_import_names: set[str] = set()
         for dep in external_deps:
@@ -838,8 +938,39 @@ class BuildManager:
                         if node.module is None:
                             continue
 
-                        # Check if this import matches a copied dependency or a local file
+                        # Extract root module (first part before the first dot)
                         root_module = node.module.split(".")[0]
+
+                        # Classify the root module first to check if it's third-party/ambiguous/stdlib
+                        # If root is third-party/ambiguous/stdlib, skip ALL its submodules
+                        root_import_info = ImportInfo(
+                            module_name=root_module,
+                            import_type="from",
+                            line_number=node.lineno,
+                            file_path=file_path,
+                        )
+                        analyzer.classify_import(root_import_info, self.src_dir)
+
+                        # If root is third-party/ambiguous/stdlib, skip ALL submodules
+                        if root_import_info.classification in ("third_party", "ambiguous", "stdlib"):
+                            continue
+
+                        # Now classify the full import to determine if it should be converted
+                        import_info = ImportInfo(
+                            module_name=node.module,
+                            import_type="from",
+                            line_number=node.lineno,
+                            file_path=file_path,
+                        )
+                        analyzer.classify_import(import_info, self.src_dir)
+
+                        # Only convert imports classified as "external" or "local"
+                        # Skip ambiguous, third_party, and stdlib imports
+                        if import_info.classification not in ("external", "local"):
+                            continue
+
+                        # Check if this import matches a copied dependency or a local file
+                        # (additional safety check, but classification takes precedence)
                         is_copied_dependency = (
                             root_module in copied_import_names or node.module in copied_import_names
                         )
@@ -859,11 +990,36 @@ class BuildManager:
                         if original_line.strip().startswith("from ."):
                             continue
 
+                        # Find the target path for the imported module
+                        module_target_path = None
+                        for dep in external_deps:
+                            if dep.import_name == node.module or node.module.startswith(dep.import_name + "."):
+                                module_target_path = dep.target_path
+                                break
+
+                        # If not found in external deps, check if it's a local file
+                        if module_target_path is None:
+                            # Try to find it as a local file
+                            module_parts = node.module.split(".")
+                            potential_path = self.src_dir / "/".join(module_parts)
+                            if (potential_path / "__init__.py").exists():
+                                module_target_path = potential_path / "__init__.py"
+                            elif potential_path.with_suffix(".py").exists():
+                                module_target_path = potential_path.with_suffix(".py")
+                            else:
+                                # Fallback: assume same level
+                                module_target_path = file_path.parent
+
+                        # Calculate the correct relative import depth
+                        dots = self._calculate_relative_import_depth(
+                            file_path, module_target_path, self.src_dir
+                        )
+
                         # Convert absolute import to relative import
-                        # from _shared.image_utils import ... -> from ._shared.image_utils import ...
+                        # from _shared.image_utils import ... -> from .._shared.image_utils import ...
                         new_line = re.sub(
                             rf"^(\s*)from\s+{re.escape(node.module)}\s+import",
-                            rf"\1from .{node.module} import",
+                            rf"\1from {dots}{node.module} import",
                             original_line,
                         )
 
@@ -874,7 +1030,39 @@ class BuildManager:
                     elif isinstance(node, ast.Import):
                         # Handle "import X" statements
                         for alias in node.names:
+                            # Extract root module (first part before the first dot)
                             root_module = alias.name.split(".")[0]
+
+                            # Classify the root module first to check if it's third-party/ambiguous/stdlib
+                            # If root is third-party/ambiguous/stdlib, skip ALL its submodules
+                            root_import_info = ImportInfo(
+                                module_name=root_module,
+                                import_type="import",
+                                line_number=node.lineno,
+                                file_path=file_path,
+                            )
+                            analyzer.classify_import(root_import_info, self.src_dir)
+
+                            # If root is third-party/ambiguous/stdlib, skip ALL submodules
+                            if root_import_info.classification in ("third_party", "ambiguous", "stdlib"):
+                                continue
+
+                            # Now classify the full import to determine if it should be converted
+                            import_info = ImportInfo(
+                                module_name=alias.name,
+                                import_type="import",
+                                line_number=node.lineno,
+                                file_path=file_path,
+                            )
+                            analyzer.classify_import(import_info, self.src_dir)
+
+                            # Only convert imports classified as "external" or "local"
+                            # Skip ambiguous, third_party, and stdlib imports
+                            if import_info.classification not in ("external", "local"):
+                                continue
+
+                            # Check if this import matches a copied dependency or a local file
+                            # (additional safety check, but classification takes precedence)
                             is_copied_dependency = root_module in copied_import_names
                             is_local_file = root_module in local_file_names
 
@@ -891,11 +1079,36 @@ class BuildManager:
                             if original_line.strip().startswith("import ."):
                                 continue
 
-                            # Convert "import _shared" to "from . import _shared"
+                            # Find the target path for the imported module
+                            module_target_path = None
+                            for dep in external_deps:
+                                if dep.import_name == alias.name or alias.name.startswith(dep.import_name + "."):
+                                    module_target_path = dep.target_path
+                                    break
+
+                            # If not found in external deps, check if it's a local file
+                            if module_target_path is None:
+                                # Try to find it as a local file
+                                module_parts = alias.name.split(".")
+                                potential_path = self.src_dir / "/".join(module_parts)
+                                if (potential_path / "__init__.py").exists():
+                                    module_target_path = potential_path / "__init__.py"
+                                elif potential_path.with_suffix(".py").exists():
+                                    module_target_path = potential_path.with_suffix(".py")
+                                else:
+                                    # Fallback: assume same level
+                                    module_target_path = file_path.parent
+
+                            # Calculate the correct relative import depth
+                            dots = self._calculate_relative_import_depth(
+                                file_path, module_target_path, self.src_dir
+                            )
+
+                            # Convert "import _shared" to "from .. import _shared" (with correct depth)
                             # This is more complex, so we'll use a regex replacement
                             new_line = re.sub(
                                 rf"^(\s*)import\s+{re.escape(alias.name)}\b",
-                                rf"\1from . import {alias.name}",
+                                rf"\1from {dots} import {alias.name}",
                                 original_line,
                             )