Profile Schema

Author: Behemyth

cppython/plugins/conan/plugin.py

@@ -12,7 +12,6 @@
 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
@@ -109,8 +108,8 @@ 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 profiles with fallback to auto-detection
-            profile_host, profile_build = self._get_profiles(conan_api)
+            # Get profiles from resolved data
+            profile_host, profile_build = self.data.host_profile, self.data.build_profile
 
             path = str(conanfile_path)
             remotes = all_remotes
@@ -249,8 +248,8 @@ def publish(self) -> None:
             remotes=all_remotes,  # Use all remotes for dependency resolution during export
         )
 
-        # Step 2: Get profiles with fallback to auto-detection
-        profile_host, profile_build = self._get_profiles(conan_api)
+        # Step 2: Get profiles from resolved data
+        profile_host, profile_build = self.data.host_profile, self.data.build_profile
 
         # Step 3: Build dependency graph for the package - prepare parameters
         path = str(conanfile_path)
@@ -305,68 +304,3 @@ 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]

cppython/plugins/conan/resolution.py

@@ -1,12 +1,124 @@
 """Provides functionality to resolve Conan-specific data for the CPPython project."""
 
+import logging
 from typing import Any
 
+from conan.api.conan_api import ConanAPI
+from conan.internal.model.profile import Profile
 from packaging.requirements import Requirement
 
 from cppython.core.exception import ConfigException
 from cppython.core.schema import CorePluginData
 from cppython.plugins.conan.schema import ConanConfiguration, ConanData, ConanDependency
+from cppython.utility.exception import ProviderConfigurationError
+
+
+def _profile_post_process(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 _resolve_profiles(
+    host_profile_name: str | None, build_profile_name: str | None, conan_api: ConanAPI
+) -> tuple[Profile, Profile]:
+    """Resolve host and build profiles, with fallback to auto-detection.
+
+    Args:
+        host_profile_name: The host profile name to resolve, or None for auto-detection
+        build_profile_name: The build profile name to resolve, or None for auto-detection
+        conan_api: The Conan API instance
+
+    Returns:
+        A tuple of (host_profile, build_profile)
+    """
+    logger = logging.getLogger('cppython.conan')
+
+    def _resolve_profile(profile_name: str | None, is_host: bool) -> Profile:
+        """Helper to resolve a single profile."""
+        profile_type = 'host' if is_host else 'build'
+
+        if profile_name is not None and profile_name != 'default':
+            # Explicitly specified profile name (not the default) - fail if not found
+            try:
+                logger.debug('Loading %s profile: %s', profile_type, profile_name)
+                profile = conan_api.profiles.get_profile([profile_name])
+                logger.debug('Successfully loaded %s profile: %s', profile_type, profile_name)
+                return profile
+            except Exception as e:
+                logger.error('Failed to load %s profile %s: %s', profile_type, profile_name, str(e))
+                raise ProviderConfigurationError(
+                    'conan',
+                    f'Failed to load {profile_type} profile {profile_name}: {str(e)}',
+                    f'{profile_type}_profile',
+                ) from e
+        elif profile_name == 'default':
+            # Try to load default profile, but fall back to auto-detection if it fails
+            try:
+                logger.debug('Loading %s profile: %s', profile_type, profile_name)
+                profile = conan_api.profiles.get_profile([profile_name])
+                logger.debug('Successfully loaded %s profile: %s', profile_type, profile_name)
+                return profile
+            except Exception as e:
+                logger.debug(
+                    'Failed to load %s profile %s: %s. Falling back to auto-detection.',
+                    profile_type,
+                    profile_name,
+                    str(e),
+                )
+                # Fall back to auto-detection
+
+        try:
+            if is_host:
+                default_profile_path = conan_api.profiles.get_default_host()
+            else:
+                default_profile_path = conan_api.profiles.get_default_build()
+
+            profile = conan_api.profiles.get_profile([default_profile_path])
+            logger.debug('Using default %s profile', profile_type)
+            return profile
+        except Exception as e:
+            logger.warning('Default %s profile not available, using auto-detection: %s', profile_type, str(e))
+
+            # Create auto-detected profile
+            profile = conan_api.profiles.detect()
+            cache_settings = conan_api.config.settings_yml
+
+            # Apply profile plugin processing
+            _profile_post_process([profile], conan_api, cache_settings)
+
+            logger.debug('Auto-detected %s profile with plugin processing applied', profile_type)
+            return profile
+
+    # Resolve both profiles
+    host_profile = _resolve_profile(host_profile_name, is_host=True)
+    build_profile = _resolve_profile(build_profile_name, is_host=False)
+
+    return host_profile, build_profile
 
 
 def resolve_conan_dependency(requirement: Requirement) -> ConanDependency:
@@ -43,4 +155,14 @@ def resolve_conan_data(data: dict[str, Any], core_data: CorePluginData) -> Conan
     """
     parsed_data = ConanConfiguration(**data)
 
-    return ConanData(remotes=parsed_data.remotes)
+    # Initialize Conan API for profile resolution
+    conan_api = ConanAPI()
+
+    # Resolve profiles
+    host_profile, build_profile = _resolve_profiles(parsed_data.host_profile, parsed_data.build_profile, conan_api)
+
+    return ConanData(
+        remotes=parsed_data.remotes,
+        host_profile=host_profile,
+        build_profile=build_profile,
+    )

cppython/plugins/conan/schema.py

@@ -7,6 +7,7 @@
 
 from typing import Annotated
 
+from conan.internal.model.profile import Profile
 from pydantic import Field
 
 from cppython.core.schema import CPPythonModel
@@ -31,6 +32,8 @@ class ConanData(CPPythonModel):
     """Resolved conan data"""
 
     remotes: list[str]
+    host_profile: Profile
+    build_profile: Profile
 
     @property
     def local_only(self) -> bool:
@@ -45,3 +48,17 @@ class ConanConfiguration(CPPythonModel):
         list[str],
         Field(description='List of remotes to upload to. Empty list means the local conan cache will be used.'),
     ] = ['conancenter']
+    host_profile: Annotated[
+        str | None,
+        Field(
+            description='Conan host profile defining the target platform where the built software will run. '
+            'Used for cross-compilation scenarios.'
+        ),
+    ] = 'default'
+    build_profile: Annotated[
+        str | None,
+        Field(
+            description='Conan build profile defining the platform where the compilation process executes. '
+            'Typically matches the development machine.'
+        ),
+    ] = 'default'

tests/unit/plugins/conan/test_install.py

@@ -136,15 +136,15 @@ def mock_resolve(requirement: Requirement) -> ConanDependency:
         # Verify Conan API was attempted
         mock_conan_api_constructor.assert_called_once()
 
-    def test_install_with_profile_exception(
+    def test_install_with_default_profiles(
         self,
         plugin: ConanProvider,
         conan_temp_conanfile: Path,
         conan_mock_dependencies: list[Requirement],
         conan_setup_mocks: dict[str, Mock],
         conan_mock_api: Mock,
     ) -> None:
-        """Test install method when profile operations throw exceptions but detect() works
+        """Test install method uses pre-resolved profiles from plugin construction
 
         Args:
             plugin: The plugin instance
@@ -153,23 +153,21 @@ def test_install_with_profile_exception(
             conan_setup_mocks: Dictionary containing all mocks
             conan_mock_api: Mock ConanAPI instance
         """
-        # Configure the API mock to throw exception on profile calls but detect() works
-        conan_mock_api.profiles.get_default_host.side_effect = Exception('Profile not found')
-
         # Setup dependencies
         plugin.core_data.cppython_data.dependencies = conan_mock_dependencies
 
-        # Execute - should succeed using fallback detect profiles
+        # Execute - should use the profiles resolved during plugin construction
         plugin.install()
 
-        # Verify that the fallback was used
+        # Verify that the API was used for installation
         conan_setup_mocks['conan_api_constructor'].assert_called_once()
-        conan_mock_api.profiles.get_default_host.assert_called_once()
-
-        # Verify detect was called for fallback (should be called twice for fallback)
-        assert conan_mock_api.profiles.detect.call_count >= EXPECTED_PROFILE_CALLS
 
-        # Verify the rest of the process continued
+        # Verify the rest of the process continued with resolved profiles
         conan_mock_api.graph.load_graph_consumer.assert_called_once()
         conan_mock_api.install.install_binaries.assert_called_once()
         conan_mock_api.install.install_consumer.assert_called_once()
+
+        # Verify that the resolved profiles were used in the graph loading
+        call_args = conan_mock_api.graph.load_graph_consumer.call_args
+        assert call_args.kwargs['profile_host'] == plugin.data.host_profile
+        assert call_args.kwargs['profile_build'] == plugin.data.build_profile

tests/unit/plugins/conan/test_publish.py

@@ -179,10 +179,10 @@ def test_publish_no_packages_found(
         with pytest.raises(ProviderInstallationError, match='No packages found to upload'):
             plugin.publish()
 
-    def test_publish_uses_default_profiles(
+    def test_publish_with_default_profiles(
         self, plugin: ConanProvider, conan_mock_api_publish: Mock, conan_temp_conanfile: None, mocker: MockerFixture
     ) -> None:
-        """Test that publish uses default profiles from API
+        """Test that publish uses pre-resolved profiles from plugin construction
 
         Args:
             plugin: The plugin instance
@@ -203,10 +203,11 @@ def test_publish_uses_default_profiles(
         # Execute publish
         plugin.publish()
 
-        # Verify profiles were obtained from API
-        conan_mock_api_publish.profiles.get_default_host.assert_called_once()
-        conan_mock_api_publish.profiles.get_default_build.assert_called_once()
-        conan_mock_api_publish.profiles.get_profile.assert_called()
+        # Verify that the resolved profiles were used in the graph loading
+        conan_mock_api_publish.graph.load_graph_consumer.assert_called_once()
+        call_args = conan_mock_api_publish.graph.load_graph_consumer.call_args
+        assert call_args.kwargs['profile_host'] == plugin.data.host_profile
+        assert call_args.kwargs['profile_build'] == plugin.data.build_profile
 
     def test_publish_upload_parameters(
         self, plugin: ConanProvider, conan_mock_api_publish: Mock, conan_temp_conanfile: None, mocker: MockerFixture