conan-server 2.5.0__tar.gz → 2.6.0__tar.gz

{conan-server-2.5.0/conan_server.egg-info → conan-server-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan-server
-Version: 2.5.0
+Version: 2.6.0
 Summary: Conan Server of Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/model.py

@@ -1,6 +1,7 @@
 import fnmatch
 import json
 import os
+from json import JSONDecodeError
 
 from conans.client.graph.graph import RECIPE_EDITABLE, RECIPE_CONSUMER, RECIPE_PLATFORM, \
     RECIPE_VIRTUAL, BINARY_SKIP, BINARY_MISSING, BINARY_INVALID
@@ -73,7 +74,12 @@ class MultiPackagesList:
 
     @staticmethod
     def load(file):
-        content = json.loads(load(file))
+        try:
+            content = json.loads(load(file))
+        except JSONDecodeError as e:
+            raise ConanException(f"Package list file invalid JSON: {file}\n{e}")
+        except Exception as e:
+            raise ConanException(f"Package list file missing or broken: {file}\n{e}")
         result = {}
         for remote, pkglist in content.items():
             if "error" in pkglist:

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/output.py

@@ -1,4 +1,5 @@
 import fnmatch
+import os
 import sys
 import time
 from threading import Lock
@@ -7,7 +8,6 @@ from colorama import Fore, Style
 
 from conans.client.userio import color_enabled
 from conans.errors import ConanException
-from conans.util.env import get_env
 
 LEVEL_QUIET = 80  # -q
 LEVEL_ERROR = 70  # Errors
@@ -40,7 +40,7 @@ class Color(object):
     BRIGHT_MAGENTA = Style.BRIGHT + Fore.MAGENTA  # @UndefinedVariable
 
 
-if get_env("CONAN_COLOR_DARK", 0):
+if os.environ.get("CONAN_COLOR_DARK"):
     Color.WHITE = Fore.BLACK
     Color.CYAN = Fore.BLUE
     Color.YELLOW = Fore.MAGENTA

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/subapi/cache.py

@@ -9,7 +9,7 @@ from conan.api.output import ConanOutput
 from conan.internal.cache.cache import PkgCache
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
-from conan.internal.integrity_check import IntegrityChecker
+from conan.internal.cache.integrity_check import IntegrityChecker
 from conans.client.downloaders.download_cache import DownloadCache
 from conans.errors import ConanException
 from conans.model.package_ref import PkgReference

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/subapi/install.py

@@ -1,8 +1,9 @@
 import os
 
+from conan.internal.api.install.generators import write_generators
 from conan.internal.conan_app import ConanApp
 from conan.internal.deploy import do_deploys
-from conans.client.generators import write_generators
+
 from conans.client.graph.install_graph import InstallGraph
 from conans.client.installer import BinaryInstaller
 from conans.errors import ConanInvalidConfiguration

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/subapi/list.py

@@ -1,14 +1,18 @@
+import os
+from collections import OrderedDict
 from typing import Dict
 
 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 ConanApp
+from conan.internal.paths import CONANINFO
 from conans.errors import ConanException, NotFoundException
 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 conans.search.search import get_cache_packages_binary_info, filter_packages
 from conans.util.dates import timelimit
+from conans.util.files import load
 
 
 class ListAPI:
@@ -69,7 +73,7 @@ class ListAPI:
         if not remote:
             app = ConanApp(self.conan_api)
             prefs = app.cache.get_package_references(ref)
-            packages = get_cache_packages_binary_info(app.cache, prefs)
+            packages = _get_cache_packages_binary_info(app.cache, prefs)
         else:
             app = ConanApp(self.conan_api)
             if ref.revision == "latest":
@@ -85,7 +89,18 @@ class ListAPI:
         :param query: str like "os=Windows AND (arch=x86 OR compiler=gcc)"
         :return: Dict[PkgReference, PkgConfiguration]
         """
-        return filter_packages(query, pkg_configurations)
+        if query is None:
+            return pkg_configurations
+        try:
+            if "!" in query:
+                raise ConanException("'!' character is not allowed")
+            if "~" in query:
+                raise ConanException("'~' character is not allowed")
+            if " not " in query or query.startswith("not "):
+                raise ConanException("'not' operator is not allowed")
+            return filter_package_configs(pkg_configurations, query)
+        except Exception as exc:
+            raise ConanException("Invalid package query: %s. %s" % (query, exc))
 
     @staticmethod
     def filter_packages_profile(packages, profile, ref):
@@ -361,3 +376,29 @@ class _BinaryDistance:
                 "python_requires": self.python_requires_diff,
                 "confs": self.confs_diff,
                 "explanation": self.explanation()}
+
+
+def _get_cache_packages_binary_info(cache, prefs) -> Dict[PkgReference, dict]:
+    """
+    param package_layout: Layout for the given reference
+    """
+
+    result = OrderedDict()
+
+    for pref in prefs:
+        latest_prev = cache.get_latest_package_reference(pref)
+        pkg_layout = cache.pkg_layout(latest_prev)
+
+        # 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)
+        pref = pkg_layout.reference
+        # The key shoudln't have the latest package revision, we are asking for package configs
+        pref.revision = None
+        result[pkg_layout.reference] = info
+
+    return result

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/subapi/local.py

@@ -1,9 +1,8 @@
 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
+from conan.internal.api.local.editable import EditablePackages
 from conans.client.conanfile.build import run_build_method
 from conans.client.graph.graph import CONTEXT_HOST
 from conans.client.graph.profile_node_definer import initialize_conanfile_profile

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/subapi/profiles.py

@@ -4,7 +4,7 @@ from conan.api.output import ConanOutput
 from conan.internal.cache.home_paths import HomePaths
 
 from conans.client.loader import load_python_file
-from conans.client.profile_loader import ProfileLoader
+from conan.internal.api.profile.profile_loader import ProfileLoader
 from conans.errors import ConanException, scoped_traceback
 from conans.model.profile import Profile
 

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/subapi/remotes.py

@@ -9,7 +9,7 @@ from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conans.client.rest_client_local_recipe_index import add_local_recipes_index_remote, \
     remove_local_recipes_index_remote
-from conans.client.store.localdb import LocalDB
+from conan.internal.api.remotes.localdb import LocalDB
 from conans.errors import ConanException
 from conans.util.files import save, load
 

{conan-server-2.5.0 → conan-server-2.6.0}/conan/api/subapi/search.py

@@ -1,5 +1,4 @@
 from conan.internal.conan_app import ConanApp
-from conans.search.search import search_recipes
 
 
 class SearchAPI:
@@ -17,7 +16,7 @@ class SearchAPI:
         if remote:
             refs = app.remote_manager.search_recipes(remote, query)
         else:
-            references = search_recipes(app.cache, query)
+            references = app.cache.search_recipes(query)
             # For consistency with the remote search, we return references without revisions
             # user could use further the API to look for the revisions
             refs = []

{conan-server-2.5.0 → conan-server-2.6.0}/conan/cli/cli.py

@@ -239,9 +239,12 @@ class Cli:
 def _warn_python_version():
     version = sys.version_info
     if version.minor == 6:
+        ConanOutput().writeln("")
+        ConanOutput().warning("*"*80, warn_tag="deprecated")
         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")
+        ConanOutput().warning("*" * 80, warn_tag="deprecated")
 
 
 def main(args):

{conan-server-2.5.0 → conan-server-2.6.0}/conan/cli/command.py

@@ -98,6 +98,12 @@ class BaseConanCommand:
 
         formatter(info)
 
+    def _dispatch_errors(self, info):
+        if info and isinstance(info, dict):
+            if info.get("conan_error"):
+                raise ConanException(info["conan_error"])
+            if info.get("conan_warning"):
+                ConanOutput().warning(info["conan_warning"])
 
 class ConanArgumentParser(argparse.ArgumentParser):
 
@@ -179,6 +185,7 @@ class ConanCommand(BaseConanCommand):
             else:
                 sub.set_parser(subcommand_parser, conan_api)
                 sub.run(conan_api, parser, *args)
+        self._dispatch_errors(info)
 
     @property
     def group(self):
@@ -198,6 +205,7 @@ class ConanSubCommand(BaseConanCommand):
         info = self._method(conan_api, parent_parser, self._parser, *args)
         # It is necessary to do it after calling the "method" otherwise parser not complete
         self._format(parent_parser, info, *args)
+        self._dispatch_errors(info)
 
     def set_name(self, parent_name):
         self._name = self._subcommand_name.replace(f'{parent_name}-', '', 1)

{conan-server-2.5.0 → conan-server-2.6.0}/conan/cli/commands/graph.py

@@ -8,6 +8,7 @@ from conan.cli.args import common_graph_args, validate_common_graph_args
 from conan.cli.command import conan_command, conan_subcommand
 from conan.cli.commands.list import prepare_pkglist_compact, print_serial
 from conan.cli.formatters.graph import format_graph_html, format_graph_json, format_graph_dot
+from conan.cli.formatters.graph.build_order_html import format_build_order_html
 from conan.cli.formatters.graph.graph_info_text import format_graph_info
 from conan.cli.printers.graph import print_graph_packages, print_graph_basic
 from conan.errors import ConanException
@@ -44,8 +45,9 @@ def graph(conan_api, parser, *args):
     """
 
 
-def cli_build_order(build_order):
+def cli_build_order(result):
     # TODO: Very simple cli output, probably needs to be improved
+    build_order = result["build_order"]
     build_order = build_order["order"] if isinstance(build_order, dict) else build_order
     for level in build_order:
         for item in level:
@@ -58,11 +60,12 @@ def cli_build_order(build_order):
                 cli_out_write(f"{item['ref']}:{item['package_id']} - {item['binary']}")
 
 
-def json_build_order(build_order):
-    cli_out_write(json.dumps(build_order, indent=4))
+def json_build_order(result):
+    cli_out_write(json.dumps(result["build_order"], indent=4))
 
 
-@conan_subcommand(formatters={"text": cli_build_order, "json": json_build_order})
+@conan_subcommand(formatters={"text": cli_build_order, "json": json_build_order,
+                              "html": format_build_order_html})
 def graph_build_order(conan_api, parser, subparser, *args):
     """
     Compute the build order of a dependency graph.
@@ -126,10 +129,13 @@ def graph_build_order(conan_api, parser, subparser, *args):
                                                   clean=args.lockfile_clean)
     conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out, cwd)
 
-    return install_order_serialized
+    return {"build_order": install_order_serialized,
+            "conan_error": install_graph.get_errors()}
 
 
-@conan_subcommand(formatters={"text": cli_build_order, "json": json_build_order})
+
+@conan_subcommand(formatters={"text": cli_build_order, "json": json_build_order,
+                              "html": format_build_order_html})
 def graph_build_order_merge(conan_api, parser, subparser, *args):
     """
     Merge more than 1 build-order file.
@@ -156,7 +162,9 @@ def graph_build_order_merge(conan_api, parser, subparser, *args):
     install_order_serialized = result.install_build_order()
     if getattr(result, "legacy"):
         install_order_serialized = install_order_serialized["order"]
-    return install_order_serialized
+
+    return {"build_order": install_order_serialized,
+            "conan_error": result.get_errors()}
 
 
 @conan_subcommand(formatters={"text": format_graph_info,
@@ -234,7 +242,10 @@ def graph_info(conan_api, parser, subparser, *args):
     return {"graph": deps_graph,
             "field_filter": args.filter,
             "package_filter": args.package_filter,
-            "conan_api": conan_api}
+            "conan_api": conan_api,
+            "conan_error": str(deps_graph.error) if deps_graph.error else None,
+            # Do not compute graph errors if there are dependency errors
+            "conan_warning": InstallGraph(deps_graph).get_errors() if not deps_graph.error else None}
 
 
 @conan_subcommand(formatters={"text": explain_formatter_text,

{conan-server-2.5.0 → conan-server-2.6.0}/conan/cli/commands/new.py

@@ -68,7 +68,7 @@ def new(conan_api, parser, *args):
                 template_vars.extend(meta.find_undeclared_variables(ast))
 
             injected_vars = {"conan_version", "package_name", "as_name"}
-            optional_vars = {"requires", "tool_requires"}
+            optional_vars = {"requires", "tool_requires", "output_root_dir"}
             template_vars = list(set(template_vars) - injected_vars - optional_vars)
             template_vars.sort()
             return template_vars

conan-server-2.6.0/conan/cli/formatters/graph/build_order_html.py

@@ -0,0 +1,273 @@
+from jinja2 import select_autoescape, Template
+from conan.api.output import cli_out_write
+
+build_order_html = r"""
+<html lang="en">
+    <head>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/cytoscape/3.30.0/cytoscape.min.js"
+        integrity="sha512-zHc90yHSbkgx0bvVpDK/nVgxANlE+yKN/jKy91tZ4P/vId8AL7HyjSpZqHmEujWDWNwxYXcfaLdYWjAULl35MQ=="
+        crossorigin="anonymous"
+        referrerpolicy="no-referrer"></script>
+    </head>
+
+    <body>
+        <style>
+            body {
+                font: 14px helvetica neue, helvetica, arial, sans-serif;
+                display: flex;
+                margin: 0;
+                padding: 0;
+                height: 100vh;
+            }
+
+            .sidebar {
+                background: #f9f9f9;
+                border-right: 1px solid #ccc;
+                padding: 20px;
+                box-sizing: border-box;
+                overflow-y: auto;
+                font-size: 14px;
+                width: 440px;
+            }
+
+            .content {
+                flex-grow: 1;
+                display: flex;
+                flex-direction: column;
+                overflow: hidden;
+            }
+
+            #cy {
+                flex-grow: 1;
+            }
+
+            #node-info {
+                margin-top: 20px;
+                background: #f9f9f9;
+                padding: 12px;
+                font-family: monospace;
+                white-space: pre-wrap;
+                font-size: 12px;
+                word-wrap: break-word;
+            }
+
+            .legend {
+                margin-top: 20px;
+                font-size: 14px;
+            }
+
+            .legend-item {
+                display: flex;
+                align-items: center;
+                margin-bottom: 5px;
+            }
+
+            .legend-color {
+                width: 20px;
+                height: 20px;
+                margin-right: 10px;
+            }
+        </style>
+
+        <div class="sidebar">
+            <div class="legend">
+                <div class="legend-item">
+                    <div class="legend-color" style="background-color: #ffff37;"></div>
+                    <span>All packages need to be built</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="background-color: #ff9b28;"></div>
+                    <span>Some packages need to be built</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="background-color: #70c7e6;"></div>
+                    <span>Cache</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="background-color: #79eb8a;"></div>
+                    <span>Download</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="border: 1px solid black; width: 20px; height: 20px;"></div>
+                    <span>Requirements in the <i>host</i> context</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="border: 1px solid black; border-radius: 50%; width: 20px; height: 20px;"></div>
+                    <span>Requirements in the <i>build</i> context</span>
+                </div>
+            </div>
+            <div id="node-info">
+                <p>Click on a node to see details.</p>
+            </div>
+        </div>
+        <div class="content">
+            <div id="cy"></div>
+        </div>
+
+        <script type="text/javascript">
+            document.addEventListener("DOMContentLoaded", function() {
+                var buildOrderData = {{ build_order | tojson }};
+
+                var elements = [];
+                var edges = [];
+
+                var yOffset = 50;
+                var posX = 0;
+                var posY = 0;
+                var columns = 4;
+
+                buildOrderData.forEach((step, stepIndex) => {
+                    var stepId = 'step' + stepIndex;
+                    elements.push({
+                        data: { id: stepId, label: 'Step ' + (stepIndex + 1) },
+                        position: { x: posX, y: posY }
+                    });
+
+                    step.forEach((lib, libIndex) => {
+                        var libId = stepId + '_lib' + libIndex;
+                        var libLabel = lib.ref.split('#')[0];
+
+                        // Determine the type of the library
+                        var libData = Array.isArray(lib.packages) ? lib.packages[0][0] : lib;
+                        var libType = libData.binary || libData.build || libData.cache;
+
+                        var isAllBuild = true;
+                        var isSomeBuild = false;
+                        var shape = 'rectangle';
+                        var borderColor = '#00695C';
+
+                        if (Array.isArray(lib.packages)) {
+                            lib.packages.forEach(pkgArray => {
+                                pkgArray.forEach(pkg => {
+                                    if (pkg.binary === "Build") {
+                                        isSomeBuild = true;
+                                    } else {
+                                        isAllBuild = false;
+                                    }
+                                    if (pkg.context === "build") {
+                                        shape = 'ellipse';
+                                        borderColor = '#0000FF';  // Different border color for build context
+                                    }
+                                });
+                            });
+                        }
+
+                        var nodeColor;
+                        if (isAllBuild) {
+                            nodeColor = "#ffff37"; // Light orange for all build
+                        } else if (isSomeBuild) {
+                            nodeColor = "#ff9b28"; // Yellow for some build
+                        } else if (libType === "Cache") {
+                            nodeColor = "#70c7e6"; // Light green
+                        } else if (libType === "Download") {
+                            nodeColor = "#79eb8a"; // Light blue
+                        } else {
+                            nodeColor = "#FFFFFF"; // Default color
+                        }
+
+                        if (libIndex % columns === 0) {
+                            posX = 0;
+                            posY += yOffset; // move to the next row
+                        }
+
+                        elements.push({
+                            data: { id: libId, parent: stepId, label: libLabel, info: lib, color: nodeColor, shape: shape, borderColor: borderColor },
+                            position: { x: posX + libLabel.length / 2.0 * 12, y: posY }
+                        });
+                        posX += libLabel.length * 12;
+                    });
+
+                    if (stepIndex > 0) {
+                        var prevStepId = 'step' + (stepIndex - 1);
+                        edges.push({ data: { id: prevStepId + '_to_' + stepId, source: prevStepId, target: stepId } });
+                    }
+
+                    posY += yOffset * 2;
+                    posX = 0;
+                });
+
+                var cy = cytoscape({
+                    container: document.getElementById('cy'),
+                    boxSelectionEnabled: false,
+                    style: [
+                        {
+                            selector: 'node[color][shape][borderColor]',
+                            style: {
+                                'shape': 'data(shape)',
+                                'content': 'data(label)',
+                                'text-valign': 'center',
+                                'text-halign': 'center',
+                                'background-color': 'data(color)',
+                                'border-color': 'data(borderColor)',
+                                'border-width': 1,
+                                'width': function(ele) { return ele.data('label').length * 10.5; },
+                                'padding': '5px',
+                                'font-family': 'monospace',
+                                'font-size': '16px'
+                            }
+                        },
+                        {
+                            selector: ':parent',
+                            style: {
+                                'text-valign': 'top',
+                                'text-halign': 'center',
+                                'shape': 'round-rectangle',
+                                'background-opacity': 0.1,
+                                'border-color': '#004D40',
+                                'border-width': 2,
+                                'padding': 10,
+                                'font-family': 'monospace',
+                                'font-size': '16px'
+                            }
+                        },
+                        {
+                            selector: 'edge',
+                            style: {
+                                'curve-style': 'bezier',
+                                'target-arrow-shape': 'triangle',
+                                'line-color': '#004D40',
+                                'target-arrow-color': '#004D40',
+                                'width': 2
+                            }
+                        }
+                    ],
+                    elements: {
+                        nodes: elements,
+                        edges: edges
+                    },
+                    layout: {
+                        name: 'preset',
+                        padding: 5,
+                        fit: true
+                    }
+                });
+
+                // Add click event listener to nodes
+                cy.on('tap', 'node', function(evt){
+                    var node = evt.target;
+                    var info = node.data('info');
+                    var infoHtml = '';
+                    for (var key in info) {
+                        if (info.hasOwnProperty(key)) {
+                            infoHtml += '<p><strong>' + key + ':</strong> ' + JSON.stringify(info[key], null, 2) + '</p>';
+                        }
+                    }
+                    document.getElementById('node-info').innerHTML = infoHtml;
+                });
+            });
+        </script>
+    </body>
+</html>
+"""
+
+def _render_build_order(build_order, template):
+    from conans import __version__ as client_version
+    context = {'build_order': build_order, 'version': client_version, }
+    return template.render(context)
+
+
+def format_build_order_html(result):
+    build_order = result["build_order"]
+    build_order = build_order["order"] if isinstance(build_order, dict) else build_order
+    template = Template(build_order_html, autoescape=select_autoescape(['html', 'xml']))
+    cli_out_write(_render_build_order(build_order, template))

{conan-server-2.5.0 → conan-server-2.6.0}/conan/cli/formatters/graph/graph.py

@@ -126,8 +126,6 @@ def format_graph_html(result):
         error["type"] = "conflict"
         error["should_highlight_node"] = lambda node: node.id == graph.error.node.id
     cli_out_write(_render_graph(graph, error, template, template_folder))
-    if graph.error:
-        raise graph.error
 
 
 def format_graph_dot(result):
@@ -138,8 +136,6 @@ def format_graph_dot(result):
     user_template = os.path.join(template_folder, "graph.dot")
     template = load(user_template) if os.path.isfile(user_template) else graph_info_dot
     cli_out_write(_render_graph(graph, None, template, template_folder))
-    if graph.error:
-        raise graph.error
 
 
 def format_graph_json(result):
@@ -150,5 +146,3 @@ def format_graph_json(result):
     serial = filter_graph(serial, package_filter=package_filter, field_filter=field_filter)
     json_result = json.dumps({"graph": serial}, indent=4)
     cli_out_write(json_result)
-    if graph.error:
-        raise graph.error

{conan-server-2.5.0 → conan-server-2.6.0}/conan/cli/formatters/graph/graph_info_text.py

@@ -33,8 +33,6 @@ def format_graph_info(result):
     for n in serial["nodes"].values():
         cli_out_write(f"{n['ref']}:")  # FIXME: This can be empty for consumers and it is ugly ":"
         _serial_pretty_printer(n, indent="  ")
-    if graph.error:
-        raise graph.error
 
 
 def _serial_pretty_printer(data, indent=""):

conan-server-2.5.0/conans/client/generators/__init__.py → conan-server-2.6.0/conan/internal/api/install/generators.py

@@ -16,7 +16,6 @@ _generators = {"CMakeToolchain": "conan.tools.cmake",
                "NMakeToolchain": "conan.tools.microsoft",
                "NMakeDeps": "conan.tools.microsoft",
                "VCVars": "conan.tools.microsoft",
-               "QbsProfile": "conan.tools.qbs.qbsprofile",
                "VirtualRunEnv": "conan.tools.env.virtualrunenv",
                "VirtualBuildEnv": "conan.tools.env.virtualbuildenv",
                "AutotoolsDeps": "conan.tools.gnu",
@@ -36,10 +35,6 @@ _generators = {"CMakeToolchain": "conan.tools.cmake",
 
 
 def _get_generator_class(generator_name):
-    # QbsToolchain is an alias for QbsProfile
-    if generator_name == "QbsToolchain":
-        generator_name = "QbsProfile"
-
     try:
         generator_class = _generators[generator_name]
         # This is identical to import ... form ... in terms of cacheing