comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/resolvers/model_resolver.py

@@ -0,0 +1,250 @@
+"""ModelResolver - Resolve model requirements for environment import/export."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+
+from ..logging.logging_config import get_logger
+from ..models.workflow import (
+    ModelResolutionContext,
+    WorkflowNodeWidgetRef,
+    WorkflowNode,
+    ResolvedModel,
+    WorkflowDependencies,
+)
+from ..configs.model_config import ModelConfig
+
+if TYPE_CHECKING:
+    from ..managers.pyproject_manager import PyprojectManager
+    from ..repositories.model_repository import ModelRepository
+    from ..models.shared import ModelWithLocation
+
+logger = get_logger(__name__)
+
+
+class ModelResolver:
+    """Resolve model requirements for environments using multiple strategies."""
+
+    def __init__(
+        self,
+        model_repository: ModelRepository,
+        model_config: ModelConfig | None = None, 
+        download_manager=None,
+    ):
+        """Initialize ModelResolver.
+
+        Args:
+            index_manager: ModelIndexManager for lookups
+            download_manager: Optional ModelDownloadManager for downloading
+        """
+        self.model_repository = model_repository
+        self.model_config = model_config or ModelConfig.load()
+        self.download_manager = download_manager
+
+    def resolve_model(
+        self, ref: WorkflowNodeWidgetRef, model_context: ModelResolutionContext
+    ) -> list[ResolvedModel] | None:
+        """Try multiple resolution strategies"""
+        workflow_name = model_context.workflow_name
+        widget_value = ref.widget_value
+
+        # Strategy 0: Check existing pyproject model data first
+        context_resolution_result = self._try_context_resolution(widget_ref=ref, context=model_context)
+        if context_resolution_result:
+            logger.debug(
+                f"Resolved {ref} to {context_resolution_result.resolved_model} from pyproject.toml"
+            )
+            return [context_resolution_result]
+
+        # Strategy 1: Exact path match
+        all_models = self.model_repository.get_all_models()
+        candidates = self._try_exact_match(widget_value, all_models)
+        if len(candidates) == 1:
+            logger.debug(f"Resolved {ref} to {candidates[0]} as exact match")
+            return [
+                ResolvedModel(
+                    workflow=workflow_name,
+                    reference=ref,
+                    match_type="exact",
+                    resolved_model=candidates[0],
+                    match_confidence=1.0,
+                )
+            ]
+
+        # Strategy 2: Reconstruct paths for native loaders
+        if self.model_config.is_model_loader_node(ref.node_type):
+            paths = self.model_config.reconstruct_model_path(
+                ref.node_type, widget_value
+            )
+            for path in paths:
+                candidates = self._try_exact_match(path, all_models)
+                if len(candidates) == 1:
+                    logger.debug(
+                        f"Resolved {ref} to {candidates[0]} as reconstructed match"
+                    )
+                    return [
+                        ResolvedModel(
+                            workflow=workflow_name,
+                            reference=ref,
+                            match_type="reconstructed",
+                            resolved_model=candidates[0],
+                            match_confidence=0.9,
+                        )
+                    ]
+
+        # Strategy 3: Case-insensitive match
+        candidates = self._try_case_insensitive_match(widget_value, all_models)
+        if len(candidates) == 1:
+            logger.debug(f"Resolved {ref} to {candidates[0]} as case-insensitive match")
+            return [
+                ResolvedModel(
+                    workflow=workflow_name,
+                    reference=ref,
+                    match_type="case_insensitive",
+                    resolved_model=candidates[0],
+                    match_confidence=0.8,
+                )
+            ]
+        elif len(candidates) > 1:
+            # Multiple matches - need disambiguation
+            logger.debug(
+                f"Resolved {ref} to {candidates} as case-insensitive match, ambiguous"
+            )
+            return [
+                ResolvedModel(
+                    workflow=workflow_name,
+                    reference=ref,
+                    match_type="case_insensitive",
+                    resolved_model=model,
+                    match_confidence=0.0,
+                )
+                for model in candidates
+            ]
+
+        # Strategy 4: Filename-only match
+        filename = Path(widget_value).name
+        candidates = self.model_repository.find_by_filename(filename)
+        if len(candidates) == 1:
+            logger.debug(f"Resolved {ref} to {candidates[0]} as filename-only match")
+            return [
+                ResolvedModel(
+                    workflow=workflow_name,
+                    reference=ref,
+                    match_type="filename",
+                    resolved_model=candidates[0],
+                    match_confidence=0.7,
+                )
+            ]
+        elif len(candidates) > 1:
+            # Multiple matches - need disambiguation
+            logger.debug(
+                f"Resolved {ref} to {candidates} as filename-only match, ambiguous"
+            )
+            return [
+                ResolvedModel(
+                    workflow=workflow_name,
+                    reference=ref,
+                    match_type="filename",
+                    resolved_model=model,
+                    match_confidence=0.0,
+                )
+                for model in candidates
+            ]
+
+        # No matches found
+        logger.debug(f"No matches found in pyproject or model index for {ref}")
+        return None
+
+    def _try_exact_match(self, path: str, all_models: list[ModelWithLocation] | None =None) -> list["ModelWithLocation"]:
+        """Try exact path match"""
+        if all_models is None:
+            all_models = self.model_repository.get_all_models()
+        return [m for m in all_models if m.relative_path == path]
+
+    def _try_case_insensitive_match(self, path: str, all_models: list[ModelWithLocation] | None =None) -> list["ModelWithLocation"]:
+        """Try case-insensitive path match"""
+        if all_models is None:
+            all_models = self.model_repository.get_all_models()
+        path_lower = path.lower()
+        return [m for m in all_models if m.relative_path.lower() == path_lower]
+    
+    def _try_context_resolution(self, context: ModelResolutionContext, widget_ref: WorkflowNodeWidgetRef) -> ResolvedModel | None:
+        """Check if this ref was previously resolved using context lookup.
+
+        Now supports download intent detection via full ManifestWorkflowModel objects.
+        """
+        workflow_name = context.workflow_name
+
+        # Check if ref exists in previous resolutions (now contains full ManifestWorkflowModel)
+        manifest_model = context.previous_resolutions.get(widget_ref)
+
+        if not manifest_model:
+            return None
+
+        # NEW: Check if download intent (has URL but no hash yet)
+        if manifest_model.status == "unresolved" and manifest_model.sources:
+            # Download intent found - don't re-prompt user
+            from pathlib import Path
+            return ResolvedModel(
+                workflow=workflow_name,
+                reference=widget_ref,
+                match_type="download_intent",
+                resolved_model=None,
+                model_source=manifest_model.sources[0],  # URL from previous session
+                target_path=Path(manifest_model.relative_path) if manifest_model.relative_path else None,
+                is_optional=False,
+                match_confidence=1.0,
+            )
+
+        # Handle optional unresolved models (user explicitly marked as optional)
+        if manifest_model.status == "unresolved" and not manifest_model.sources:
+            # Only treat as optional if user explicitly marked it (criticality="optional")
+            # Otherwise it's just unresolved (from interrupted resolution) - return None
+            if manifest_model.criticality == "optional":
+                return ResolvedModel(
+                    workflow=workflow_name,
+                    reference=widget_ref,
+                    match_type="workflow_context",
+                    resolved_model=None,
+                    is_optional=True,
+                    match_confidence=1.0,
+                )
+            # Not explicitly optional - this is truly unresolved, let it fall through
+            return None
+
+        # Handle resolved models - look up in repository by hash
+        if manifest_model.hash:
+            resolved_model = self.model_repository.get_model(manifest_model.hash)
+
+            if not resolved_model:
+                # Model was previously resolved but doesn't exist locally
+                # Check global models table for download sources (fallback path)
+                global_model = context.global_models.get(manifest_model.hash)
+                if global_model and global_model.sources:
+                    # Create download intent from global models table
+                    from pathlib import Path
+                    logger.info(f"Creating download intent for {manifest_model.filename} from global models table")
+                    return ResolvedModel(
+                        workflow=workflow_name,
+                        reference=widget_ref,
+                        match_type="download_intent",
+                        resolved_model=None,
+                        model_source=global_model.sources[0],
+                        target_path=Path(global_model.relative_path) if global_model.relative_path else None,
+                        is_optional=False,
+                        match_confidence=1.0,
+                    )
+
+                logger.warning(f"Model {manifest_model.hash} in previous resolutions but not found in repository or global models")
+                return None
+
+            return ResolvedModel(
+                workflow=workflow_name,
+                reference=widget_ref,
+                match_type="workflow_context",
+                resolved_model=resolved_model,
+                match_confidence=1.0,
+            )
+
+        return None

comfygit_core/services/import_analyzer.py

@@ -0,0 +1,218 @@
+"""Import preview and analysis service."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import tomlkit
+
+from ..logging.logging_config import get_logger
+
+if TYPE_CHECKING:
+    from ..repositories.model_repository import ModelRepository
+    from ..repositories.node_mappings_repository import NodeMappingsRepository
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class ModelAnalysis:
+    """Analysis of a single model in the import."""
+    filename: str
+    hash: str | None
+    sources: list[str]
+    relative_path: str
+    locally_available: bool
+    needs_download: bool
+    workflows: list[str]
+
+
+@dataclass
+class NodeAnalysis:
+    """Analysis of a custom node in the import."""
+    name: str
+    source: str  # "registry" | "development" | "git"
+    install_spec: str | None
+    is_dev_node: bool
+
+
+@dataclass
+class WorkflowAnalysis:
+    """Analysis of a workflow in the import."""
+    name: str
+    models_required: int
+    models_optional: int
+
+
+@dataclass
+class ImportAnalysis:
+    """Complete analysis of an import before finalization."""
+
+    # ComfyUI version
+    comfyui_version: str | None
+    comfyui_version_type: str | None
+
+    # Models breakdown
+    models: list[ModelAnalysis]
+    total_models: int
+    models_locally_available: int
+    models_needing_download: int
+    models_without_sources: int
+
+    # Nodes breakdown
+    nodes: list[NodeAnalysis]
+    total_nodes: int
+    registry_nodes: int
+    dev_nodes: int
+    git_nodes: int
+
+    # Workflows
+    workflows: list[WorkflowAnalysis]
+    total_workflows: int
+
+    # Summary flags
+    needs_model_downloads: bool
+    needs_node_installs: bool
+
+    def get_download_strategy_recommendation(self) -> str:
+        """Recommend strategy based on analysis."""
+        if self.models_without_sources > 0:
+            return "required"  # Some models can't be downloaded - user must provide
+        if not self.needs_model_downloads:
+            return "skip"  # All models available locally
+        return "all"  # Can download everything
+
+
+class ImportAnalyzer:
+    """Analyzes import requirements before finalization.
+
+    Works on extracted .cec directory to provide preview of what
+    will be downloaded, installed, and configured during import finalization.
+    """
+
+    def __init__(
+        self,
+        model_repository: ModelRepository,
+        node_mapping_repository: NodeMappingsRepository
+    ):
+        self.model_repository = model_repository
+        self.node_mapping_repository = node_mapping_repository
+
+    def analyze_import(self, cec_path: Path) -> ImportAnalysis:
+        """Analyze import requirements from extracted .cec directory.
+
+        Args:
+            cec_path: Path to extracted .cec directory
+
+        Returns:
+            ImportAnalysis with models, nodes, workflows breakdown
+        """
+        # Parse pyproject.toml
+        pyproject_path = cec_path / "pyproject.toml"
+        with open(pyproject_path, encoding='utf-8') as f:
+            pyproject_data = tomlkit.load(f)
+
+        comfygit_config = pyproject_data.get("tool", {}).get("comfygit", {})
+
+        # Analyze models
+        models = self._analyze_models(pyproject_data)
+
+        # Analyze nodes
+        nodes = self._analyze_nodes(comfygit_config)
+
+        # Analyze workflows
+        workflows = self._analyze_workflows(pyproject_data)
+
+        # Build summary
+        return ImportAnalysis(
+            comfyui_version=comfygit_config.get("comfyui_version"),
+            comfyui_version_type=comfygit_config.get("comfyui_version_type"),
+            models=models,
+            total_models=len(models),
+            models_locally_available=sum(1 for m in models if m.locally_available),
+            models_needing_download=sum(1 for m in models if m.needs_download),
+            models_without_sources=sum(
+                1 for m in models if not m.sources and not m.locally_available
+            ),
+            nodes=nodes,
+            total_nodes=len(nodes),
+            registry_nodes=sum(1 for n in nodes if n.source == "registry"),
+            dev_nodes=sum(1 for n in nodes if n.is_dev_node),
+            git_nodes=sum(1 for n in nodes if n.source == "git"),
+            workflows=workflows,
+            total_workflows=len(workflows),
+            needs_model_downloads=any(m.needs_download for m in models),
+            needs_node_installs=any(n.source in ("registry", "git") for n in nodes),
+        )
+
+    def _analyze_models(self, pyproject_data: dict) -> list[ModelAnalysis]:
+        """Analyze all models from pyproject.toml."""
+        models = []
+
+        # Get global models table
+        global_models = pyproject_data.get("tool", {}).get("comfygit", {}).get("models", {})
+
+        # Get all workflows
+        workflows_config = pyproject_data.get("tool", {}).get("comfygit", {}).get("workflows", {})
+
+        # Build reverse index: hash -> workflows
+        hash_to_workflows = {}
+        for workflow_name, workflow_data in workflows_config.items():
+            for model in workflow_data.get("models", []):
+                model_hash = model.get("hash")
+                if model_hash:
+                    hash_to_workflows.setdefault(model_hash, []).append(workflow_name)
+
+        # Analyze each model
+        for model_hash, model_data in global_models.items():
+            sources = model_data.get("sources", [])
+
+            # Check local availability
+            existing = self.model_repository.get_model(model_hash)
+            locally_available = existing is not None
+
+            models.append(ModelAnalysis(
+                filename=model_data.get("filename", "unknown"),
+                hash=model_hash,
+                sources=sources,
+                relative_path=model_data.get("relative_path", ""),
+                locally_available=locally_available,
+                needs_download=not locally_available and bool(sources),
+                workflows=hash_to_workflows.get(model_hash, [])
+            ))
+
+        return models
+
+    def _analyze_nodes(self, comfygit_config: dict) -> list[NodeAnalysis]:
+        """Analyze all custom nodes from pyproject.toml."""
+        nodes = []
+        nodes_config = comfygit_config.get("nodes", {})
+
+        for node_name, node_data in nodes_config.items():
+            source = node_data.get("source", "registry")
+
+            nodes.append(NodeAnalysis(
+                name=node_name,
+                source=source,
+                install_spec=node_data.get("install_spec"),
+                is_dev_node=(source == "development")
+            ))
+
+        return nodes
+
+    def _analyze_workflows(self, pyproject_data: dict) -> list[WorkflowAnalysis]:
+        """Analyze all workflows."""
+        workflows = []
+        workflows_config = pyproject_data.get("tool", {}).get("comfygit", {}).get("workflows", {})
+
+        for workflow_name, workflow_data in workflows_config.items():
+            models = workflow_data.get("models", [])
+
+            workflows.append(WorkflowAnalysis(
+                name=workflow_name,
+                models_required=sum(1 for m in models if m.get("criticality") == "required"),
+                models_optional=sum(1 for m in models if m.get("criticality") == "optional"),
+            ))
+
+        return workflows