conan-cci-build 0.1.0__tar.gz

conan_cci_build-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 conan-py
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

conan_cci_build-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: conan-cci-build
+Version: 0.1.0
+Requires-Python: >=3.13
+License-File: LICENSE
+Requires-Dist: conan<3.0,>=2.25
+Requires-Dist: packaging>=26.2
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python

conan_cci_build-0.1.0/README.md

@@ -0,0 +1,8 @@
+# [Conan CCI Build](https://github.com/conan-py/conan-cci-build)
+
+Populate a Conan 2 Artifactory remote from a local Conan Center Index checkout.
+
+# Links
+
+- https://github.com/conan-io/conan-center-index
+- https://github.com/conan-io/conan-extensions

conan_cci_build-0.1.0/extensions/commands/cmd_cci_build.py

@@ -0,0 +1,19 @@
+"""
+    A conan extension command entry point that thunks through to the cc-build module.
+"""
+import argparse
+
+from conan.api.conan_api import ConanAPI
+from conan.cli.command import conan_command
+
+@conan_command(group="Custom commands")
+def cci_build(conan_api: ConanAPI, parser: argparse.ArgumentParser, *args):
+    """
+        Build Conan Center Index packages using a custom utility pipeline.
+
+        Run the following to install/use this command:
+            > conan config install .
+            > conan cci-build --help
+    """
+    from cci_build.main import cci_build_command
+    return cci_build_command(conan_api, parser, *args)

conan_cci_build-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

conan_cci_build-0.1.0/setup.py

@@ -0,0 +1,30 @@
+"""
+    Trivial setup.py to package for publishing the module to pypi.
+"""
+from setuptools import setup, find_packages
+
+setup(
+    name="conan-cci-build",
+    version="0.1.0",
+    package_dir={
+        "": "src",
+        "cci_build_extensions": "extensions",
+    },
+    packages=find_packages(where="src") + [
+        "cci_build_extensions",
+        "cci_build_extensions.commands",
+    ],
+    python_requires=">=3.13",
+    install_requires=[
+        "conan>=2.25,<3.0",
+        "packaging>=26.2",
+    ],
+    package_data={
+        "cci_build_extensions.commands": ["cmd_cci_build.py"],
+    },
+    entry_points={
+        "console_scripts": [
+            "conan-cci-build-install = cci_build.installer:main",
+        ],
+    },
+)

conan_cci_build-0.1.0/src/cci_build/conan_centre_index.py

@@ -0,0 +1,108 @@
+"""
+    CCI Utilities
+"""
+import yaml
+from packaging.version import parse as parse_version
+from pathlib import Path
+from typing import Optional, Tuple
+
+from cci_build.error.exception import RecipeNotFoundError
+from cci_build.model.cci.conandata.types import ConanDataLayout
+from cci_build.model.cci.config.types import Config, VersionInfo
+
+
+def make_cci_recipie_package_config_filename(recipe_dir: Path) -> Path:
+    """
+        Make the path to the 'config.yml' for a package in a CCI
+    """
+    return recipe_dir / "config.yml"
+
+
+def make_cci_recipie_package_conanfile_filename(conanfile_folder_name, recipe_dir: Path) -> Path:
+    """
+        Make the path to the 'conanfile.py' for a package in a CCI
+    """
+    return recipe_dir / conanfile_folder_name / "conanfile.py"
+
+
+def make_cci_recipie_package_conandata_filename(conanfile_folder_name, recipe_dir: Path) -> Path:
+    """
+        Make the path to the 'conandata.yml' for a package in a CCI
+    """
+    return recipe_dir / conanfile_folder_name / "conandata.yml"
+
+
+def make_cci_recipe_package_path(cci_root: Path, package_name: str) -> Path:
+    return Path(cci_root) / "recipes" / package_name
+
+
+def read_package_config_yaml(config_path: Path) -> Config:
+    with open(config_path, "r", encoding="utf-8") as f:
+        config_data = yaml.safe_load(f)
+    return config_data
+
+
+def read_conandata_yaml(config_path: Path) -> ConanDataLayout:
+    with open(config_path, "r", encoding="utf-8") as f:
+        config_data = yaml.safe_load(f)
+        if config_data.get("sources"):
+            return config_data
+    return None
+
+
+def find_cci_conanfile(cci_root: Path, package_name: str, version: Optional[str]) -> Tuple[str, Path]:
+    """
+        Finds the exact conanfile.py path for a given package version
+        based on standard Conan Center Index (CCI) layout specifications.
+
+        :argument cci_root: The root directory of the local copy of a CCI.
+        :argument package_name: The name of the package to find.
+        :argument version: An optional version of the package to find, otherwise None will be translated to latest.
+
+        Return the conanfile.py path and the exact version to be built.
+    """
+    recipe_dir = make_cci_recipe_package_path(cci_root, package_name)
+    config_path = make_cci_recipie_package_config_filename(recipe_dir)
+
+    if config_path.exists():
+        config_data = read_package_config_yaml(config_path)
+
+        # Standard CCI layout groups everything under the 'versions' node
+        v, info = find_config_version(config_data.get("versions", {}), version)
+        if v and info and "folder" in info:
+
+            # Pull the targeted folder (frequently 'all', or specific folders like '1.x.x')
+            conanfile_folder_name = info.get("folder")
+            conanfile_path = make_cci_recipie_package_conanfile_filename(conanfile_folder_name, recipe_dir)
+            if conanfile_path.exists():
+
+                conandata_path = make_cci_recipie_package_conandata_filename(conanfile_folder_name, recipe_dir)
+                if conandata_path.exists():
+
+                    conandata = read_conandata_yaml(conandata_path)
+                    if conandata:
+                        return v, conanfile_path
+                    raise FileNotFoundError(f"Package '{package_name}/{v}' not found in conandata")
+                raise FileNotFoundError(f"Expected conandata.yml missing at: {conandata_path}")
+            raise FileNotFoundError(f"Expected conanfile.py missing at: {conanfile_path}")
+        raise RecipeNotFoundError(f"Recipe '{package_name}/{version if not None else 'latest'}' not found config.yml.")
+    raise RecipeNotFoundError(f"Package '{package_name}' or its config.yml not found in CCI path.")
+
+
+def find_config_version(
+        versions: dict[str, VersionInfo],
+        version: Optional[str]) -> Tuple[Optional[str], Optional[VersionInfo]]:
+    """
+        Given a `config.yml` set of versions available, select the version information
+        for that version. If no version is specified, then select the latest/newest version.
+
+        Use standard PEP 440 version parsing rules to compare version numbers.
+
+        return A valid ConanCentreVersionInfo or None if there is no matching version
+    """
+    if version:
+        specific_version = versions.get(version)
+        return (version, specific_version) if specific_version else (None, None,)
+    else:
+        max_version = max(versions.keys(), key=parse_version)
+        return (max_version, versions.get(max_version),) if max_version else (None, None,)

conan_cci_build-0.1.0/src/cci_build/conan_client.py

@@ -0,0 +1,59 @@
+"""
+    Wrap the ConanAPI
+"""
+from pathlib import Path
+from typing import Iterable
+
+from conan.api.conan_api import ConanAPI
+from conan.api.model import Remote, ListPattern
+from conan.internal.errors import NotFoundException
+
+from cci_build.error.exception import ConanAdapterError
+
+
+class ConanClient:
+    """
+        Thin wrapper over Conan 2 public API.
+    """
+
+    def __init__(self, api: ConanAPI) -> None:
+        self.api = api
+
+    def binary_exists(self, ref: ListPattern, remote: Remote) -> bool:
+        """
+            Uses Conan list against remote.
+        """
+
+        try:
+            result = self.api.list.select(ref, remote=remote)
+            return bool(result)
+        except NotFoundException:
+            return False
+
+    def create(self, recipe: Path, host: str, build: str) -> list[str]:
+        """
+            Executes in-process create using Conan API.
+        """
+
+        try:
+            graph = self.api.graph.load_graph(
+                path=str(recipe),
+                name=None,
+                version=None,
+                args=[f"-pr:h={host}", f"-pr:b={build}", "--build=missing"],
+            )
+
+            self.api.graph.analyze_binaries(graph)
+            self.api.graph.build(graph)
+
+            return [str(node.ref) for node in graph.nodes.values() if node.binary_package]
+
+        except Exception as e:
+            raise ConanAdapterError(f"Create failed: {e}")
+
+    def upload(self, refs: Iterable[str], remote: str) -> None:
+        try:
+            for ref in refs:
+                self.api.upload.upload_full(ref, remote=remote, only_recipe=False, only_package=True)
+        except Exception as e:
+            raise ConanAdapterError(f"Upload failed: {e}")

conan_cci_build-0.1.0/src/cci_build/installer.py

@@ -0,0 +1,54 @@
+"""
+    A script to install the cci-build command into Conan.
+"""
+import logging
+import os
+import shutil
+from importlib.resources import files, as_file
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+def get_conan_home() -> Path:
+    """
+        Resolve Conan 2 home directory.
+
+        This is the root directory where Conan stores:
+            - cache
+            - extensions
+            - configuration
+            - remotes
+
+        Resolution order:
+            1. CONAN_HOME environment variable (if set)
+            2. Default platform-specific location (~/.conan2)
+
+        Returns:
+            Path to Conan home directory.
+    """
+
+    # 1. Explicit override (highest priority)
+    env_home = os.environ.get("CONAN_HOME")
+    if env_home:
+        return Path(env_home).expanduser().resolve()
+
+    # 2. Default Conan 2 home directory
+    # Conan 2 standard default is ~/.conan2 unless overridden
+    return Path.home() / ".conan2"
+
+
+
+def main():
+    """
+       Entry
+    """
+    conan_home = get_conan_home()
+    target_dir = conan_home / "extensions" / "commands"
+    target_dir.mkdir(parents=True, exist_ok=True)
+    destination = target_dir / "cmd_cci_build.py"
+
+    resource = files("cci_build_extensions.commands").joinpath("cmd_cci_build.py")
+    with as_file(resource) as src:
+        shutil.copyfile(src, destination)
+
+    log.info(f"Installed Conan extension to: {destination}")

conan_cci_build-0.1.0/src/cci_build/main.py

@@ -0,0 +1,39 @@
+"""
+    Entrypoint for the cci-build (called from the conan extension command)
+"""
+from pathlib import Path
+
+from conan.api.conan_api import ConanAPI
+from conan.api.output import ConanOutput
+
+from cci_build.model.context import Context
+from cci_build.workflow import Workflow
+
+
+def cci_build_command(_conan_api: ConanAPI, parser, *args):
+    """
+        Build Conan Center Index packages using a custom utility pipeline.
+    """
+    # Conan provides its own pre-configured argparse instance via 'parser'
+    parser.add_argument("--cci-root", required=True, help="Path to the CCI root directory.")
+    parser.add_argument("--remote", required=True, help="Conan remote target.")
+    parser.add_argument("--host-profile", required=True, help="Host profile name or path.")
+    parser.add_argument("--build-profile", required=True, help="Build profile name or path.")
+    parser.add_argument("file", help="The packages file to process.")
+
+    # Parse the arguments forwarded from Conan's command line interface
+    parsed_args = parser.parse_args(*args)
+
+    # Initialize your existing Context object
+    config = Context(
+        cci_root=Path(parsed_args.cci_root),
+        remote=parsed_args.remote,
+        host_profile=parsed_args.host_profile,
+        build_profile=parsed_args.build_profile,
+        packages_filename=parsed_args.file,
+        channel=None,
+        user=None
+    )
+
+    workflow = Workflow(ConanAPI(), ConanOutput())
+    workflow.run(config)

conan_cci_build-0.1.0/src/cci_build/model/context.py

@@ -0,0 +1,29 @@
+"""
+    An immutable POCO to store program configuration
+"""
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class Context:
+    """
+        A top level state to hold command line arguments and program state.
+    """
+
+    cci_root: Path
+    """ A filesystem Path to the root of the CCI project """
+
+    remote: str
+    """ The name of a configured (and authenticated) of a jFrog Artifactory package repository to use"""
+
+    build_profile: str
+    """ The profile used for building the package """
+
+    host_profile: str
+
+    packages_filename: str
+
+    channel: Optional[str]
+    user: Optional[str]

conan_cci_build-0.1.0/src/cci_build/model/settings/types.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, field
+from typing import Optional, List
+
+
+@dataclass(frozen=True)
+class PackageRef:
+    """
+        A reference to a package to be built.
+    """
+    name: str
+    """ the name of the package to be built"""
+    version: Optional[str] = None
+    """ the version of the package to build """
+
+
+@dataclass(frozen=True)
+class ProfileRule:
+    """ A rule to determine whether a profile should be included in a build """
+    include: bool
+    pattern: str
+
+
+@dataclass(frozen=True)
+class PackageEntry(PackageRef):
+    """ A description of a single package to build, that will be uploaded to the Conan jFrog Artifactory repository """
+
+    profiles: List[ProfileRule] = field(default_factory=list)
+    """ The list of profiles that this package should be built for """

conan_cci_build-0.1.0/src/cci_build/package_parser.py

@@ -0,0 +1,91 @@
+"""
+    Parse 'package.txt' files which have a list of packages and optionally a version.
+"""
+import re
+from io import TextIOWrapper
+from pathlib import Path
+from typing import List, Optional
+
+from .error.exception import PackageFileError
+from cci_build.model.settings.types import PackageEntry, ProfileRule
+
+# LINE = re.compile(r"^\s*([a-zA-Z0-9_.+-]+/[a-zA-Z0-9_.+-]+)(?:\s*\[(.+)\])?\s*$")
+LINE_REGEX = re.compile(
+    r"""
+    ^
+    
+    (?: 
+        \s*                          # Ignore leading whitespace
+    
+        (?P<name> [a-zA-Z0-9_.+-]+ )
+        
+        # An optional version
+        (?: \s* / \s* (?P<version>[\w.+-]+ ) )?
+    
+        \s*
+        (?:
+            (?: p | profiles ) = 
+            (?P<profiles> !? [\w.+*-]+ (?: , \s* !? [\w.+*-]+ )* )
+        )?
+
+    )?
+    \s*    # allow trailing whitespace
+    
+    
+    (?: \# .* )?  # ignore comments    
+    
+    $
+    """,
+    re.VERBOSE,
+)
+
+
+
+
+def parse_line(line: str) -> Optional[PackageEntry]:
+    """
+    """
+    m = LINE_REGEX.match(line)
+    if not m:
+        raise PackageFileError(f"Invalid line '{line}'")
+
+    name = m.group("name")
+    if name is not None:
+        version = m.group("version")
+        profiles = m.group("profiles").split(",") if m.group("profiles") else []
+
+        profile_rules = []
+        for r in [x.strip() for x in profiles]:
+            profile_rules.append(parse_profile_rule(r))
+
+        return PackageEntry(name=name, version=version, profiles=profile_rules)
+    return None
+
+
+def parse_profile_rule(rule_str: str) -> ProfileRule:
+    """
+
+    """
+    if not rule_str.startswith("!"):
+        return ProfileRule(include=True, pattern=rule_str)
+    else:
+        return ProfileRule(include=False, pattern=rule_str[1:])
+
+
+def parse_lines(stream: TextIOWrapper) -> List[PackageEntry]:
+    """
+        Parse a 'package.txt' from a stream.
+    """
+    return [
+        entry
+        for a_line in stream
+        if (entry := parse_line(a_line.strip())) is not None
+    ]
+
+
+def load_package_file(path: Path) -> List[PackageEntry]:
+    """
+        Parse a 'package.txt' from a filesystem based file.
+    """
+    with open(path) as f:
+        return parse_lines(f)

conan_cci_build-0.1.0/src/cci_build/profile_matcher.py

@@ -0,0 +1,33 @@
+from fnmatch import fnmatch
+from typing import List
+
+from cci_build.model.settings.types import ProfileRule, PackageEntry
+
+
+def include( pkg: PackageEntry, profile: str) -> bool:
+    return include_rules(pkg.profiles, profile)
+
+def include_rules(rules : List[ProfileRule], profile: str) -> bool:
+    """
+        Given a host profile, check if a given package should be built.
+
+        Rules:
+           - no listed profiles, means match all profiles
+           - an exclamation prefix on a rule excludes those profiles
+    """
+    if not rules:
+        # if no filter rules are provided, then the package is built for
+        # all profiles, so it is a match.
+        return True
+
+    # Find the first matching rule, or default to do not build
+    for rule in rules:
+        # check if the rule is a negative check (i.e. do not built this package).
+        #
+        if not rule.include:
+            if fnmatch(profile, rule.pattern):
+                return False # a positive match means that the package is not built
+        elif fnmatch(profile, rule.pattern):
+            return True # the rule positively matches the profile, so the package is built
+
+    return False

conan_cci_build-0.1.0/src/cci_build/workflow.py

@@ -0,0 +1,201 @@
+"""
+    Main workflow for building the packages.
+"""
+from pathlib import Path
+from typing import Tuple, List, Optional, Any
+
+from conan.api.conan_api import ConanAPI
+from conan.api.model import RecipeReference, Remote, ListPattern, PackagesList
+from conan.api.output import ConanOutput
+from conan.internal.errors import NotFoundException
+from conan.internal.graph.graph import DepsGraph, BINARY_BUILD
+from conan.internal.model.profile import Profile
+
+from cci_build.conan_centre_index import find_cci_conanfile
+from cci_build.conan_client import ConanClient
+from cci_build.error.exception import PackageFileError
+from cci_build.model.context import Context
+from cci_build.model.settings.types import PackageEntry
+from cci_build.package_parser import load_package_file
+from cci_build.profile_matcher import include_rules
+
+
+def make_revision(ref: RecipeReference) -> str:
+    """
+        Make a conan search revision based on a recipe reference.
+    """
+    pattern_str = f"{ref.name}/{ref.version if ref.version else '*'}"
+    return pattern_str + (f"@{ref.user}/{ref.channel}" if ref.user and ref.channel else "#*")
+
+
+def list_select(conan: ConanClient, search_pattern: ListPattern, remote: Optional[Remote]) -> bool:
+    """
+        Select a list of conan recipes.
+    """
+    try:
+        return conan.api.list.select(search_pattern, remote=remote)
+    except NotFoundException:
+        # Eat the exception (the specific error is not reported)
+        return False
+
+
+class Workflow:
+    """
+        Run a conan workflow to build all missing packages in a jFrog Artifactory repository.
+
+        see:
+           - https://docs.conan.io/2/reference/commands/graph/info.html
+           - https://docs.conan.io/2/reference/extensions/python_api/GraphAPI.html
+    """
+
+    def __init__(self, api: ConanAPI, logger: ConanOutput):
+        self.profile_build: Optional[Profile] = None
+        self.profile_host: Optional[Profile] = None
+        self.conan = ConanClient(api)
+        self.api = api
+        self.log = logger
+
+    def run(self, ctx: Context) -> None:
+        """
+            Perform a minimal build of one host (target) profile. The inputs
+            to the process are:
+               - the local package list configuration file
+               - a local filesystem copy of a CCI
+
+            The state is help in:
+               - a jFrog Artifactory repository
+
+            The pre-requisites are:
+               - this script
+               - conan installed and configured with profiles
+               - a conan remote configured and authenticated to the Artifactory repository
+
+        """
+        self.profile_host = self.api.profiles.get_profile([ctx.host_profile])
+        if self.profile_host is None:
+            raise ModuleNotFoundError(f"No profile found for '{ctx.host_profile}'")
+
+        self.profile_build = self.api.profiles.get_profile(
+            [ctx.build_profile]) if ctx.build_profile else self.api.profiles.get_default_build()
+        if self.profile_build is None:
+            raise ModuleNotFoundError(f"No profile found for '{ctx.build_profile}'")
+
+        # Load the configuration file which describes packages in the local CCI that need to be built
+        pkgs = load_package_file(Path(ctx.packages_filename))
+        self.log.info(f"Found {len(pkgs)} packages")
+        for pkg in pkgs:
+            self.log.info(f"Processing package '{pkg.name}:{pkg.version if pkg.version else "*"}'")
+
+        if ctx.remote:
+            remote = self.api.remotes.get(ctx.remote)
+            remotes = [remote] if remote else []
+
+            #
+            # Using the local CCI, map the desired packages to the exact recipe and version to be built
+            # and filter which packages should be included based on the profile filter criteria.
+            #
+            refs = self.filter_package_names(ctx, pkgs)
+
+            self.create_remote_recipe(refs, ctx, remote)
+            graph = self.build_package_graph(refs, ctx, remotes)
+            self.install_and_upload_missing(graph, remote, remotes)
+        else:
+            raise NotFoundException("No remote configured")
+
+
+    def filter_package_names(self, ctx: Context, pkgs: list[PackageEntry]) -> List[Tuple[RecipeReference, Path]]:
+        """
+            Given the list of packages to build, filter them based on the host profile.
+        """
+        refs = []
+        for pkg in pkgs:
+
+            # Check if the profile rules in the configuration file allow this 'host' profile
+            if include_rules(pkg.profiles, ctx.host_profile):
+
+                # Given the package/profile/version needs to be present, resolve the package
+                # and the version in the CCI.
+                version, conanfile = find_cci_conanfile(ctx.cci_root, pkg.name, pkg.version)
+                if version:
+                    ref = RecipeReference(name=pkg.name, version=version, user=ctx.user, channel=ctx.channel)
+                    refs.append((ref, conanfile,))
+                    self.log.info(f"Found CCI reference '{ref.name}:{ref.version}'")
+                else:
+                    self.log.error("Can not determine version for package '%s'", pkg.name)
+                    raise PackageFileError()
+            else:
+                self.log.info("Skipping package '%s' as it does not match the host profile", pkg.name)
+        return refs
+
+    def build_package_graph(
+            self, packages: List[Tuple[RecipeReference, Path]], context: Context, remotes: List[Remote]) -> DepsGraph:
+        """
+            For each of the packages, add it to the package graph.
+        """
+        requires = [ref for ref, _ in packages]
+        deps_graph = self.api.graph.load_graph_requires(
+            requires,
+            tool_requires=None,
+            profile_host=self.profile_host, profile_build=self.profile_build,
+            lockfile=None,
+            remotes=remotes,
+            update=True)
+        # Stop now if there was an error
+        deps_graph.report_graph_error()
+
+        # mark only remote-missing binaries for build (replaces make_build_graph/make_one)
+        self.api.graph.analyze_binaries(deps_graph, build_mode=["missing"], remotes=remotes, update=True)
+
+        return deps_graph
+
+    def create_remote_recipe(self, refs: List[Tuple[RecipeReference, Path]], context: Context, remote: Remote):
+        """
+            Upload all recipes that don't exist at the remote.
+
+            Note: this creates a recipe in the remote, but none of the binaries.
+        """
+        for ref, conanfile_path in refs:
+            search_pattern = ListPattern(make_revision(ref))
+            self.log.info(f'Searching for recipe "{make_revision(ref)}"')
+            remote_check = list_select(self.conan, search_pattern, remote=remote)
+            if not remote_check:
+
+                local_recipes = list_select(self.conan, search_pattern, remote=None)
+                if not local_recipes:
+                    self.log.info(f'Exporting recipe "{str(ref)}"')
+                    clean_conanfile_path = str(Path(conanfile_path).resolve().absolute())
+
+                    exported_ref, conanfile_obj = self.conan.api.export.export(
+                        path=clean_conanfile_path,
+                        name=ref.name,
+                        version=ref.version,
+                        user=ref.user,
+                        channel=ref.channel)
+
+                self.log.info(f'Upload recipe "{str(ref)}"')
+                self.conan.api.upload.upload_full(
+                    package_list=local_recipes,
+                    remote=remote,
+                    enabled_remotes=[remote],
+                    dry_run=False)
+            else:
+                self.log.info(f'Recipe "{str(ref)}" present at remote "{remote.name}"')
+
+
+    def install_and_upload_missing(self, graph: DepsGraph, remote: Remote, remotes: list[Remote] | list[Any]):
+        """
+            Locally build those binaries (for the given profile) that are missing at the remote.
+        """
+        install_error = self.api.install.install_binaries(deps_graph=graph, remotes=remotes, return_install_error=True)
+
+        built = PackagesList()
+        for node in graph.nodes:
+            # a completed build has a package revision; a failed one does not
+            if node.binary == BINARY_BUILD and node.pref.revision:
+                built.add_ref(node.ref)
+                built.add_pref(node.pref)
+        if built:
+            self.api.upload.upload_full(
+                built, remote, enabled_remotes=remotes, check_integrity=True, dry_run=False)
+        if install_error is not None:
+            raise install_error

conan_cci_build-0.1.0/src/conan_cci_build.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: conan-cci-build
+Version: 0.1.0
+Requires-Python: >=3.13
+License-File: LICENSE
+Requires-Dist: conan<3.0,>=2.25
+Requires-Dist: packaging>=26.2
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python

conan_cci_build-0.1.0/src/conan_cci_build.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+setup.py
+extensions/commands/cmd_cci_build.py
+src/cci_build/__init__.py
+src/cci_build/conan_centre_index.py
+src/cci_build/conan_client.py
+src/cci_build/installer.py
+src/cci_build/main.py
+src/cci_build/package_parser.py
+src/cci_build/profile_matcher.py
+src/cci_build/workflow.py
+src/cci_build/model/__init__.py
+src/cci_build/model/context.py
+src/cci_build/model/settings/__init__.py
+src/cci_build/model/settings/types.py
+src/conan_cci_build.egg-info/PKG-INFO
+src/conan_cci_build.egg-info/SOURCES.txt
+src/conan_cci_build.egg-info/dependency_links.txt
+src/conan_cci_build.egg-info/entry_points.txt
+src/conan_cci_build.egg-info/requires.txt
+src/conan_cci_build.egg-info/top_level.txt

conan_cci_build-0.1.0/src/conan_cci_build.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

conan_cci_build-0.1.0/src/conan_cci_build.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+conan-cci-build-install = cci_build.installer:main

conan_cci_build-0.1.0/src/conan_cci_build.egg-info/requires.txt

@@ -0,0 +1,2 @@
+conan<3.0,>=2.25
+packaging>=26.2

conan_cci_build-0.1.0/src/conan_cci_build.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+cci_build
+cci_build_extensions