conan-server 2.2.2__tar.gz → 2.3.0__tar.gz

{conan-server-2.2.2/conan_server.egg-info → conan-server-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan-server
-Version: 2.2.2
+Version: 2.3.0
 Summary: Conan Server of Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD
@@ -43,12 +43,6 @@ Description: <picture>
         This is the **developer/maintainer** documentation. For user documentation, go to https://docs.conan.io
         
         
-        | **develop2**            |
-        |-------------------------|
-        | [![Build Status Develop](https://ci.conan.io/buildStatus/icon?job=ConanTestSuite/develop)](https://ci.conan.io/blue/organizations/jenkins/ConanTestSuitev2/activity)  |
-        
-        
-        
         ## Setup
         
         You can run Conan from source in Windows, MacOS, and Linux:
@@ -87,9 +81,9 @@ Description: <picture>
         
         
         Feedback and contribution are always welcome in this project.
-        Please read our [contributing guide](https://github.com/conan-io/conan/blob/develop/.github/CONTRIBUTING.md).
+        Please read our [contributing guide](https://github.com/conan-io/conan/blob/develop2/.github/CONTRIBUTING.md).
         Also, if you plan to contribute, please add some testing for your changes. You can read the [Conan
-        tests guidelines section](https://github.com/conan-io/conan/blob/develop/conans/test/README.md) for
+        tests guidelines section](https://github.com/conan-io/conan/blob/develop2/conans/test/README.md) for
         some advice on how to write tests for Conan.
         
         ### Running the tests
@@ -141,7 +135,7 @@ Description: <picture>
         To run specific tests, you can specify the test name too, something like:
         
         ```bash
-        $ python -m pytest conans/test/unittests/client/cmd/export_test.py::ExportTest::test_export_warning -s
+        $ python -m pytest conans/test/functional/command/export_test.py::TestRevisionModeSCM::test_revision_mode_scm -s
         ```
         
         The `-s` argument can be useful to see some output that otherwise is captured by *pytest*.

{conan-server-2.2.2 → conan-server-2.3.0}/README.md

@@ -35,12 +35,6 @@ Conan is a package manager for C and C++ developers:
 This is the **developer/maintainer** documentation. For user documentation, go to https://docs.conan.io
 
 
-| **develop2**            |
-|-------------------------|
-| [![Build Status Develop](https://ci.conan.io/buildStatus/icon?job=ConanTestSuite/develop)](https://ci.conan.io/blue/organizations/jenkins/ConanTestSuitev2/activity)  |
-
-
-
 ## Setup
 
 You can run Conan from source in Windows, MacOS, and Linux:
@@ -79,9 +73,9 @@ You can run Conan from source in Windows, MacOS, and Linux:
 
 
 Feedback and contribution are always welcome in this project.
-Please read our [contributing guide](https://github.com/conan-io/conan/blob/develop/.github/CONTRIBUTING.md).
+Please read our [contributing guide](https://github.com/conan-io/conan/blob/develop2/.github/CONTRIBUTING.md).
 Also, if you plan to contribute, please add some testing for your changes. You can read the [Conan
-tests guidelines section](https://github.com/conan-io/conan/blob/develop/conans/test/README.md) for
+tests guidelines section](https://github.com/conan-io/conan/blob/develop2/conans/test/README.md) for
 some advice on how to write tests for Conan.
 
 ### Running the tests
@@ -133,7 +127,7 @@ OK
 To run specific tests, you can specify the test name too, something like:
 
 ```bash
-$ python -m pytest conans/test/unittests/client/cmd/export_test.py::ExportTest::test_export_warning -s
+$ python -m pytest conans/test/functional/command/export_test.py::TestRevisionModeSCM::test_revision_mode_scm -s
 ```
 
 The `-s` argument can be useful to see some output that otherwise is captured by *pytest*.

{conan-server-2.2.2 → conan-server-2.3.0}/conan/api/model.py

@@ -47,6 +47,9 @@ class MultiPackagesList:
     def __init__(self):
         self.lists = {}
 
+    def setdefault(self, key, default):
+        return self.lists.setdefault(key, default)
+
     def __getitem__(self, name):
         try:
             return self.lists[name]
@@ -63,6 +66,10 @@ class MultiPackagesList:
         return {k: v.serialize() if isinstance(v, PackagesList) else v
                 for k, v in self.lists.items()}
 
+    def merge(self, other):
+        for k, v in other.lists.items():
+            self.lists.setdefault(k, PackagesList()).merge(v)
+
     @staticmethod
     def load(file):
         content = json.loads(load(file))
@@ -76,9 +83,18 @@ class MultiPackagesList:
         pkglist.lists = result
         return pkglist
 
+    @staticmethod
+    def from_graph(graph, graph_recipes=None, graph_binaries=None):
+        graph = {"graph": graph.serialize()}
+        return MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries)
+
     @staticmethod
     def load_graph(graphfile, graph_recipes=None, graph_binaries=None):
         graph = json.loads(load(graphfile))
+        return MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries)
+
+    @staticmethod
+    def _define_graph(graph, graph_recipes=None, graph_binaries=None):
         pkglist = MultiPackagesList()
         cache_list = PackagesList()
         if graph_recipes is None and graph_binaries is None:
@@ -143,6 +159,16 @@ class PackagesList:
     def __init__(self):
         self.recipes = {}
 
+    def merge(self, other):
+        def recursive_dict_update(d, u):  # TODO: repeated from conandata.py
+            for k, v in u.items():
+                if isinstance(v, dict):
+                    d[k] = recursive_dict_update(d.get(k, {}), v)
+                else:
+                    d[k] = v
+            return d
+        recursive_dict_update(self.recipes, other.recipes)
+
     def split(self):
         """
         Returns a list of PackageList, splitted one per reference.

{conan-server-2.2.2 → conan-server-2.3.0}/conan/api/subapi/cache.py

@@ -155,6 +155,8 @@ class CacheAPI:
             tgz.close()
 
     def restore(self, path):
+        if not os.path.isfile(path):
+            raise ConanException(f"Restore archive doesn't exist in {path}")
         with open(path, mode='rb') as file_handler:
             the_tar = tarfile.open(fileobj=file_handler)
             fileobj = the_tar.extractfile("pkglist.json")
@@ -162,32 +164,49 @@ class CacheAPI:
             the_tar.extractall(path=self.conan_api.cache_folder)
             the_tar.close()
 
+        # After unzipping the files, we need to update the DB that references these files
         out = ConanOutput()
         package_list = PackagesList.deserialize(json.loads(pkglist))
         cache = ClientCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
         for ref, ref_bundle in package_list.refs().items():
             ref.timestamp = revision_timestamp_now()
             ref_bundle["timestamp"] = ref.timestamp
-            recipe_layout = cache.get_or_create_ref_layout(ref)
+            recipe_layout = cache.get_or_create_ref_layout(ref)  # DB folder entry
             recipe_folder = ref_bundle["recipe_folder"]
             rel_path = os.path.relpath(recipe_layout.base_folder, cache.cache_folder)
             rel_path = rel_path.replace("\\", "/")
+            # In the case of recipes, they are always "in place", so just checking it
             assert rel_path == recipe_folder, f"{rel_path}!={recipe_folder}"
             out.info(f"Restore: {ref} in {recipe_folder}")
             for pref, pref_bundle in package_list.prefs(ref, ref_bundle).items():
                 pref.timestamp = revision_timestamp_now()
                 pref_bundle["timestamp"] = pref.timestamp
-                pkg_layout = cache.get_or_create_pkg_layout(pref)
-                pkg_folder = pref_bundle["package_folder"]
-                out.info(f"Restore: {pref} in {pkg_folder}")
-                # We need to put the package in the final location in the cache
-                shutil.move(os.path.join(cache.cache_folder, pkg_folder), pkg_layout.package())
-                metadata_folder = pref_bundle.get("metadata_folder")
-                if metadata_folder:
-                    out.info(f"Restore: {pref} metadata in {metadata_folder}")
-                    # We need to put the package in the final location in the cache
-                    shutil.move(os.path.join(cache.cache_folder, metadata_folder),
-                                pkg_layout.metadata())
+                pkg_layout = cache.get_or_create_pkg_layout(pref)  # DB Folder entry
+                unzipped_pkg_folder = pref_bundle["package_folder"]
+                out.info(f"Restore: {pref} in {unzipped_pkg_folder}")
+                # If the DB folder entry is different to the disk unzipped one, we need to move it
+                # This happens for built (not downloaded) packages in the source "conan cache save"
+                db_pkg_folder = os.path.relpath(pkg_layout.package(), cache.cache_folder)
+                db_pkg_folder = db_pkg_folder.replace("\\", "/")
+                if db_pkg_folder != unzipped_pkg_folder:
+                    # If a previous package exists, like a previous restore, then remove it
+                    if os.path.exists(pkg_layout.package()):
+                        shutil.rmtree(pkg_layout.package())
+                    shutil.move(os.path.join(cache.cache_folder, unzipped_pkg_folder),
+                                pkg_layout.package())
+                    pref_bundle["package_folder"] = db_pkg_folder
+                unzipped_metadata_folder = pref_bundle.get("metadata_folder")
+                if unzipped_metadata_folder:
+                    out.info(f"Restore: {pref} metadata in {unzipped_metadata_folder}")
+                    db_metadata_folder = os.path.relpath(pkg_layout.metadata(), cache.cache_folder)
+                    db_metadata_folder = db_metadata_folder.replace("\\", "/")
+                    if db_metadata_folder != unzipped_metadata_folder:
+                        # We need to put the package in the final location in the cache
+                        if os.path.exists(pkg_layout.metadata()):
+                            shutil.rmtree(pkg_layout.metadata())
+                        shutil.move(os.path.join(cache.cache_folder, unzipped_metadata_folder),
+                                    pkg_layout.metadata())
+                        pref_bundle["metadata_folder"] = db_metadata_folder
 
         return package_list
 

{conan-server-2.2.2 → conan-server-2.3.0}/conan/api/subapi/local.py

@@ -1,5 +1,6 @@
 import os
 
+from conan.api.output import ConanOutput
 from conan.cli import make_abs_path
 from conan.internal.conan_app import ConanApp
 from conans.client.cache.editable import EditablePackages
@@ -60,7 +61,8 @@ class LocalAPI:
 
     def editable_remove(self, path=None, requires=None, cwd=None):
         if path:
-            path = self._conan_api.local.get_conanfile_path(path, cwd, py=True)
+            path = make_abs_path(path, cwd)
+            path = os.path.join(path, "conanfile.py")
         return self.editable_packages.remove(path, requires)
 
     def editable_list(self):

{conan-server-2.2.2 → conan-server-2.3.0}/conan/api/subapi/remotes.py

@@ -257,7 +257,10 @@ def _load(remotes_file):
         _save(remotes_file, [remote])
         return [remote]
 
-    data = json.loads(load(remotes_file))
+    try:
+        data = json.loads(load(remotes_file))
+    except Exception as e:
+        raise ConanException(f"Error loading JSON remotes file '{remotes_file}': {e}")
     result = []
     for r in data.get("remotes", []):
         remote = Remote(r["name"], r["url"], r["verify_ssl"], r.get("disabled", False),

{conan-server-2.2.2 → conan-server-2.3.0}/conan/cli/cli.py

@@ -236,6 +236,14 @@ class Cli:
         return ERROR_UNEXPECTED
 
 
+def _warn_python_version():
+    version = sys.version_info
+    if version.minor == 6:
+        ConanOutput().warning("Python 3.6 is end-of-life since 2021. "
+                              "Conan future versions will drop support for it, "
+                              "please upgrade Python", warn_tag="deprecated")
+
+
 def main(args):
     """ main entry point of the conan application, using a Command to
     parse parameters
@@ -281,6 +289,7 @@ def main(args):
     error = SUCCESS
     try:
         cli.run(args)
+        _warn_python_version()
     except BaseException as e:
         error = cli.exception_exit_error(e)
     sys.exit(error)

{conan-server-2.2.2 → conan-server-2.3.0}/conan/cli/commands/create.py

@@ -9,6 +9,7 @@ from conan.cli.formatters.graph import format_graph_json
 from conan.cli.printers import print_profiles
 from conan.cli.printers.graph import print_graph_packages, print_graph_basic
 from conan.errors import ConanException
+from conans.client.graph.graph import BINARY_BUILD
 from conans.util.files import mkdir
 
 
@@ -26,14 +27,20 @@ def create(conan_api, parser, *args):
     parser.add_argument("-tf", "--test-folder", action=OnceArgument,
                         help='Alternative test folder name. By default it is "test_package". '
                              'Use "" to skip the test stage')
+    parser.add_argument("-tm", "--test-missing", action='store_true', default=False,
+                        help='Run the test_package checks only if the package is built from source'
+                             ' but not if it already existed (using --build=missing)')
     parser.add_argument("-bt", "--build-test", action="append",
                         help="Same as '--build' but only for the test_package requires. By default"
                              " if not specified it will take the '--build' value if specified")
+    raw_args = args[0]
     args = parser.parse_args(*args)
 
+    if args.test_missing and args.test_folder == "":
+        raise ConanException('--test-folder="" is incompatible with --test-missing')
+
     cwd = os.getcwd()
     path = conan_api.local.get_conanfile_path(args.path, cwd, py=True)
-    test_conanfile_path = _get_test_conanfile_path(args.test_folder, path)
     overrides = eval(args.lockfile_overrides) if args.lockfile_overrides else None
     lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile,
                                                conanfile_path=path,
@@ -56,6 +63,25 @@ def create(conan_api, parser, *args):
     lockfile = conan_api.lockfile.update_lockfile_export(lockfile, conanfile, ref, is_build)
 
     print_profiles(profile_host, profile_build)
+    if profile_host.runner and not os.environ.get("CONAN_RUNNER_ENVIRONMENT"):
+        from conan.internal.runner.docker import DockerRunner
+        from conan.internal.runner.ssh import SSHRunner
+        from conan.internal.runner.wsl import WSLRunner
+        try:
+            runner_type = profile_host.runner['type'].lower()
+        except KeyError:
+            raise ConanException(f"Invalid runner configuration. 'type' must be defined")
+        runner_instances_map = {
+            'docker': DockerRunner,
+            # 'ssh': SSHRunner,
+            # 'wsl': WSLRunner,
+        }
+        try:
+            runner_instance = runner_instances_map[runner_type]
+        except KeyError:
+            raise ConanException(f"Invalid runner type '{runner_type}'. Allowed values: {', '.join(runner_instances_map.keys())}")
+        return runner_instance(conan_api, 'create', profile_host, profile_build, args, raw_args).run()
+
     if args.build is not None and args.build_test is None:
         args.build_test = args.build
 
@@ -91,6 +117,14 @@ def create(conan_api, parser, *args):
         lockfile = conan_api.lockfile.update_lockfile(lockfile, deps_graph, args.lockfile_packages,
                                                       clean=args.lockfile_clean)
 
+    test_package_folder = getattr(conanfile, "test_package_folder", None) \
+        if args.test_folder is None else args.test_folder
+    test_conanfile_path = _get_test_conanfile_path(test_package_folder, path)
+    # If the user provide --test-missing and the binary was not built from source, skip test_package
+    if args.test_missing and deps_graph.root.dependencies\
+            and deps_graph.root.dependencies[0].dst.binary != BINARY_BUILD:
+        test_conanfile_path = None  # disable it
+
     if test_conanfile_path:
         # TODO: We need arguments for:
         #  - decide update policy "--test_package_update"

{conan-server-2.2.2 → conan-server-2.3.0}/conan/cli/commands/graph.py

@@ -14,9 +14,8 @@ from conan.errors import ConanException
 from conan.internal.deploy import do_deploys
 from conans.client.graph.graph import BINARY_MISSING
 from conans.client.graph.install_graph import InstallGraph
-from conans.errors import ConanConnectionError, NotFoundException
+from conans.errors import NotFoundException
 from conans.model.recipe_ref import ref_matches, RecipeReference
-from conans.model.version_range import VersionRange
 
 
 def explain_formatter_text(data):
@@ -214,10 +213,7 @@ def graph_info(conan_api, parser, subparser, *args):
                                                          remotes, args.update,
                                                          check_updates=args.check_updates)
     print_graph_basic(deps_graph)
-    if deps_graph.error:
-        ConanOutput().info("Graph error", Color.BRIGHT_RED)
-        ConanOutput().info("    {}".format(deps_graph.error), Color.BRIGHT_RED)
-    else:
+    if not deps_graph.error:
         conan_api.graph.analyze_binaries(deps_graph, args.build, remotes=remotes, update=args.update,
                                          lockfile=lockfile)
         print_graph_packages(deps_graph)

{conan-server-2.2.2 → conan-server-2.3.0}/conan/cli/commands/new.py

@@ -18,7 +18,7 @@ def new(conan_api, parser, *args):
                         "either a predefined built-in or a user-provided one. "
                         "Available built-in templates: basic, cmake_lib, cmake_exe, "
                         "meson_lib, meson_exe, msbuild_lib, msbuild_exe, bazel_lib, bazel_exe, "
-                        "autotools_lib, autotools_exe, local_recipes_index"
+                        "autotools_lib, autotools_exe, local_recipes_index. "
                         "E.g. 'conan new cmake_lib -d name=hello -d version=0.1'. "
                         "You can define your own templates too by inputting an absolute path "
                         "as your template, or a path relative to your conan home folder."

conan-server-2.3.0/conan/cli/commands/pkglist.py

@@ -0,0 +1,93 @@
+import copy
+
+from conan.api.conan_api import ConanAPI
+from conan.api.model import MultiPackagesList, PackagesList
+from conan.cli import make_abs_path
+from conan.cli.command import conan_command, conan_subcommand
+from conan.cli.commands.list import print_list_text, print_list_json
+from conan.cli.formatters.list import list_packages_html
+from conans.errors import NotFoundException
+
+
+@conan_command(group="Consumer")
+def pkglist(conan_api: ConanAPI, parser, *args):  # noqa
+    """
+    Several operations over package lists
+    """
+
+
+@conan_subcommand(formatters={"text": print_list_text,
+                              "json": print_list_json,
+                              "html": list_packages_html})
+def pkglist_find_remote(conan_api, parser, subparser, *args):
+    """
+    (Experimental) Find the remotes of a list of packages in the cache
+    """
+    subparser.add_argument('list', help="Input package list")
+    subparser.add_argument("-r", "--remote", default=None, action="append",
+                           help="Remote names. Accepts wildcards "
+                                "('*' means all the remotes available)")
+    args = parser.parse_args(*args)
+
+    listfile = make_abs_path(args.list)
+    multi_pkglist = MultiPackagesList.load(listfile)
+    package_list = multi_pkglist["Local Cache"]
+    selected_remotes = conan_api.remotes.list(args.remote)
+
+    result = MultiPackagesList()
+    for r in selected_remotes:
+        result_pkg_list = PackagesList()
+        for ref, recipe_bundle in package_list.refs().items():
+            ref_no_rev = copy.copy(ref)  # TODO: Improve ugly API
+            ref_no_rev.revision = None
+            try:
+                revs = conan_api.list.recipe_revisions(ref_no_rev, remote=r)
+            except NotFoundException:
+                continue
+            if ref not in revs:  # not found
+                continue
+            result_pkg_list.add_refs([ref])
+            for pref, pref_bundle in package_list.prefs(ref, recipe_bundle).items():
+                pref_no_rev = copy.copy(pref)  # TODO: Improve ugly API
+                pref_no_rev.revision = None
+                try:
+                    prevs = conan_api.list.package_revisions(pref_no_rev, remote=r)
+                except NotFoundException:
+                    continue
+                if pref in prevs:
+                    result_pkg_list.add_prefs(ref, [pref])
+                    info = recipe_bundle["packages"][pref.package_id]["info"]
+                    result_pkg_list.add_configurations({pref: info})
+        if result_pkg_list.recipes:
+            result.add(r.name, result_pkg_list)
+
+    return {
+        "results": result.serialize(),
+        "conan_api": conan_api,
+        "cli_args": " ".join([f"{arg}={getattr(args, arg)}"
+                              for arg in vars(args) if getattr(args, arg)])
+    }
+
+
+@conan_subcommand(formatters={"text": print_list_text,
+                              "json": print_list_json,
+                              "html": list_packages_html})
+def pkglist_merge(conan_api, parser, subparser, *args):
+    """
+    (Experimental) Merge several package lists into a single one
+    """
+    subparser.add_argument("-l", "--list", help="Package list file", action="append")
+    args = parser.parse_args(*args)
+
+    result = MultiPackagesList()
+    for pkglist in args.list:
+        listfile = make_abs_path(pkglist)
+        multi_pkglist = MultiPackagesList.load(listfile)
+        result.merge(multi_pkglist)
+
+    return {
+        "results": result.serialize(),
+        "conan_api": conan_api,
+        "cli_args": " ".join([f"{arg}={getattr(args, arg)}"
+                              for arg in vars(args) if getattr(args, arg)])
+    }

{conan-server-2.2.2 → conan-server-2.3.0}/conan/cli/commands/profile.py

@@ -58,12 +58,18 @@ def profile_detect(conan_api, parser, subparser, *args):
     """
     subparser.add_argument("--name", help="Profile name, 'default' if not specified")
     subparser.add_argument("-f", "--force", action='store_true', help="Overwrite if exists")
+    subparser.add_argument("-e", "--exist-ok", action='store_true',
+                           help="If the profile already exist, do not detect a new one")
     args = parser.parse_args(*args)
 
     profile_name = args.name or "default"
     profile_pathname = conan_api.profiles.get_path(profile_name, os.getcwd(), exists=False)
-    if not args.force and os.path.exists(profile_pathname):
-        raise ConanException(f"Profile '{profile_pathname}' already exists")
+    if os.path.exists(profile_pathname):
+        if args.exist_ok:
+            ConanOutput().info(f"Profile '{profile_name}' already exists, skipping detection")
+            return
+        if not args.force:
+            raise ConanException(f"Profile '{profile_pathname}' already exists")
 
     detected_profile = conan_api.profiles.detect()
     ConanOutput().success("\nDetected profile:")

{conan-server-2.2.2 → conan-server-2.3.0}/conan/cli/commands/version.py

@@ -12,10 +12,22 @@ def version(conan_api, parser, *args):
     Give information about the Conan client version.
     """
 
-    return {'version': str(conan_version),
+    return {
+            'version': str(conan_version),
+            'conan_path': sys.argv[0],
             'python': {
                 'version': platform.python_version().replace('\n', ''),
                 'sys_version': sys.version.replace('\n', ''),
+                'sys_executable': sys.executable,
+                'is_frozen': getattr(sys, 'frozen', False),
+                'architecture': platform.machine(),
+                },
+            'system': {
+                'version': platform.version(),
+                'platform': platform.platform(),
+                'system': platform.system(),
+                'release': platform.release(),
+                'cpu': platform.processor(),
                 }
             }
 

{conan-server-2.2.2 → conan-server-2.3.0}/conan/cli/formatters/graph/graph.py

@@ -54,16 +54,23 @@ class _PrinterGraphItem(object):
 class _Grapher(object):
     def __init__(self, deps_graph):
         self._deps_graph = deps_graph
-        self.node_map, self.edges = self._build_graph()
+        self.node_map, self._edges = self._build_graph()
         self._nodes = self.node_map.values()
 
     @property
     def nodes(self):
-        ConanOutput().warning("--format=html rendering using 'graph' object is deprecated and "
+        ConanOutput().warning("--format=html/dot rendering using 'graph' object is deprecated and "
                               "will be removed in future 2.X version. Please upgrade your template "
                               "to use 'deps_graph' instead", warn_tag="deprecated")
         return self._nodes
 
+    @property
+    def edges(self):
+        ConanOutput().warning("--format=html/dot rendering using 'graph' object is deprecated and "
+                              "will be removed in future 2.X version. Please upgrade your template "
+                              "to use 'deps_graph' instead", warn_tag="deprecated")
+        return self._edges
+
     def _build_graph(self):
         graph_nodes = self._deps_graph.by_levels()
         build_time_nodes = self._deps_graph.build_time_nodes()
@@ -95,10 +102,10 @@ class _Grapher(object):
 
 
 def _render_graph(graph, error, template, template_folder):
-    deps_graph = json.dumps(graph.serialize())
+    deps_graph = graph.serialize()
     graph = _Grapher(graph)
     from conans import __version__ as client_version
-    template = Template(template)
+    template = Template(template, autoescape=select_autoescape(['html', 'xml']))
     return template.render(deps_graph=deps_graph, graph=graph, error=error,
                            base_template_path=template_folder, version=client_version)
 
@@ -126,11 +133,7 @@ def format_graph_html(result):
 def format_graph_dot(result):
     graph = result["graph"]
     conan_api = result["conan_api"]
-    package_filter = result["package_filter"]
-    serial = graph.serialize()
-    # TODO: This is not used, it is necessary to update the renderings to use the serialized graph
-    #  instead of the native graph
-    serial = filter_graph(serial, package_filter)
+
     template_folder = os.path.join(conan_api.cache_folder, "templates")
     user_template = os.path.join(template_folder, "graph.dot")
     template = load(user_template) if os.path.isfile(user_template) else graph_info_dot

conan-server-2.3.0/conan/cli/formatters/graph/info_graph_dot.py

@@ -0,0 +1,13 @@
+
+graph_info_dot = """\
+digraph {
+    {%- for node_id, node in deps_graph["nodes"].items() %}
+        {%- for dep_id, dep in node["dependencies"].items() %}
+        {%- if dep["direct"] %}
+        "{{ node["label"] }}" -> "{{ deps_graph["nodes"][dep_id]["label"] }}"
+        {%- endif %}
+        {%- endfor %}
+    {%- endfor %}
+}
+
+"""