Add Presets File Write

Author: Behemyth

cppython/plugins/conan/builder.py

@@ -121,7 +121,9 @@ def __init__(self) -> None:
         self._filename = 'conanfile.py'
 
     @staticmethod
-    def _create_conanfile(conan_file: Path, dependencies: list[ConanDependency], name: str, version: str) -> None:
+    def _create_conanfile(
+        conan_file: Path, dependencies: list[ConanDependency], name: str, version: str, preset_file: Path
+    ) -> None:
         """Creates a conanfile.py file with the necessary content."""
         template_string = """
         from conan import ConanFile
@@ -140,6 +142,7 @@ def generate(self):
                 deps = CMakeDeps(self)
                 deps.generate()
                 tc = CMakeToolchain(self)
+                tc.user_presets_path = "${preset_file}"
                 tc.generate()
 
             def build(self):
@@ -158,6 +161,7 @@ def package(self):
             'name': name,
             'version': version,
             'dependencies': [dependency.requires() for dependency in dependencies],
+            'preset_file': str(preset_file),
         }
 
         result = template.substitute(values)
@@ -166,7 +170,7 @@ def package(self):
             file.write(result)
 
     def generate_conanfile(
-        self, directory: DirectoryPath, dependencies: list[ConanDependency], name: str, version: str
+        self, directory: DirectoryPath, dependencies: list[ConanDependency], name: str, version: str, preset_file: Path
     ) -> None:
         """Generate a conanfile.py file for the project."""
         conan_file = directory / self._filename
@@ -181,4 +185,4 @@ def generate_conanfile(
             conan_file.write_text(modified.code, encoding='utf-8')
         else:
             directory.mkdir(parents=True, exist_ok=True)
-            self._create_conanfile(conan_file, dependencies, name, version)
+            self._create_conanfile(conan_file, dependencies, name, version, preset_file)

cppython/plugins/conan/plugin.py

@@ -91,6 +91,7 @@ def _prepare_installation(self) -> Path:
             resolved_dependencies,
             self.core_data.pep621_data.name,
             self.core_data.pep621_data.version,
+            self.core_data.cppython_data.tool_path / 'ConanPresets.json',
         )
 
         # Ensure build directory exists
@@ -120,15 +121,8 @@ def _run_conan_install(self, conanfile_path: Path, update: bool, logger) -> None
         command.extend(['--build', 'missing'])
 
         # Add profiles if specified
-        if self.data.host_profile and str(self.data.host_profile) != 'default':
-            command.extend(['--profile:host', str(self.data.host_profile)])
-        else:
-            command.extend(['--profile:host', 'default'])
-
-        if self.data.build_profile and str(self.data.build_profile) != 'default':
-            command.extend(['--profile:build', str(self.data.build_profile)])
-        else:
-            command.extend(['--profile:build', 'default'])
+        command.extend(['--profile:host', 'default'])
+        command.extend(['--profile:build', 'default'])
 
         # Add update flag if needed
         if update:
@@ -225,15 +219,8 @@ def publish(self) -> None:
             command.extend(['--build', 'missing'])
 
             # Add profiles
-            if self.data.host_profile and str(self.data.host_profile) != 'default':
-                command.extend(['--profile:host', str(self.data.host_profile)])
-            else:
-                command.extend(['--profile:host', 'default'])
-
-            if self.data.build_profile and str(self.data.build_profile) != 'default':
-                command.extend(['--profile:build', str(self.data.build_profile)])
-            else:
-                command.extend(['--profile:build', 'default'])
+            command.extend(['--profile:host', 'default'])
+            command.extend(['--profile:build', 'default'])
 
             # Log the command being executed
             logger.info('Executing conan create command: %s', ' '.join(command))

cppython/plugins/conan/resolution.py

@@ -1,12 +1,8 @@
 """Provides functionality to resolve Conan-specific data for the CPPython project."""
 
-import importlib
-import logging
 from pathlib import Path
 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
@@ -18,193 +14,6 @@
     ConanVersion,
     ConanVersionRange,
 )
-from cppython.utility.exception import ProviderConfigurationError
-
-
-def _detect_cmake_program() -> str | None:
-    """Detect CMake program path from the cmake module if available.
-
-    Returns:
-        Path to cmake executable, or None if not found
-    """
-    try:
-        # Try to import cmake module and get its executable path
-        # Note: cmake is an optional dependency, so we import it conditionally
-        cmake = importlib.import_module('cmake')
-
-        cmake_bin_dir = Path(cmake.CMAKE_BIN_DIR)
-
-        # Try common cmake executable names (pathlib handles platform differences)
-        for cmake_name in ['cmake.exe', 'cmake']:
-            cmake_exe = cmake_bin_dir / cmake_name
-            if cmake_exe.exists():
-                return str(cmake_exe)
-
-        return None
-    except ImportError:
-        # cmake module not available
-        return None
-    except (AttributeError, Exception):
-        # If cmake module doesn't have expected attributes
-        return None
-
-
-def _profile_post_process(
-    profiles: list[Profile], conan_api: ConanAPI, cache_settings: Any, cmake_program: str | None = None
-) -> 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
-        cmake_program: Optional path to cmake program to configure in profiles
-    """
-    logger = logging.getLogger('cppython.conan')
-
-    # Get global configuration
-    global_conf = conan_api.config.global_conf
-
-    # 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')
-
-    # Apply the full profile processing pipeline for each profile
-    for profile in profiles:
-        # Set cmake program configuration if provided
-        if cmake_program is not None:
-            try:
-                # Set the tools.cmake:cmake_program configuration in the profile
-                profile.conf.update('tools.cmake:cmake_program', cmake_program)
-                logger.debug('Set tools.cmake:cmake_program=%s in profile', cmake_program)
-            except (AttributeError, Exception) as cmake_error:
-                logger.debug('Failed to set cmake program configuration: %s', str(cmake_error))
-
-        # Process settings to initialize processed_settings
-        try:
-            profile.process_settings(cache_settings)
-        except (AttributeError, Exception) as settings_error:
-            logger.debug('Settings processing failed for profile: %s', str(settings_error))
-
-        # Validate configuration
-        try:
-            profile.conf.validate()
-        except (AttributeError, Exception) as conf_error:
-            logger.debug('Configuration validation failed for profile: %s', str(conf_error))
-
-        # Apply global configuration to the profile
-        try:
-            if global_conf is not None:
-                profile.conf.rebase_conf_definition(global_conf)
-        except (AttributeError, Exception) as rebase_error:
-            logger.debug('Configuration rebase failed for profile: %s', str(rebase_error))
-
-
-def _apply_cmake_config_to_profile(profile: Profile, cmake_program: str | None, profile_type: str) -> None:
-    """Apply cmake program configuration to a profile.
-
-    Args:
-        profile: The profile to configure
-        cmake_program: Path to cmake program to configure
-        profile_type: Type of profile (for logging)
-    """
-    if cmake_program is not None:
-        logger = logging.getLogger('cppython.conan')
-        try:
-            profile.conf.update('tools.cmake:cmake_program', cmake_program)
-            logger.debug('Set tools.cmake:cmake_program=%s in %s profile', cmake_program, profile_type)
-        except (AttributeError, Exception) as cmake_error:
-            logger.debug('Failed to set cmake program in %s profile: %s', profile_type, str(cmake_error))
-
-
-def _resolve_profiles(
-    host_profile_name: str | None, build_profile_name: str | None, conan_api: ConanAPI, cmake_program: str | None = None
-) -> 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
-        cmake_program: Optional path to cmake program to configure in profiles
-
-    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)
-                _apply_cmake_config_to_profile(profile, cmake_program, profile_type)
-                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)
-                _apply_cmake_config_to_profile(profile, cmake_program, profile_type)
-                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)
-            _apply_cmake_config_to_profile(profile, cmake_program, profile_type)
-            return profile
-        except Exception as e:
-            logger.debug('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, cmake_program)
-
-            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 _handle_single_specifier(name: str, specifier) -> ConanDependency:
@@ -257,7 +66,7 @@ def resolve_conan_dependency(requirement: Requirement) -> ConanDependency:
         return _handle_single_specifier(requirement.name, next(iter(specifiers)))
 
     # Handle multiple specifiers - convert to Conan range syntax
-    range_parts = []
+    range_parts: list[str] = []
 
     # Define order for operators to ensure consistent output
     operator_order = ['>=', '>', '<=', '<', '!=']
@@ -305,20 +114,13 @@ def resolve_conan_data(data: dict[str, Any], core_data: CorePluginData) -> Conan
     """
     parsed_data = ConanConfiguration(**data)
 
-    # Initialize Conan API for profile resolution
-    conan_api = ConanAPI()
+    profile_dir = Path(parsed_data.profile_dir)
 
-    # Try to detect cmake program path from current virtual environment
-    cmake_program = _detect_cmake_program()
-
-    # Resolve profiles
-    host_profile, build_profile = _resolve_profiles(
-        parsed_data.host_profile, parsed_data.build_profile, conan_api, cmake_program
-    )
+    if not profile_dir.is_absolute():
+        profile_dir = core_data.cppython_data.tool_path / profile_dir
 
     return ConanData(
         remotes=parsed_data.remotes,
         skip_upload=parsed_data.skip_upload,
-        host_profile=host_profile,
-        build_profile=build_profile,
+        profile_dir=profile_dir,
     )

cppython/plugins/conan/schema.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """Conan plugin schema
 
 This module defines Pydantic models used for integrating the Conan
@@ -8,7 +10,6 @@
 import re
 from typing import Annotated
 
-from conan.internal.model.profile import Profile
 from pydantic import Field, field_validator
 
 from cppython.core.schema import CPPythonModel
@@ -294,8 +295,7 @@ class ConanData(CPPythonModel):
 
     remotes: list[str]
     skip_upload: bool
-    host_profile: Profile
-    build_profile: Profile
+    profile_dir: Path
 
 
 class ConanConfiguration(CPPythonModel):
@@ -307,19 +307,13 @@ class ConanConfiguration(CPPythonModel):
     ] = ['conancenter']
     skip_upload: Annotated[
         bool,
-        Field(description='If true, skip uploading packages during publish (local-only mode).'),
+        Field(description='If true, skip uploading packages to a remote during publishing.'),
     ] = False
-    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,
+    profile_dir: Annotated[
+        str,
         Field(
-            description='Conan build profile defining the platform where the compilation process executes. '
-            'Typically matches the development machine.'
+            description='Directory containing Conan profiles. Profiles will be looked up relative to this directory. '
+            'If profiles do not exist in this directory, Conan will fall back to default profiles.'
+            "If a relative path is provided, it will be resolved relative to the tool's working directory."
         ),
-    ] = 'default'
+    ] = 'profiles'