conan 2.11.0__tar.gz → 2.12.1__tar.gz

{conan-2.11.0/conan.egg-info → conan-2.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan
-Version: 2.11.0
+Version: 2.12.1
 Summary: Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD
@@ -25,6 +25,8 @@ Description: <picture>
         - Docs: https://docs.conan.io
         - Slack: https://cpplang.slack.com (#conan channel. Please, click [here](https://join.slack.com/t/cpplang/shared_invite/zt-1snzdn6rp-rOUxF3166oz1_11Tr5H~xg) to get an invitation)
         - Twitter: https://twitter.com/conan_io
+        - Blog: https://blog.conan.io
+        - Security reports: https://jfrog.com/trust/report-vulnerability
         
         
         Conan is a package manager for C and C++ developers:

{conan-2.11.0 → conan-2.12.1}/README.md

@@ -14,6 +14,8 @@ Decentralized, open-source (MIT), C/C++ package manager.
 - Docs: https://docs.conan.io
 - Slack: https://cpplang.slack.com (#conan channel. Please, click [here](https://join.slack.com/t/cpplang/shared_invite/zt-1snzdn6rp-rOUxF3166oz1_11Tr5H~xg) to get an invitation)
 - Twitter: https://twitter.com/conan_io
+- Blog: https://blog.conan.io
+- Security reports: https://jfrog.com/trust/report-vulnerability
 
 
 Conan is a package manager for C and C++ developers:

conan-2.12.1/conan/__init__.py

@@ -0,0 +1,5 @@
+from conan.internal.model.conan_file import ConanFile
+from conan.internal.model.version import Version
+
+__version__ = '2.12.1'
+conan_version = Version(__version__)

{conan-2.11.0 → conan-2.12.1}/conan/api/conan_api.py

@@ -6,7 +6,6 @@ from conan.api.subapi.command import CommandAPI
 from conan.api.subapi.local import LocalAPI
 from conan.api.subapi.lockfile import LockfileAPI
 from conan.api.subapi.workspace import WorkspaceAPI
-from conan import conan_version
 from conan.api.subapi.config import ConfigAPI
 from conan.api.subapi.download import DownloadAPI
 from conan.api.subapi.export import ExportAPI
@@ -19,13 +18,18 @@ from conan.api.subapi.remotes import RemotesAPI
 from conan.api.subapi.remove import RemoveAPI
 from conan.api.subapi.search import SearchAPI
 from conan.api.subapi.upload import UploadAPI
-from conans.client.migrations import ClientMigrator
 from conan.errors import ConanException
 from conan.internal.paths import get_conan_user_home
-from conans.model.version_range import validate_conan_version
+from conans.client.migrations import ClientMigrator
+from conan.internal.model.version_range import validate_conan_version
 
 
 class ConanAPI:
+    """
+    This is the main object to interact with the Conan API. It provides all the subapis to work with
+    recipes, packages, remotes, etc., which are exposed as attributes of this class, and should
+    not be created directly.
+    """
     def __init__(self, cache_folder=None):
 
         version = sys.version_info
@@ -36,14 +40,14 @@ class ConanAPI:
         self.workspace = WorkspaceAPI(self)
         self.cache_folder = self.workspace.home_folder() or cache_folder or get_conan_user_home()
         self.home_folder = self.cache_folder  # Lets call it home, deprecate "cache"
+        self.migrate()
 
-        # Migration system
-        migrator = ClientMigrator(self.cache_folder, conan_version)
-        migrator.migrate()
+        # This API is depended upon by the subsequent ones, it should be initialized first
+        self.config = ConfigAPI(self)
 
-        self.command = CommandAPI(self)
         self.remotes = RemotesAPI(self)
-        # Search recipes by wildcard and packages filtering by configuracion
+        self.command = CommandAPI(self)
+        # Search recipes by wildcard and packages filtering by configuration
         self.search = SearchAPI(self)
         # Get latest refs and list refs of recipes and packages
         self.list = ListAPI(self)
@@ -52,7 +56,6 @@ class ConanAPI:
         self.graph = GraphAPI(self)
         self.export = ExportAPI(self)
         self.remove = RemoveAPI(self)
-        self.config = ConfigAPI(self)
         self.new = NewAPI(self)
         self.upload = UploadAPI(self)
         self.download = DownloadAPI(self)
@@ -60,6 +63,27 @@ class ConanAPI:
         self.lockfile = LockfileAPI(self)
         self.local = LocalAPI(self)
 
-        required_range_new = self.config.global_conf.get("core:required_conan_version")
-        if required_range_new:
-            validate_conan_version(required_range_new)
+        _check_conan_version(self)
+
+    def reinit(self):
+        """
+        Reinitialize the Conan API. This is useful when the configuration changes.
+        """
+        self.config.reinit()
+        self.remotes.reinit()
+        self.local.reinit()
+
+        _check_conan_version(self)
+
+    def migrate(self):
+        # Migration system
+        # TODO: A prettier refactoring of migrators would be nice
+        from conan import conan_version
+        migrator = ClientMigrator(self.cache_folder, conan_version)
+        migrator.migrate()
+
+
+def _check_conan_version(conan_api):
+    required_range_new = conan_api.config.global_conf.get("core:required_conan_version")
+    if required_range_new:
+        validate_conan_version(required_range_new)

conan-2.12.1/conan/api/model/__init__.py

@@ -0,0 +1,3 @@
+from conan.api.model.remote import Remote, LOCAL_RECIPES_INDEX
+from conan.api.model.refs import RecipeReference, PkgReference
+from conan.api.model.list import PackagesList, MultiPackagesList, ListPattern

conan-2.11.0/conan/api/model.py → conan-2.12.1/conan/api/model/list.py

@@ -3,47 +3,13 @@ import json
 import os
 from json import JSONDecodeError
 
+from conan.errors import ConanException
+from conan.internal.errors import NotFoundException
+from conan.api.model import RecipeReference, PkgReference
+from conan.internal.model.version_range import VersionRange
 from conans.client.graph.graph import RECIPE_EDITABLE, RECIPE_CONSUMER, RECIPE_PLATFORM, \
     RECIPE_VIRTUAL, BINARY_SKIP, BINARY_MISSING, BINARY_INVALID
-from conan.internal.errors import NotFoundException
-from conan.errors import ConanException
-from conans.model.package_ref import PkgReference
-from conans.model.recipe_ref import RecipeReference
 from conans.util.files import load
-from conans.model.version_range import VersionRange
-
-LOCAL_RECIPES_INDEX = "local-recipes-index"
-
-
-class Remote:
-
-    def __init__(self, name, url, verify_ssl=True, disabled=False, allowed_packages=None,
-                 remote_type=None):
-        self.name = name  # Read only, is the key
-        self.url = url
-        self.verify_ssl = verify_ssl
-        self.disabled = disabled
-        self.allowed_packages = allowed_packages
-        self.remote_type = remote_type
-
-    def __eq__(self, other):
-        if other is None:
-            return False
-        return (self.name == other.name and self.url == other.url and
-                self.verify_ssl == other.verify_ssl and self.disabled == other.disabled)
-
-    def __str__(self):
-        allowed_msg = ""
-        if self.allowed_packages:
-            allowed_msg = ", Allowed packages: {}".format(", ".join(self.allowed_packages))
-        if self.remote_type == LOCAL_RECIPES_INDEX:
-            return "{}: {} [{}, Enabled: {}{}]".format(self.name, self.url, LOCAL_RECIPES_INDEX,
-                                                       not self.disabled, allowed_msg)
-        return "{}: {} [Verify SSL: {}, Enabled: {}{}]".format(self.name, self.url, self.verify_ssl,
-                                                               not self.disabled, allowed_msg)
-
-    def __repr__(self):
-        return str(self)
 
 
 class MultiPackagesList:

conan-2.11.0/conans/model/recipe_ref.py → conan-2.12.1/conan/api/model/refs.py

@@ -4,7 +4,7 @@ import re
 from functools import total_ordering
 
 from conan.errors import ConanException
-from conans.model.version import Version
+from conan.internal.model.version import Version
 from conans.util.dates import timestamp_to_str
 
 
@@ -205,8 +205,102 @@ class RecipeReference:
                 return True
 
 
-def ref_matches(ref, pattern, is_consumer):
-    if not ref or not str(ref):
-        assert is_consumer
-        ref = RecipeReference.loads("*/*")  # FIXME: ugly
-    return ref.matches(pattern, is_consumer=is_consumer)
+class PkgReference:
+
+    def __init__(self, ref=None, package_id=None, revision=None, timestamp=None):
+        self.ref = ref
+        self.package_id = package_id
+        self.revision = revision
+        self.timestamp = timestamp  # float, Unix seconds UTC
+
+    def __repr__(self):
+        """ long repr like pkg/0.1@user/channel#rrev%timestamp """
+        if self.ref is None:
+            return ""
+        result = repr(self.ref)
+        if self.package_id:
+            result += ":{}".format(self.package_id)
+        if self.revision is not None:
+            result += "#{}".format(self.revision)
+        if self.timestamp is not None:
+            result += "%{}".format(self.timestamp)
+        return result
+
+    def repr_notime(self):
+        if self.ref is None:
+            return ""
+        result = self.ref.repr_notime()
+        if self.package_id:
+            result += ":{}".format(self.package_id)
+        if self.revision is not None:
+            result += "#{}".format(self.revision)
+        return result
+
+    def repr_reduced(self):
+        if self.ref is None:
+            return ""
+        result = self.ref.repr_reduced()
+        if self.package_id:
+            result += ":{}".format(self.package_id[0:4])
+        if self.revision is not None:
+            result += "#{}".format(self.revision[0:4])
+        return result
+
+    def repr_humantime(self):
+        result = self.repr_notime()
+        assert self.timestamp
+        result += " ({})".format(timestamp_to_str(self.timestamp))
+        return result
+
+    def __str__(self):
+        """ shorter representation, excluding the revision and timestamp """
+        if self.ref is None:
+            return ""
+        result = str(self.ref)
+        if self.package_id:
+            result += ":{}".format(self.package_id)
+        return result
+
+    def __lt__(self, ref):
+        # The timestamp goes before the revision for ordering revisions chronologically
+        raise Exception("WHO IS COMPARING PACKAGE REFERENCES?")
+        # return (self.name, self.version, self.user, self.channel, self.timestamp, self.revision) \
+        #       < (ref.name, ref.version, ref.user, ref.channel, ref._timestamp, ref.revision)
+
+    def __eq__(self, other):
+        # TODO: In case of equality, should it use the revision and timestamp?
+        # Used:
+        #    at "graph_binaries" to check: cache_latest_prev != pref
+        #    at "installer" to check: if pkg_layout.reference != pref (probably just optimization?)
+        #    at "revisions_test"
+        return self.ref == other.ref and self.package_id == other.package_id and \
+               self.revision == other.revision
+
+    def __hash__(self):
+        # Used in dicts of PkgReferences as keys like the cached nodes in the graph binaries
+        return hash((self.ref, self.package_id, self.revision))
+
+    @staticmethod
+    def loads(pkg_ref):  # TODO: change this default to validate only on end points
+        try:
+            tokens = pkg_ref.split(":", 1)
+            assert len(tokens) == 2
+            ref, pkg_id = tokens
+
+            ref = RecipeReference.loads(ref)
+
+            # timestamp
+            tokens = pkg_id.rsplit("%", 1)
+            text = tokens[0]
+            timestamp = float(tokens[1]) if len(tokens) == 2 else None
+
+            # revision
+            tokens = text.split("#", 1)
+            package_id = tokens[0]
+            revision = tokens[1] if len(tokens) == 2 else None
+
+            return PkgReference(ref, package_id, revision, timestamp)
+        except Exception:
+            raise ConanException(
+                f"{pkg_ref} is not a valid package reference, provide a reference"
+                f" in the form name/version[@user/channel:package_id]")

conan-2.12.1/conan/api/model/remote.py

@@ -0,0 +1,39 @@
+LOCAL_RECIPES_INDEX = "local-recipes-index"
+
+
+class Remote:
+    """
+    The ``Remote`` class represents a remote registry of packages. It's a read-only opaque object that
+    should not be created directly, but obtained from the relevant ``RemotesAPI`` subapi methods.
+    """
+    def __init__(self, name, url, verify_ssl=True, disabled=False, allowed_packages=None,
+                 remote_type=None):
+        self.name = name  # Read only, is the key
+        self.url = url
+        self.verify_ssl = verify_ssl
+        self.disabled = disabled
+        self.allowed_packages = allowed_packages
+        self.remote_type = remote_type
+        self._caching = {}
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+        return (self.name == other.name and self.url == other.url and
+                self.verify_ssl == other.verify_ssl and self.disabled == other.disabled)
+
+    def __str__(self):
+        allowed_msg = ""
+        if self.allowed_packages:
+            allowed_msg = ", Allowed packages: {}".format(", ".join(self.allowed_packages))
+        if self.remote_type == LOCAL_RECIPES_INDEX:
+            return "{}: {} [{}, Enabled: {}{}]".format(self.name, self.url, LOCAL_RECIPES_INDEX,
+                                                       not self.disabled, allowed_msg)
+        return "{}: {} [Verify SSL: {}, Enabled: {}{}]".format(self.name, self.url, self.verify_ssl,
+                                                               not self.disabled, allowed_msg)
+
+    def __repr__(self):
+        return str(self)
+
+    def invalidate_cache(self):
+        self._caching = {}

{conan-2.11.0 → conan-2.12.1}/conan/api/output.py

@@ -212,12 +212,12 @@ class ConanOutput:
 
     def trace(self, msg):
         if self._conan_output_level <= LEVEL_TRACE:
-            self._write_message(msg, fg=Color.BRIGHT_WHITE)
+            self._write_message(msg, fg=Color.BLUE)
         return self
 
     def debug(self, msg):
         if self._conan_output_level <= LEVEL_DEBUG:
-            self._write_message(msg)
+            self._write_message(msg, fg=Color.MAGENTA)
         return self
 
     def verbose(self, msg, fg=None, bg=None):
@@ -294,10 +294,14 @@ def cli_out_write(data, fg=None, bg=None, endline="\n", indentation=0):
         sys.stdout.write(data)
     else:
         data = f"{' ' * indentation}{data}{endline}"
-        # https://github.com/conan-io/conan/issues/17245 avoid colorama crash and overhead
-        colorama.deinit()
-        sys.stdout.write(data)
-        colorama.reinit()
+        if sys.stdout.isatty():
+            # https://github.com/conan-io/conan/issues/17245 avoid colorama crash and overhead
+            # skip deinit/reinit if stdout is not a TTY to preserve redirected output to file
+            colorama.deinit()
+            sys.stdout.write(data)
+            colorama.reinit()
+        else:
+            sys.stdout.write(data)
 
 
 class TimedOutput:

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/cache.py

@@ -11,8 +11,8 @@ from conan.internal.cache.home_paths import HomePaths
 from conan.internal.cache.integrity_check import IntegrityChecker
 from conans.client.downloaders.download_cache import DownloadCache
 from conan.errors import ConanException
-from conans.model.package_ref import PkgReference
-from conans.model.recipe_ref import RecipeReference
+from conan.api.model import PkgReference
+from conan.api.model import RecipeReference
 from conans.util.dates import revision_timestamp_now
 from conans.util.files import rmdir, gzopen_without_timestamps, mkdir, remove
 

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/config.py

@@ -16,11 +16,11 @@ from conans.client.graph.graph import CONTEXT_HOST, RECIPE_VIRTUAL, Node
 from conans.client.graph.graph_builder import DepsGraphBuilder
 from conans.client.graph.profile_node_definer import consumer_definer
 from conan.errors import ConanException
-from conans.model.conf import ConfDefinition, BUILT_IN_CONFS
-from conans.model.pkg_type import PackageType
-from conans.model.recipe_ref import RecipeReference
-from conans.model.settings import Settings
-from conans.util.files import load, save
+from conan.internal.model.conf import ConfDefinition, BUILT_IN_CONFS, CORE_CONF_PATTERN
+from conan.internal.model.pkg_type import PackageType
+from conan.api.model import RecipeReference
+from conan.internal.model.settings import Settings
+from conans.util.files import load, save, rmdir, remove
 
 
 class ConfigAPI:
@@ -28,6 +28,7 @@ class ConfigAPI:
     def __init__(self, conan_api):
         self.conan_api = conan_api
         self._new_config = None
+        self._cli_core_confs = None
 
     def home(self):
         return self.conan_api.cache_folder
@@ -36,9 +37,11 @@ class ConfigAPI:
                 source_folder=None, target_folder=None):
         # TODO: We probably want to split this into git-folder-http cases?
         from conan.internal.api.config.config_installer import configuration_install
-        app = ConanApp(self.conan_api)
-        configuration_install(app, path_or_url, verify_ssl, config_type=config_type, args=args,
+        cache_folder = self.conan_api.cache_folder
+        requester = self.conan_api.remotes.requester
+        configuration_install(cache_folder, requester, path_or_url, verify_ssl, config_type=config_type, args=args,
                               source_folder=source_folder, target_folder=target_folder)
+        self.conan_api.reinit()
 
     def install_pkg(self, ref, lockfile=None, force=False, remotes=None, profile=None):
         ConanOutput().warning("The 'conan config install-pkg' is experimental",
@@ -90,13 +93,16 @@ class ConfigAPI:
                     return pkg.pref  # Already installed, we can skip repeating the install
 
         from conan.internal.api.config.config_installer import configuration_install
-        configuration_install(app, uri=pkg.conanfile.package_folder, verify_ssl=False,
+        cache_folder = self.conan_api.cache_folder
+        requester = self.conan_api.remotes.requester
+        configuration_install(cache_folder, requester, uri=pkg.conanfile.package_folder, verify_ssl=False,
                               config_type="dir", ignore=["conaninfo.txt", "conanmanifest.txt"])
         # We save the current package full reference in the file for future
         # And for ``package_id`` computation
         config_versions = {ref.split("/", 1)[0]: ref for ref in config_versions}
         config_versions[pkg.pref.ref.name] = pkg.pref.repr_notime()
         save(config_version_file, json.dumps({"config_version": list(config_versions.values())}))
+        self.conan_api.reinit()
         return pkg.pref
 
     def get(self, name, default=None, check_type=None):
@@ -111,11 +117,19 @@ class ConfigAPI:
         configuration defined with the new syntax as in profiles, this config will be composed
         to the profile ones and passed to the conanfiles.conf, which can be passed to collaborators
         """
+        # Lazy loading
         if self._new_config is None:
-            cache_folder = self.conan_api.cache_folder
-            self._new_config = self.load_config(cache_folder)
+            self._new_config = ConfDefinition()
+            self._populate_global_conf()
         return self._new_config
 
+    def _populate_global_conf(self):
+        cache_folder = self.conan_api.cache_folder
+        new_config = self.load_config(cache_folder)
+        self._new_config.update_conf_definition(new_config)
+        if self._cli_core_confs is not None:
+            self._new_config.update_conf_definition(self._cli_core_confs)
+
     @staticmethod
     def load_config(home_folder):
         # Do not document yet, keep it private
@@ -188,3 +202,35 @@ class ConfigAPI:
             appending_recursive_dict_update(settings, settings_user)
 
         return Settings(settings)
+
+    def clean(self):
+        contents = os.listdir(self.home())
+        packages_folder = self.global_conf.get("core.cache:storage_path") or os.path.join(self.home(), "p")
+        for content in contents:
+            content_path = os.path.join(self.home(), content)
+            if content_path == packages_folder:
+                continue
+            ConanOutput().debug(f"Removing {content_path}")
+            if os.path.isdir(content_path):
+                rmdir(content_path)
+            else:
+                remove(content_path)
+        self.conan_api.reinit()
+        # CHECK: This also generates a remotes.json that is not there after a conan profile show?
+        self.conan_api.migrate()
+
+    def set_core_confs(self, core_confs):
+        confs = ConfDefinition()
+        for c in core_confs:
+            if not CORE_CONF_PATTERN.match(c):
+                raise ConanException(f"Only core. values are allowed in --core-conf. Got {c}")
+        confs.loads("\n".join(core_confs))
+        confs.validate()
+        self._cli_core_confs = confs
+        # Last but not least, apply the new configuration
+        self.conan_api.reinit()
+
+    def reinit(self):
+        if self._new_config is not None:
+            self._new_config.clear()
+            self._populate_global_conf()

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/download.py

@@ -6,8 +6,8 @@ from conan.api.model import Remote, PackagesList
 from conan.api.output import ConanOutput
 from conan.internal.conan_app import ConanBasicApp
 from conan.errors import ConanException
-from conans.model.package_ref import PkgReference
-from conans.model.recipe_ref import RecipeReference
+from conan.api.model import PkgReference
+from conan.api.model import RecipeReference
 
 
 class DownloadAPI:

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/export.py

@@ -6,7 +6,7 @@ from conan.internal.api.export import cmd_export
 from conan.internal.methods import run_package_method
 from conans.client.graph.graph import BINARY_BUILD, RECIPE_INCACHE
 from conans.client.hook_manager import HookManager
-from conans.model.package_ref import PkgReference
+from conan.api.model import PkgReference
 from conans.util.files import mkdir
 
 

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/graph.py

@@ -1,12 +1,13 @@
 from conan.api.output import ConanOutput
-from conan.internal.conan_app import ConanApp
+from conan.internal.conan_app import ConanApp, ConanBasicApp
+from conan.internal.model.recipe_ref import ref_matches
 from conans.client.graph.graph import Node, RECIPE_CONSUMER, CONTEXT_HOST, RECIPE_VIRTUAL, \
-    CONTEXT_BUILD
+    CONTEXT_BUILD, BINARY_MISSING
 from conans.client.graph.graph_binaries import GraphBinariesAnalyzer
 from conans.client.graph.graph_builder import DepsGraphBuilder
 from conans.client.graph.profile_node_definer import initialize_conanfile_profile, consumer_definer
 from conan.errors import ConanException
-from conans.model.recipe_ref import RecipeReference
+from conan.api.model import RecipeReference
 
 
 class GraphAPI:
@@ -196,7 +197,18 @@ class GraphAPI:
         :param tested_graph: In case of a "test_package", the graph being tested
         """
         ConanOutput().title("Computing necessary packages")
-        conan_app = ConanApp(self.conan_api)
+        conan_app = ConanBasicApp(self.conan_api)
         binaries_analyzer = GraphBinariesAnalyzer(conan_app, self.conan_api.config.global_conf)
         binaries_analyzer.evaluate_graph(graph, build_mode, lockfile, remotes, update,
                                          build_modes_test, tested_graph)
+
+    @staticmethod
+    def find_first_missing_binary(graph, missing=None):
+        """ (Experimental) Given a dependency graph, will return the first node with a
+        missing binary package
+        """
+        for node in graph.ordered_iterate():
+            if ((not missing and node.binary == BINARY_MISSING)  # First missing binary or specified
+                    or (missing and ref_matches(node.ref, missing, is_consumer=None))):
+                return node.ref, node.conanfile.info
+        raise ConanException("There is no missing binary")

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/install.py

@@ -75,7 +75,7 @@ class InstallAPI:
             # Issue related: https://github.com/conan-io/conan/issues/16543
             base_folder = os.path.abspath(deploy_folder) if deploy_folder \
                 else conanfile.folders.base_build
-            do_deploys(self.conan_api, deps_graph, deploy, deploy_package, base_folder)
+            do_deploys(self.conan_api.home_folder, deps_graph, deploy, deploy_package, base_folder)
 
         final_generators = []
         # Don't use set for uniqueness because order matters
@@ -89,3 +89,7 @@ class InstallAPI:
         hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)
         write_generators(conanfile, hook_manager, self.conan_api.home_folder,
                          envs_generation=envs_generation)
+
+    def deploy(self, graph, deployer, deploy_package=None, deploy_folder=None):
+        return do_deploys(self.conan_api.home_folder, graph, deployer, deploy_package=deploy_package,
+                          deploy_folder=deploy_folder)

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/list.py

@@ -6,12 +6,13 @@ from conan.api.model import PackagesList
 from conan.api.output import ConanOutput, TimedOutput
 from conan.internal.api.list.query_parse import filter_package_configs
 from conan.internal.conan_app import ConanBasicApp
+from conan.internal.model.recipe_ref import ref_matches
 from conan.internal.paths import CONANINFO
 from conan.internal.errors import NotFoundException
 from conan.errors import ConanException
-from conans.model.info import load_binary_info
-from conans.model.package_ref import PkgReference
-from conans.model.recipe_ref import RecipeReference, ref_matches
+from conan.internal.model.info import load_binary_info
+from conan.api.model import PkgReference
+from conan.api.model import RecipeReference
 from conans.util.dates import timelimit
 from conans.util.files import load
 
@@ -224,6 +225,8 @@ class ListAPI:
         return select_bundle
 
     def explain_missing_binaries(self, ref, conaninfo, remotes):
+        """ (Experimental) Explain why a binary is missing in the cache
+        """
         ConanOutput().info(f"Missing binary: {ref}")
         ConanOutput().info(f"With conaninfo.txt (package_id):\n{conaninfo.dumps()}")
         conaninfo = load_binary_info(conaninfo.dumps())
@@ -391,10 +394,12 @@ def _get_cache_packages_binary_info(cache, prefs) -> Dict[PkgReference, dict]:
         # Read conaninfo
         info_path = os.path.join(pkg_layout.package(), CONANINFO)
         if not os.path.exists(info_path):
-            raise ConanException(f"Corrupted package '{pkg_layout.reference}' "
-                                 f"without conaninfo.txt in: {info_path}")
-        conan_info_content = load(info_path)
-        info = load_binary_info(conan_info_content)
+            ConanOutput().error(f"Corrupted package '{pkg_layout.reference}' "
+                                f"without conaninfo.txt in: {info_path}")
+            info = {}
+        else:
+            conan_info_content = load(info_path)
+            info = load_binary_info(conan_info_content)
         pref = pkg_layout.reference
         # The key shoudln't have the latest package revision, we are asking for package configs
         pref.revision = None

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/local.py

@@ -10,7 +10,7 @@ from conans.client.graph.profile_node_definer import initialize_conanfile_profil
 from conan.internal.errors import conanfile_exception_formatter
 from conan.errors import ConanException
 from conans.client.hook_manager import HookManager
-from conans.model.recipe_ref import RecipeReference
+from conan.api.model import RecipeReference
 from conans.util.files import chdir
 
 
@@ -118,3 +118,6 @@ class LocalAPI:
         conanfile = app.loader.load_named(conanfile_path, name=name, version=version, user=user,
                                           channel=channel, remotes=remotes, graph_lock=lockfile)
         return conanfile
+
+    def reinit(self):
+        self.editable_packages = EditablePackages(self._conan_api.home_folder)

{conan-2.11.0 → conan-2.12.1}/conan/api/subapi/lockfile.py

@@ -4,7 +4,7 @@ from conan.api.output import ConanOutput
 from conan.cli import make_abs_path
 from conans.client.graph.graph import Overrides
 from conan.errors import ConanException
-from conans.model.graph_lock import Lockfile, LOCKFILE
+from conan.internal.model.lockfile import Lockfile, LOCKFILE
 
 
 class LockfileAPI:
@@ -80,6 +80,15 @@ class LockfileAPI:
             lockfile.update_lock(graph, lock_packages)
         return lockfile
 
+    @staticmethod
+    def merge_lockfiles(lockfiles):
+        result = Lockfile()
+        for lockfile in lockfiles:
+            lockfile = make_abs_path(lockfile)
+            graph_lock = Lockfile.load(lockfile)
+            result.merge(graph_lock)
+        return result
+
     @staticmethod
     def add_lockfile(lockfile=None, requires=None, build_requires=None, python_requires=None,
                      config_requires=None):