Update Profile Detection

Author: Behemyth

cppython/plugins/conan/plugin.py

@@ -12,6 +12,7 @@
 import requests
 from conan.api.conan_api import ConanAPI
 from conan.api.model import ListPattern
+from conan.internal.model.profile import Profile
 
 from cppython.core.plugin_schema.generator import SyncConsumer
 from cppython.core.plugin_schema.provider import Provider, ProviderPluginGroupData, SupportedProviderFeatures
@@ -108,45 +109,27 @@ def _install_dependencies(self, *, update: bool = False) -> None:
             all_remotes = conan_api.remotes.list()
             logger.debug('Available remotes: %s', [remote.name for remote in all_remotes])
 
-            # Get default profiles, handle case when no default profile exists
-            try:
-                profile_host_path = conan_api.profiles.get_default_host()
-                profile_build_path = conan_api.profiles.get_default_build()
-
-                # Ensure we have valid profile paths
-                if profile_host_path is None:
-                    # Create a minimal default profile if none exists
-                    profile_host = conan_api.profiles.get_profile([])
-                else:
-                    profile_host = conan_api.profiles.get_profile([profile_host_path])
-
-                if profile_build_path is None:
-                    # Create a minimal default profile if none exists
-                    profile_build = conan_api.profiles.get_profile([])
-                else:
-                    profile_build = conan_api.profiles.get_profile([profile_build_path])
-
-            except Exception:
-                # If profile operations fail, create minimal default profiles
-                profile_host = conan_api.profiles.get_profile([])
-                profile_build = conan_api.profiles.get_profile([])
-
-            logger.debug('Using profiles: host=%s, build=%s', profile_host, profile_build)
-
-            # Build dependency graph
+            # Get profiles with fallback to auto-detection
+            profile_host, profile_build = self._get_profiles(conan_api)
+
+            path = str(conanfile_path)
+            remotes = all_remotes
+            update_flag = None if not update else True
+            check_updates_flag = update
+
             deps_graph = conan_api.graph.load_graph_consumer(
-                path=str(conanfile_path),
+                path=path,
                 name=None,
                 version=None,
                 user=None,
                 channel=None,
-                profile_host=profile_host,
-                profile_build=profile_build,
                 lockfile=None,
-                remotes=all_remotes,
-                update=None if not update else True,
-                check_updates=update,
+                remotes=remotes,
+                update=update_flag,
+                check_updates=check_updates_flag,
                 is_build_require=False,
+                profile_host=profile_host,
+                profile_build=profile_build,
             )
 
             logger.debug('Dependency graph loaded with %d nodes', len(deps_graph.nodes))
@@ -266,43 +249,26 @@ def publish(self) -> None:
             remotes=all_remotes,  # Use all remotes for dependency resolution during export
         )
 
-        # Step 2: Get default profiles, handle case when no default profile exists
-        try:
-            profile_host_path = conan_api.profiles.get_default_host()
-            profile_build_path = conan_api.profiles.get_default_build()
+        # Step 2: Get profiles with fallback to auto-detection
+        profile_host, profile_build = self._get_profiles(conan_api)
 
-            # Ensure we have valid profile paths
-            if profile_host_path is None:
-                # Create a minimal default profile if none exists
-                profile_host = conan_api.profiles.get_profile([])
-            else:
-                profile_host = conan_api.profiles.get_profile([profile_host_path])
-
-            if profile_build_path is None:
-                # Create a minimal default profile if none exists
-                profile_build = conan_api.profiles.get_profile([])
-            else:
-                profile_build = conan_api.profiles.get_profile([profile_build_path])
+        # Step 3: Build dependency graph for the package - prepare parameters
+        path = str(conanfile_path)
+        remotes = all_remotes  # Use all remotes for dependency resolution
 
-        except Exception:
-            # If profile operations fail, create minimal default profiles
-            profile_host = conan_api.profiles.get_profile([])
-            profile_build = conan_api.profiles.get_profile([])
-
-        # Step 3: Build dependency graph for the package
         deps_graph = conan_api.graph.load_graph_consumer(
-            path=str(conanfile_path),
+            path=path,
             name=None,
             version=None,
             user=None,
             channel=None,
-            profile_host=profile_host,
-            profile_build=profile_build,
             lockfile=None,
-            remotes=all_remotes,  # Use all remotes for dependency resolution
+            remotes=remotes,
             update=None,
             check_updates=False,
             is_build_require=False,
+            profile_host=profile_host,
+            profile_build=profile_build,
         )
 
         # Step 4: Analyze binaries and install/build them if needed
@@ -339,3 +305,68 @@ def publish(self) -> None:
                 )
             else:
                 raise ProviderInstallationError('conan', 'No packages found to upload')
+
+    def _apply_profile_processing(self, profiles: list[Profile], conan_api: ConanAPI, cache_settings: Any) -> None:
+        """Apply profile plugin and settings processing to a list of profiles.
+
+        Args:
+            profiles: List of profiles to process
+            conan_api: The Conan API instance
+            cache_settings: The settings configuration
+        """
+        logger = logging.getLogger('cppython.conan')
+
+        # Apply profile plugin processing
+        try:
+            profile_plugin = conan_api.profiles._load_profile_plugin()
+            if profile_plugin is not None:
+                for profile in profiles:
+                    try:
+                        profile_plugin(profile)
+                    except Exception as plugin_error:
+                        logger.warning('Profile plugin failed for profile: %s', str(plugin_error))
+        except (AttributeError, Exception):
+            logger.debug('Profile plugin not available or failed to load')
+
+        # Process settings to initialize processed_settings
+        for profile in profiles:
+            try:
+                profile.process_settings(cache_settings)
+            except (AttributeError, Exception) as settings_error:
+                logger.debug('Settings processing failed for profile: %s', str(settings_error))
+
+    def _get_profiles(self, conan_api: ConanAPI) -> tuple[Profile, Profile]:
+        """Get Conan profiles with fallback to auto-detection.
+
+        Args:
+            conan_api: The Conan API instance
+
+        Returns:
+            A tuple of (profile_host, profile_build) objects
+        """
+        logger = logging.getLogger('cppython.conan')
+
+        try:
+            # Gather default profile paths, these can raise exceptions if not available
+            profile_host_path = conan_api.profiles.get_default_host()
+            profile_build_path = conan_api.profiles.get_default_build()
+
+            # Load the actual profile objects, can raise if data is invalid
+            profile_host = conan_api.profiles.get_profile([profile_host_path])
+            profile_build = conan_api.profiles.get_profile([profile_build_path])
+
+            logger.debug('Using existing default profiles')
+            return profile_host, profile_build
+
+        except Exception as e:
+            logger.warning('Default profiles not available, using auto-detection. Conan message: %s', str(e))
+
+            # Create auto-detected profiles
+            profiles = [conan_api.profiles.detect(), conan_api.profiles.detect()]
+            cache_settings = conan_api.config.settings_yml
+
+            # Apply profile plugin processing to both profiles
+            self._apply_profile_processing(profiles, conan_api, cache_settings)
+
+            logger.debug('Auto-detected profiles with plugin processing applied')
+            return profiles[0], profiles[1]

tests/fixtures/conan.py

@@ -43,6 +43,7 @@ def fixture_conan_mock_api(mocker: MockerFixture) -> Mock:
     mock_api.profiles.get_default_host = mocker.Mock(return_value=None)
     mock_api.profiles.get_default_build = mocker.Mock(return_value=None)
     mock_api.profiles.get_profile = mocker.Mock(return_value=mock_profile)
+    mock_api.profiles.detect = mocker.Mock(return_value=mock_profile)
 
     return mock_api
 
@@ -90,6 +91,7 @@ def fixture_conan_mock_api_publish(mocker: MockerFixture) -> Mock:
     mock_api.profiles.get_default_host = mocker.Mock(return_value='/path/to/default/host')
     mock_api.profiles.get_default_build = mocker.Mock(return_value='/path/to/default/build')
     mock_api.profiles.get_profile = mocker.Mock(return_value=mock_profile)
+    mock_api.profiles.detect = mocker.Mock(return_value=mock_profile)
 
     return mock_api
 

tests/integration/plugins/conan/test_provider.py

@@ -1,5 +1,6 @@
 """Integration tests for the provider"""
 
+from pathlib import Path
 from typing import Any
 
 import pytest
@@ -8,7 +9,24 @@
 from cppython.test.pytest.contracts import ProviderIntegrationTestContract
 
 
-class TestCPPythonProvider(ProviderIntegrationTestContract[ConanProvider]):
+@pytest.fixture(autouse=True)
+def clean_conan_cache(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    """Sets CONAN_HOME to a temporary directory for each test.
+
+    This ensures all tests run with a clean Conan cache.
+
+    Args:
+        tmp_path: Pytest temporary directory fixture
+        monkeypatch: Pytest monkeypatch fixture for environment variable manipulation
+    """
+    conan_home = tmp_path / 'conan_home'
+    conan_home.mkdir()
+
+    # Set CONAN_HOME to the temporary directory
+    monkeypatch.setenv('CONAN_HOME', str(conan_home))
+
+
+class TestConanProvider(ProviderIntegrationTestContract[ConanProvider]):
     """The tests for the conan provider"""
 
     @staticmethod