pysfi 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

sfi/pyprojectparse/pyprojectparse.py

@@ -16,13 +16,15 @@ import argparse
 import datetime
 import json
 import logging
+import platform
 import re
 import sys
 import time
 from dataclasses import dataclass, field
 from functools import cached_property
 from pathlib import Path
-from typing import Any
+from re import Pattern
+from typing import Any, Final
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -35,12 +37,15 @@ __all__ = ["Project", "Solution"]
 logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
 logger = logging.getLogger(__name__)
 cwd = Path.cwd()
+is_windows = platform.system() == "Windows"
 
 # Precompiled regex for dependency name extraction (optimization)
-_DEP_NAME_PATTERN = re.compile(r"^([a-zA-Z0-9._-]+)")
+_DEP_NAME_PATTERN: Final[Pattern[str]] = re.compile(r"^([a-zA-Z0-9._-]+)")
+_EXTRA_PATTERN: Final[Pattern[str]] = re.compile(r"\[([^\]]+)\]")
+_VERSION_PATTERN: Final[Pattern[str]] = re.compile(r"[<>=!~].*$")
 
 # Qt-related keywords and dependencies for faster detection
-_QT_DEPENDENCIES: frozenset[str] = frozenset((
+_QT_DEPENDENCIES: Final[frozenset[str]] = frozenset((
     "Qt",
     "PySide",
     "PyQt",
@@ -53,10 +58,77 @@ _QT_DEPENDENCIES: frozenset[str] = frozenset((
 ))
 
 # GUI-related keywords for faster detection
-_GUI_KEYWORDS: frozenset[str] = frozenset(("gui", "desktop"))
+_GUI_KEYWORDS: Final[frozenset[str]] = frozenset(("gui", "desktop"))
 
 # Required attributes for project validation (module-level constant for performance)
-_REQUIRED_ATTRS: frozenset[str] = frozenset(("name", "version", "description"))
+_REQUIRED_ATTRS: Final[frozenset[str]] = frozenset(("name", "version", "description"))
+
+
+@dataclass(frozen=True)
+class Dependency:
+    """Represents a Python package dependency."""
+
+    name: str = ""
+    version: str | None = None
+    extras: set[str] = field(default_factory=set)
+    requires: set[str] = field(default_factory=set)
+
+    @staticmethod
+    def from_str(dep_str: str) -> Dependency:
+        """Create a Dependency instance from a dependency string.
+
+        Args:
+            dep_str (str): The dependency string in the format "name[extras]version".
+
+        Returns:
+            Dependency: The created Dependency instance.
+        """
+        # Parse the dependency string to extract name, extras, and version
+        name = ""
+        version = None  # Use None initially, will be set if version is found
+        extras = set()
+
+        # First, extract extras if present (text within square brackets)
+        extras_match = _EXTRA_PATTERN.search(dep_str)
+        if extras_match:
+            extras_str = extras_match.group(1)
+            extras = {extra.strip() for extra in extras_str.split(",")}
+            # Remove the extras part from the string for further processing
+            dep_str = dep_str[: extras_match.start()] + dep_str[extras_match.end() :]
+
+        # Extract version specifier (starts with comparison operators like >=, <=, ==, etc.)
+        version_match = _VERSION_PATTERN.search(dep_str)
+        if version_match:
+            version = version_match.group()
+            dep_str = dep_str[: version_match.start()].strip()
+
+        # Remaining part is the name
+        name = dep_str.strip()
+
+        return Dependency(name=name, version=version, extras=extras, requires=set())
+
+    def __post_init__(self):
+        # Normalize the name after initialization
+        # This ensures that names like "Requests-OAuthLib" become "requests_oauthlib"
+        object.__setattr__(self, "name", self.name.lower().replace("-", "_"))
+
+    @cached_property
+    def normalized_name(self) -> str:
+        """Return the normalized name of the dependency (same as name since it's already normalized)."""
+        return self.name
+
+    def __str__(self) -> str:
+        """String representation of dependency."""
+        # Pre-cache version to avoid repeated evaluation
+        version_str = self.version or ""
+        if self.extras:
+            # Pre-cache sorted extras to avoid repeated sorting
+            sorted_extras = ",".join(sorted(self.extras))
+            return f"{self.name}[{sorted_extras}]{version_str}"
+        return f"{self.name}{version_str}"
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.version, frozenset(self.extras)))
 
 
 @dataclass(frozen=True)
@@ -84,6 +156,8 @@ class Project:
         urls: Dictionary of project URLs (homepage, repository, etc.)
         build_backend: Build backend system used (e.g., "setuptools.build_meta")
         requires: List of build system requirements
+        toml_path: Path to the pyproject.toml file
+        solution_root_dir: Root directory of the solution (for multi-project setups)
     """
 
     name: str
@@ -102,11 +176,99 @@ class Project:
     urls: dict[str, str]
     build_backend: str
     requires: list[str]
+    toml_path: Path
+    solution_root_dir: Path | None = None
+
+    @cached_property
+    def min_python_version(self) -> str | None:
+        """Extract the minimum Python version from requires_python.
+
+        Parses the requires_python string to extract the minimum version requirement.
+        Supports formats like ">=3.8", ">3.7", "~=3.9", etc. Returns None if no
+        minimum version is specified or if the format is unrecognized.
+
+        Returns:
+            The minimum Python version as a string, or None if not found.
+        """
+        if not self.requires_python:
+            return None
+
+        # Pattern to match minimum Python version requirements
+        # Examples: >=3.8, >3.7, ~=3.9, ==3.8.*, etc.
+        patterns = [
+            r">=(\d+\.\d+(?:\.\d+)?)",  # >=3.8, >=3.8.1
+            r">(\d+\.\d+(?:\.\d+)?)",  # >3.7
+            r"~=?(\d+\.\d+(?:\.\d+)?)",  # ~=3.9, ~3.9
+            r"==?(\d+\.\d+(?:\.\d+)?)(?:\.\*)?",  # ==3.8, ==3.8.*, =3.8
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, self.requires_python)
+            if match:
+                return match.group(1)
+
+        return None
+
+    @cached_property
+    def root_dir(self) -> Path:
+        """Return the root directory of the project."""
+        if not self.toml_path.is_file():
+            # Return current directory if toml_path is not set or invalid
+            # This can happen when Project is created with default values
+            return Path()
+
+        return self.toml_path.parent
+
+    @cached_property
+    def dist_dir(self) -> Path:
+        """Return the distribution directory of the project.
+
+        In multi-project solutions, returns solution_root_dir/dist.
+        In single-project setups, returns project_root_dir/dist.
+        """
+        if self.solution_root_dir:
+            dist_dir = self.solution_root_dir / "dist"
+        else:
+            dist_dir = self.root_dir / "dist"
+        dist_dir.mkdir(parents=True, exist_ok=True)
+        return dist_dir
+
+    @cached_property
+    def extension(self) -> str:
+        return ".exe" if is_windows else ""
+
+    @cached_property
+    def exe_name(self) -> str:
+        """Return the executable name of the project."""
+        return f"{self.name}{self.extension}"
+
+    @cached_property
+    def exe_path(self) -> Path:
+        """Return the executable path of the project."""
+        return self.dist_dir / f"{self.name}{self.extension}"
+
+    @cached_property
+    def runtime_dir(self) -> Path:
+        """Return the runtime directory of the project."""
+        runtime_dir = self.dist_dir / "runtime"
+        runtime_dir.mkdir(parents=True, exist_ok=True)
+        return runtime_dir
+
+    @cached_property
+    def lib_dir(self) -> Path:
+        """Return the lib directory of the project."""
+        lib_dir = self.dist_dir / "site-packages"
+        lib_dir.mkdir(parents=True, exist_ok=True)
+        return lib_dir
 
     @cached_property
     def normalized_name(self) -> str:
         return self.name.replace("-", "_")
 
+    @cached_property
+    def converted_dependencies(self) -> set[Dependency]:
+        return {Dependency.from_str(dep) for dep in self.dependencies}
+
     @cached_property
     def dep_names(self) -> set[str]:
         """Extract normalized dependency names from the dependencies list.
@@ -118,7 +280,6 @@ class Project:
         Returns:
             Set of normalized dependency package names.
         """
-        # Use set comprehension directly to avoid intermediate list
         return {
             match.group(1)
             if (match := _DEP_NAME_PATTERN.match(main_part))
@@ -134,7 +295,10 @@ class Project:
         Returns:
             Set of Qt-related dependency names found in the project.
         """
-        return self.dep_names & _QT_DEPENDENCIES
+        # Pre-cache the sets to avoid attribute lookup overhead
+        dep_names_set = self.dep_names
+        qt_deps_set = _QT_DEPENDENCIES
+        return dep_names_set & qt_deps_set
 
     @cached_property
     def has_qt(self) -> bool:
@@ -147,7 +311,8 @@ class Project:
     @cached_property
     def is_gui(self) -> bool:
         # Use set intersection for O(1) lookup instead of O(n) with any()
-        return bool(set(self.keywords) & _GUI_KEYWORDS)
+        # Also consider projects with Qt dependencies as GUI applications
+        return bool(set(self.keywords) & _GUI_KEYWORDS) or self.has_qt
 
     @cached_property
     def loader_type(self) -> str:
@@ -169,24 +334,46 @@ class Project:
         """
         if not toml_file.is_file():
             logger.error(f"{toml_file} does not exist")
-            return Project.from_dict({})
+            return Project._from_empty_dict()
 
         try:
             with open(toml_file, "rb") as f:
                 data = tomllib.load(f)
         except Exception as e:
             logger.error(f"Error parsing {toml_file}: {e}")
-            return Project.from_dict({})
+            return Project._from_empty_dict()
 
         if "project" not in data:
             logger.error(f"No project section in {toml_file}")
-            return Project.from_dict({})
+            return Project._from_empty_dict()
 
         if "name" not in data["project"]:
             logger.error(f"No name in project section of {toml_file}")
-            return Project.from_dict({})
+            return Project._from_empty_dict()
+
+        # Extract project data and build system data separately for performance
+        project_data = data["project"]
+        build_system_data = data.get("build-system", {})
+
+        # Merge data efficiently
+        merged_data = project_data.copy()  # Start with project data
+
+        # Handle TOML field names that use hyphens but Python attributes use underscores
+        if "requires-python" in merged_data:
+            merged_data["requires_python"] = merged_data.pop("requires-python")
+
+        merged_data.update({"toml_path": toml_file})
+        merged_data.update(build_system_data)  # Add build system data
+
+        return Project._from_dict(merged_data)
 
-        return Project.from_dict({**data["project"], **data.get("build-system", {})})
+    def pack_source(self):
+        """Pack source code and resources to dist/src directory."""
+        pass
+
+    def pack_embed_python(self):
+        """Pack Python runtime to dist/runtime directory."""
+        pass
 
     @cached_property
     def raw_data(self) -> dict[str, Any]:
@@ -216,7 +403,12 @@ class Project:
         }
 
     @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> Project:
+    def _from_empty_dict(cls) -> Project:
+        """Create a Project instance from an empty dictionary."""
+        return cls._from_dict({})
+
+    @classmethod
+    def _from_dict(cls, data: dict[str, Any]) -> Project:
         """Create a Project instance from a dictionary of project attributes.
 
         Args:
@@ -242,6 +434,8 @@ class Project:
             urls=data.get("urls", {}),
             build_backend=data.get("build_backend", ""),
             requires=data.get("requires", []),
+            toml_path=data.get("toml_path", Path("")),
+            solution_root_dir=data.get("solution_root_dir"),
         )
 
 
@@ -268,27 +462,41 @@ class Solution:
     time_stamp: datetime.datetime = field(default_factory=datetime.datetime.now)
 
     def __repr__(self):
-        return f"""
-        <Solution root={self.root_dir}
-                  projects: {len(self.projects)}
-                  update: {self.update}
-                  time_used: {self.elapsed_time:.4f}s
-                  timestamp: {self.time_stamp}
-        >"""
-
-    @cached_property
-    def elapsed_time(self) -> float:
-        """Calculate and cache the elapsed time since start."""
-        return time.perf_counter() - self.start_time
+        return (
+            f"<Solution(\n"
+            f"  root_dir={self.root_dir!r},\n"
+            f"  projects: {len(self.projects)},\n"
+            f"  update={self.update!r},\n"
+            f"  time_used={self.elapsed_time:.4f}s,\n"
+            f"  timestamp={self.time_stamp!r}\n"
+            f")>"
+        )
 
     def __post_init__(self):
-        logger.info(f"\t - Loaded {len(self.projects)} projects from {self.root_dir}")
         # Only log brief summary to avoid overly verbose output
         logger.info(
-            f"\t - Solution created in {self.elapsed_time:.4f}s at {self.time_stamp}"
+            f"Solution: {len(self.projects)} projects from {self.root_dir}, "
+            f"created in {self.elapsed_time:.4f}s at {self.time_stamp:%Y-%m-%d %H:%M:%S}"
         )
         self._write_project_json()
 
+    @cached_property
+    def elapsed_time(self) -> float:
+        """Calculate and cache the elapsed time since start."""
+        return time.perf_counter() - self.start_time
+
+    @cached_property
+    def dependencies(self) -> set[str]:
+        """Get a set of all dependencies for all projects in the solution.
+
+        Returns:
+            Set of dependency package names.
+        """
+        # Use set comprehension for better performance
+        return {
+            dep for project in self.projects.values() for dep in project.dependencies
+        }
+
     @cached_property
     def json_file(self) -> Path:
         """Path to the cache file where project data is stored.
@@ -298,6 +506,69 @@ class Solution:
         """
         return self.root_dir / "projects.json"
 
+    def find_matching_projects(self, pattern: str) -> list[str]:
+        """Find all projects matching the given pattern (case-insensitive).
+
+        Args:
+            pattern: Pattern to match (substring, case-insensitive)
+
+        Returns:
+            List of matching project names
+        """
+        if not pattern:
+            return []
+
+        lower_pattern = pattern.lower()
+        return [name for name in self.projects if lower_pattern in name.lower()]
+
+    def resolve_project_name(self, project_name: str | None) -> str | None:
+        """Resolve project name with fuzzy matching support.
+
+        Resolution strategy:
+        1. If project_name is None: auto-select if only one project exists
+        2. Exact match: return if project name exists
+        3. Fuzzy match: find projects containing the given substring (case-insensitive)
+        4. If multiple fuzzy matches: return None (ambiguous)
+
+        Args:
+            project_name: Project name to resolve, or None for auto-selection
+
+        Returns:
+            Resolved project name, or None if resolution fails
+
+        Examples:
+            >>> solution.resolve_project_name(None)  # Auto-select if single project
+            'myproject'
+            >>> solution.resolve_project_name('docscan')  # Exact match
+            'docscan'
+            >>> solution.resolve_project_name('doc')  # Fuzzy match
+            'docscan'
+            >>> solution.resolve_project_name('scan')  # Fuzzy match
+            'docscan'
+        """
+        # Auto-select if only one project
+        if not project_name:
+            if len(self.projects) == 1:
+                return next(iter(self.projects.keys()))
+            return None
+
+        # Exact match (case-sensitive)
+        if project_name in self.projects:
+            return project_name
+
+        # Fuzzy match (case-insensitive substring matching)
+        lower_name = project_name.lower()
+        matches = [name for name in self.projects if lower_name in name.lower()]
+
+        if len(matches) == 1:
+            return matches[0]
+        elif len(matches) > 1:
+            # Multiple matches found - ambiguous
+            return None
+
+        # No match found
+        return None
+
     @classmethod
     def from_toml_files(
         cls, root_dir: Path, toml_files: list[Path], update: bool = False
@@ -322,6 +593,31 @@ class Solution:
                     f"Warning: {toml_file} does not contain project information"
                 )
                 continue
+
+            # For multi-project solutions, set solution_root_dir
+            # Create new Project with solution_root_dir set
+            if len(toml_files) > 1:
+                project = Project(
+                    name=project.name,
+                    version=project.version,
+                    description=project.description,
+                    readme=project.readme,
+                    requires_python=project.requires_python,
+                    dependencies=project.dependencies,
+                    optional_dependencies=project.optional_dependencies,
+                    scripts=project.scripts,
+                    entry_points=project.entry_points,
+                    authors=project.authors,
+                    license=project.license,
+                    keywords=project.keywords,
+                    classifiers=project.classifiers,
+                    urls=project.urls,
+                    build_backend=project.build_backend,
+                    requires=project.requires,
+                    toml_path=project.toml_path,
+                    solution_root_dir=root_dir,
+                )
+
             projects[project.name] = project
 
         return cls(root_dir=root_dir, projects=projects, update=update)
@@ -347,16 +643,16 @@ class Solution:
                     # Check if the value has a "project" section (from pyproject.toml parsing)
                     if "project" in value:
                         project_data = value.get("project", {})
-                        projects[key] = Project.from_dict(project_data)
+                        projects[key] = Project._from_dict(project_data)
                     else:
                         # Check if the value contains direct project attributes
                         # Use set intersection with module-level constant for faster attribute checking
                         if value.keys() & _REQUIRED_ATTRS:
-                            projects[key] = Project.from_dict(value)
+                            projects[key] = Project._from_dict(value)
                         else:
                             # No project section or recognizable project attributes found
                             logger.warning(f"No project information found in {key}")
-                            projects[key] = Project.from_dict({})
+                            projects[key] = Project._from_empty_dict()
                 else:
                     projects[key] = value
         except (TypeError, ValueError) as e:
@@ -385,6 +681,8 @@ class Solution:
             logger.debug(f"Loading project data from {json_file}...")
             with json_file.open("r", encoding="utf-8") as f:
                 loaded_data = json.load(f)
+            logger.debug(f"\t - Loaded project data from {json_file}")
+            return cls.from_json_data(json_file.parent, loaded_data, update=update)
         except (OSError, json.JSONDecodeError, KeyError) as e:
             logger.error(f"Error loading project data from {json_file}: {e}")
             return cls(root_dir=json_file.parent, projects={})
@@ -392,9 +690,6 @@ class Solution:
             logger.error(f"Unknown error loading project data from {json_file}: {e}")
             return cls(root_dir=json_file.parent, projects={})
 
-        logger.debug(f"\t - Loaded project data from {json_file}")
-        return cls.from_json_data(json_file.parent, loaded_data, update=update)
-
     @classmethod
     def from_directory(cls, root_dir: Path, update: bool = False) -> Solution:
         """Create a Solution instance by scanning a directory for pyproject.toml files.
@@ -441,8 +736,7 @@ class Solution:
             return
 
         try:
-            # Convert Project objects to dictionaries for JSON serialization
-            # Use dict comprehension for better performance
+            # Pre-cache raw_data access to avoid repeated property access
             serializable_data = {
                 key: project_data.raw_data
                 if isinstance(project_data, Project)
@@ -452,14 +746,11 @@ class Solution:
 
             with json_file.open("w", encoding="utf-8") as f:
                 json.dump(serializable_data, f, indent=2, ensure_ascii=False)
+            logger.info(f"Output written to {json_file}")
         except (OSError, json.JSONDecodeError, KeyError) as e:
             logger.error(f"Error writing output to {json_file}: {e}")
-            return
         except Exception as e:
             logger.error(f"Unknown error writing output to {json_file}: {e}")
-            return
-        else:
-            logger.info(f"Output written to {json_file}")
 
 
 def create_parser() -> argparse.ArgumentParser:
@@ -491,6 +782,12 @@ def create_parser() -> argparse.ArgumentParser:
 
 
 def main() -> None:
+    """Main entry point for the pyproject.toml parser tool.
+
+    Parses command line arguments and creates a Solution instance by scanning
+    the specified directory for pyproject.toml files. Uses cached data if
+    available unless the update flag is set.
+    """
     parser = create_parser()
     args = parser.parse_args()
 

sfi/pysourcepack/__init__.py

@@ -0,0 +1 @@
+