diff --git a/conans/client/conan_api.py b/conans/client/conan_api.py
index 357ce44ad..a4e109979 100644
--- a/conans/client/conan_api.py
+++ b/conans/client/conan_api.py
@@ -556,14 +556,11 @@ class ConanAPIV1(object):
         self._client_cache.invalidate()
 
     @api_method
-    def config_install(self, item, verify_ssl, config_type=None, args=None):
-        # _make_abs_path, but could be not a path at all
-        if item is not None and os.path.exists(item) and not os.path.isabs(item):
-            item = os.path.abspath(item)
+    def config_install(self, path_or_url, verify_ssl, config_type=None, args=None):
 
         from conans.client.conf.config_installer import configuration_install
         requester = self._remote_manager._auth_manager._rest_client.requester,  # FIXME: Look out!
-        return configuration_install(item, self._client_cache, self._user_io.out, verify_ssl,
+        return configuration_install(path_or_url, self._client_cache, self._user_io.out, verify_ssl,
                                      requester=requester, config_type=config_type, args=args)
 
     def _info_args(self, reference, install_folder, profile_name, settings, options, env):
diff --git a/conans/client/conf/config_installer.py b/conans/client/conf/config_installer.py
index 8559e6299..6e50d8a02 100644
--- a/conans/client/conf/config_installer.py
+++ b/conans/client/conf/config_installer.py
@@ -7,6 +7,7 @@ from six.moves.urllib.parse import urlparse
 from conans import load
 from conans.client import tools
 from conans.client.remote_registry import load_registry_txt
+from conans.client.tools import Git
 from conans.client.tools.files import unzip
 from conans.errors import ConanException
 from conans.util.files import mkdir, rmdir, walk
@@ -38,24 +39,21 @@ def _handle_profiles(source_folder, target_folder, output):
             relative_path = ""
         for f in files:
             profile = os.path.join(relative_path, f)
-            output.info("    Installing profile %s" % profile)
+            output.info("  - %s" % profile)
             shutil.copy(os.path.join(root, f), os.path.join(target_folder, profile))
 
 
 def _process_git_repo(repo_url, client_cache, output, tmp_folder, verify_ssl, args=None):
-    output.info("Trying to clone repo  %s" % repo_url)
+    output.info("Trying to clone repo: %s" % repo_url)
 
     with tools.chdir(tmp_folder):
         try:
             args = args or ""
-            subprocess.check_output('git -c http.sslVerify=%s %s clone "%s" config'
-                                    % (verify_ssl, args, repo_url),
-                                    shell=True)
-            output.info("Repo cloned")
+            git = Git(verify_ssl=verify_ssl, output=output)
+            git.clone(repo_url, args=args)
+            output.info("Repo cloned!")
         except Exception as e:
-            raise ConanException("config install error. Can't clone repo: %s" % str(e))
-
-    tmp_folder = os.path.join(tmp_folder, "config")
+            raise ConanException("Can't clone repo: %s" % str(e))
     _process_folder(tmp_folder, client_cache, output)
 
 
@@ -84,7 +82,7 @@ def _process_folder(folder, client_cache, output):
                 conan_conf = client_cache.conan_config
                 _handle_conan_conf(conan_conf, os.path.join(root, f))
             elif f == "remotes.txt":
-                output.info("Defining remotes")
+                output.info("Defining remotes from remotes.txt")
                 _handle_remotes(client_cache, os.path.join(root, f))
             else:
                 relpath = os.path.relpath(root, folder)
@@ -94,7 +92,7 @@ def _process_folder(folder, client_cache, output):
                 shutil.copy(os.path.join(root, f), target_folder)
         for d in dirs:
             if d == "profiles":
-                output.info("Installing profiles")
+                output.info("Installing profiles:")
                 profiles_path = client_cache.profiles_path
                 _handle_profiles(os.path.join(root, d), profiles_path, output)
                 break
@@ -111,32 +109,76 @@ def _process_download(item, client_cache, output, tmp_folder, verify_ssl, reques
         raise ConanException("Error while installing config from %s\n%s" % (item, str(e)))
 
 
-def configuration_install(item, client_cache, output, verify_ssl, requester,
+def configuration_install(path_or_url, client_cache, output, verify_ssl, requester,
                           config_type=None, args=None):
+    if path_or_url is None:
+        try:
+            item = client_cache.conan_config.get_item("general.config_install")
+            _config_type, path_or_url, _args = _process_config_install_item(item)
+        except ConanException:
+            raise ConanException("Called config install without arguments and "
+                                 "'general.config_install' not defined in conan.conf")
+    else:
+        _config_type, path_or_url, _args = _process_config_install_item(path_or_url)
+
+    config_type = config_type or _config_type
+    args = args or _args
+
+    if os.path.exists(path_or_url):
+        path_or_url = os.path.abspath(path_or_url)
+
     tmp_folder = os.path.join(client_cache.conan_folder, "tmp_config_install")
     # necessary for Mac OSX, where the temp folders in /var/ are symlinks to /private/var/
     tmp_folder = os.path.realpath(tmp_folder)
     mkdir(tmp_folder)
     try:
-        if item is None:
-            try:
-                item = client_cache.conan_config.get_item("general.config_install")
-            except ConanException:
-                raise ConanException("Called config install without arguments and "
-                                     "'general.config_install' not defined in conan.conf")
-
-        if item.endswith(".git") or config_type == "git":
-            _process_git_repo(item, client_cache, output, tmp_folder, verify_ssl, args)
-        elif os.path.isdir(item):
-            _process_folder(item, client_cache, output)
-        elif os.path.isfile(item):
-            _process_zip_file(item, client_cache, output, tmp_folder)
-        elif item.startswith("http"):
-            _process_download(item, client_cache, output, tmp_folder, verify_ssl,
+
+        if config_type == "git":
+            _process_git_repo(path_or_url, client_cache, output, tmp_folder, verify_ssl, args)
+        elif config_type == "dir":
+            args = None
+            _process_folder(path_or_url, client_cache, output)
+        elif config_type == "file":
+            args = None
+            _process_zip_file(path_or_url, client_cache, output, tmp_folder)
+        elif config_type == "url":
+            args = None
+            _process_download(path_or_url, client_cache, output, tmp_folder, verify_ssl,
                               requester=requester)
         else:
-            raise ConanException("I don't know how to process %s" % item)
+            raise ConanException("Unable to process config install: %s" % path_or_url)
     finally:
-        if item:
-            client_cache.conan_config.set_item("general.config_install", item)
+        if config_type is not None and path_or_url is not None:
+            value = "%s:[%s, %s]" % (config_type, path_or_url, args)
+            client_cache.conan_config.set_item("general.config_install", value)
         rmdir(tmp_folder)
+
+
+def _process_config_install_item(item):
+    """
+    Processes a config_install item and outputs a tuple with the configuration type, the path/url
+    and additional args
+
+    :param item: config_install item value from conan.conf with a simple path/url or a string
+    following this pattern: "<config_type>:[<path_or_url>, <args>]"
+    :return: configuration source type (git, url, dir or file), path to file/dir or git/http url and
+    additional arguments
+    """
+    config_type, path_or_url, args = None, None, None
+    if not item.startswith(("git:", "dir:", "url:", "file:")):
+        path_or_url = item
+        if path_or_url.endswith(".git"):
+            config_type = "git"
+        elif os.path.isdir(path_or_url):
+            config_type = "dir"
+        elif os.path.isfile(path_or_url):
+            config_type = "file"
+        elif path_or_url.startswith("http"):
+            config_type = "url"
+        else:
+            raise ConanException("Unable to process config install: %s" % path_or_url)
+    else:
+        config_type, rest = item.split(":", 1)
+        path_or_url, args = [item.strip() for item in rest[1:-1].rstrip().split(",", 1)]
+        args = None if "none" in args.lower() else args
+    return config_type, path_or_url, args
diff --git a/conans/client/tools/scm.py b/conans/client/tools/scm.py
index 740ac7bf8..b0f43f852 100644
--- a/conans/client/tools/scm.py
+++ b/conans/client/tools/scm.py
@@ -58,7 +58,7 @@ class Git(SCMBase):
         # TODO: This should be a context manager
         return self.run("config http.sslVerify %s" % ("true" if self._verify_ssl else "false"))
 
-    def clone(self, url, branch=None):
+    def clone(self, url, branch=None, args=""):
         url = self.get_url_with_credentials(url)
         if os.path.exists(url):
             url = url.replace("\\", "/")  # Windows local directory
@@ -75,7 +75,7 @@ class Git(SCMBase):
             output += self.run("checkout -t origin/%s" % branch)
         else:
             branch_cmd = "--branch %s" % branch if branch else ""
-            output = self.run('clone "%s" . %s' % (url, branch_cmd))
+            output = self.run('clone "%s" . %s %s' % (url, branch_cmd, args))
             output += self._configure_ssl_verify()
 
         return output

conan config from a specific branch/tag from a git repository
To help us debug your issue please explain:

- [x] I've read the [CONTRIBUTING guide](https://raw.githubusercontent.com/conan-io/conan/develop/.github/CONTRIBUTING.md).
- [x] I've specified the Conan version, operating system version and any tool that can be relevant.
- [x] I've explained the steps to reproduce the error or the motivation/use case of the question/suggestion.

Conan version 1.7.4
Git version 1.8.3.1
Centos 7.1.503

I want to install the settings from a git repository, but from a specific branch or tag. I tried: 

```bash
conan config install "git@gitlab.gitlabserv.com:chreniuc/conan_config.git" --args "-b tag"
```

But  I get an error:

```bash
Trying to clone repo  git@gitlab.gitlabserv.com:chreniuc/conan_config.git
Unknown option: -b
usage: git [--version] [--help] [-c name=value]
           [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
           [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]
           [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
           <command> [<args>]
ERROR: config install error. Can't clone repo: Command 'git -c http.sslVerify=True -b tag clone "git@gitlab.gitlabserv.com:chreniuc/conan_config.git" config' returned non-zero exit status 129
```

I also tried:

```bash
conan config install "git@gitlab.gitlabserver.com:chreniuc/conan_config.git -b master"
```

But I got this error:

```bash
ERROR: I don't know how to process git@gitlab.gitlabserver.com:chreniuc/conan_config.git -b master
```

Does conan support this feature? Am I missing something? I tried to look for an example, but I couldn't find any or any documentation related to this.

The use case for this is: we want to have different versions of the config for conan. We have a git repository and tags for each version. Can this be achieved?

Also, another thing to notice is that, when you run:
```bash
 conan config install --help
```
For **--args** you get:
```bash
String with extra arguments for "git clone"
```

But if you take a look at the command that was generated by conan, you can see that those args are passed to the `git` command not to the `git clone`:

```bash
Command 'git -c http.sslVerify=True -b tag clone "git@gitlab.gitlabserv.com:chreniuc/conan_config.git" config' returned non-zero exit status 129
```

diff --git a/conans/test/functional/command/config_install_test.py b/conans/test/functional/command/config_install_test.py
index f9a327ffb..febdad8c1 100644
--- a/conans/test/functional/command/config_install_test.py
+++ b/conans/test/functional/command/config_install_test.py
@@ -180,7 +180,7 @@ class Pkg(ConanFile):
         """
         zippath = self._create_zip()
         self.client.run('config install "%s"' % zippath)
-        self._check(zippath)
+        self._check("file:[%s, None]" % zippath)
         self.assertTrue(os.path.exists(zippath))
 
     def install_dir_test(self):
@@ -189,7 +189,7 @@ class Pkg(ConanFile):
         folder = self._create_profile_folder()
         self.assertTrue(os.path.isdir(folder))
         self.client.run('config install "%s"' % folder)
-        self._check(folder)
+        self._check("dir:[%s, None]" % folder)
 
     def test_without_profile_folder(self):
         shutil.rmtree(self.client.client_cache.profiles_path)
@@ -209,17 +209,17 @@ class Pkg(ConanFile):
 
         with patch.object(Downloader, 'download', new=my_download):
             self.client.run("config install http://myfakeurl.com/myconf.zip")
-            self._check("http://myfakeurl.com/myconf.zip")
+            self._check("url:[http://myfakeurl.com/myconf.zip, None]")
 
             # repeat the process to check
             self.client.run("config install http://myfakeurl.com/myconf.zip")
-            self._check("http://myfakeurl.com/myconf.zip")
+            self._check("url:[http://myfakeurl.com/myconf.zip, None]")
 
     def failed_install_repo_test(self):
         """ should install from a git repo
         """
         self.client.run('config install notexistingrepo.git', assert_error=True)
-        self.assertIn("ERROR: config install error. Can't clone repo", self.client.out)
+        self.assertIn("ERROR: Can't clone repo", self.client.out)
 
     def failed_install_http_test(self):
         """ should install from a http zip
@@ -241,7 +241,8 @@ class Pkg(ConanFile):
             self.client.runner('git commit -m "mymsg"')
 
         self.client.run('config install "%s/.git"' % folder)
-        self._check("%s/.git" % folder)
+        check_path = os.path.join(folder, ".git")
+        self._check("git:[%s, None]" % check_path)
 
     def install_repo_relative_test(self):
         relative_folder = "./config"
@@ -256,7 +257,7 @@ class Pkg(ConanFile):
             self.client.runner('git commit -m "mymsg"')
 
         self.client.run('config install "%s/.git"' % relative_folder)
-        self._check(os.path.join("%s" % folder, ".git"))
+        self._check("git:[%s, None]" % os.path.join("%s" % folder, ".git"))
 
     def install_custom_args_test(self):
         """ should install from a git repo
@@ -270,8 +271,9 @@ class Pkg(ConanFile):
             self.client.runner('git config user.email myname@mycompany.com')
             self.client.runner('git commit -m "mymsg"')
 
-        self.client.run('config install "%s/.git" --args="-c init.templateDir=\"\""' % folder)
-        self._check("%s/.git" % folder)
+        self.client.run('config install "%s/.git" --args="-c init.templateDir=value"' % folder)
+        check_path = os.path.join(folder, ".git")
+        self._check("git:[%s, -c init.templateDir=value]" % check_path)
 
     def force_git_type_test(self):
         client = TestClient()
@@ -284,7 +286,7 @@ class Pkg(ConanFile):
         zippath = self._create_zip()
         self.client.run('config set general.config_install="%s"' % zippath)
         self.client.run("config install")
-        self._check(zippath)
+        self._check("file:[%s, None]" % zippath)
 
     def reinstall_error_test(self):
         """ should use configured URL in conan.conf
@@ -341,7 +343,7 @@ class Pkg(ConanFile):
             self.assertIn(fake_url_hidden_password, self.client.out)
 
             # Check credentials still stored in configuration
-            self._check(fake_url_with_credentials)
+            self._check("url:[%s, None]" % fake_url_with_credentials)
 
     def ssl_verify_test(self):
         fake_url = "https://fakeurl.com/myconf.zip"
@@ -359,3 +361,49 @@ class Pkg(ConanFile):
 
         with patch.object(Downloader, 'download', new=download_verify_true):
             self.client.run("config install %s --verify-ssl=True" % fake_url)
+
+    def test_git_checkout_is_possible(self):
+        folder = self._create_profile_folder()
+        with tools.chdir(folder):
+            self.client.runner('git init .')
+            self.client.runner('git add .')
+            self.client.runner('git config user.name myname')
+            self.client.runner('git config user.email myname@mycompany.com')
+            self.client.runner('git commit -m "mymsg"')
+            self.client.runner('git checkout -b other_branch')
+            save(os.path.join(folder, "hooks", "cust", "cust.py"), "")
+            self.client.runner('git add .')
+            self.client.runner('git commit -m "my file"')
+            self.client.runner('git tag 0.0.1')
+            self.client.runner('git checkout master')
+
+        # Without checkout
+        self.client.run('config install "%s/.git"' % folder)
+        check_path = os.path.join(folder, ".git")
+        self._check("git:[%s, None]" % check_path)
+        file_path = os.path.join(self.client.client_cache.conan_folder, "hooks", "cust", "cust.py")
+        self.assertFalse(os.path.exists(file_path))
+        # With checkout tag and reuse url
+        self.client.run('config install --args="-b 0.0.1"')
+        check_path = os.path.join(folder, ".git")
+        self._check("git:[%s, -b 0.0.1]" % check_path)
+        self.assertTrue(os.path.exists(file_path))
+        # With checkout branch and reuse url
+        self.client.run('config install --args="-b other_branch"')
+        check_path = os.path.join(folder, ".git")
+        self._check("git:[%s, -b other_branch]" % check_path)
+        self.assertTrue(os.path.exists(file_path))
+        # Add changes to that branch and update
+        with tools.chdir(folder):
+            self.client.runner('git checkout other_branch')
+            save(os.path.join(folder, "hooks", "other", "other.py"), "")
+            self.client.runner('git add .')
+            self.client.runner('git commit -m "my other file"')
+            self.client.runner('git checkout master')
+        other_path = os.path.join(self.client.client_cache.conan_folder, "hooks", "other",
+                                  "other.py")
+        self.assertFalse(os.path.exists(other_path))
+        self.client.run('config install')
+        check_path = os.path.join(folder, ".git")
+        self._check("git:[%s, -b other_branch]" % check_path)
+        self.assertTrue(os.path.exists(other_path))
diff --git a/conans/test/unittests/client/conf/__init__.py b/conans/test/unittests/client/conf/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/conans/test/unittests/client/conf/config_installer.py b/conans/test/unittests/client/conf/config_installer.py
new file mode 100644
index 000000000..de62ed915
--- /dev/null
+++ b/conans/test/unittests/client/conf/config_installer.py
@@ -0,0 +1,57 @@
+import os
+import unittest
+from parameterized import parameterized
+
+from conans.client.conf.config_installer import _process_config_install_item
+from conans.errors import ConanException
+from conans.test.utils.test_files import temp_folder
+from conans.util.files import save
+
+
+class ConfigInstallerTests(unittest.TestCase):
+
+    def process_config_install_item_test(self):
+        config_type, url_or_path, args = _process_config_install_item(
+                "git:[whaterver.url.com/repo.git, --recusrive --other -b 0.3.4]")
+        self.assertEqual("git", config_type)
+        self.assertEqual("whaterver.url.com/repo.git", url_or_path)
+        self.assertEqual("--recusrive --other -b 0.3.4", args)
+
+        config_type, url_or_path, args = _process_config_install_item("whaterver.url.com/repo.git")
+        self.assertEqual("git", config_type)
+        self.assertEqual("whaterver.url.com/repo.git", url_or_path)
+        self.assertIsNone(args)
+
+        dir_path = temp_folder()
+        for dir_item in ["dir:[%s, None]" % dir_path, dir_path]:
+            config_type, url_or_path, args = _process_config_install_item(dir_item)
+            self.assertEqual("dir", config_type)
+            self.assertEqual(dir_path, url_or_path)
+            self.assertIsNone(args)
+
+        file_path = os.path.join(dir_path, "file.zip")
+        save(file_path, "")
+        for file_item in ["file:[%s, None]" % file_path, file_path]:
+            config_type, url_or_path, args = _process_config_install_item(file_item)
+            self.assertEqual("file", config_type)
+            self.assertEqual(file_path, url_or_path)
+            self.assertIsNone(args)
+
+        for url_item in ["url:[http://is/an/absloute/path with spaces/here/file.zip, None]",
+                         "http://is/an/absloute/path with spaces/here/file.zip"]:
+            config_type, url_or_path, args = _process_config_install_item(url_item)
+            self.assertEqual("url", config_type)
+            self.assertEqual("http://is/an/absloute/path with spaces/here/file.zip", url_or_path)
+            self.assertIsNone(args)
+
+        config_type, url, args = _process_config_install_item(
+                "url:[http://is/an/absloute/path with spaces/here/file.zip, --option]")
+        self.assertEqual("url", config_type)
+        self.assertEqual("http://is/an/absloute/path with spaces/here/file.zip", url)
+        self.assertEqual("--option", args)
+
+        # Test wrong input
+        for item in ["git@github.com:conan-io/conan.git, None"
+                     "file/not/exists.zip"]:
+            with self.assertRaisesRegex(ConanException, "Unable to process config install"):
+                _, _, _ = _process_config_install_item(item)

pip install -e .[dev]
parse_log_pytest
requirements.txt
nose nose-cov pytest
apt-get update apt-get install -y gcc g++-multilib wget unzip
3.6
conans/requirements.txt conans/requirements_server.txt conans/requirements_dev.txt
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
astroid==2.11.7
attrs==22.2.0
beautifulsoup4==4.12.3
bottle==0.12.25
certifi==2021.5.30
charset-normalizer==2.0.12
codecov==2.1.13
colorama==0.4.5
-e git+https://github.com/conan-io/conan.git@e250f738c68383c06b46dde32fe386d160c5bd5a#egg=conan
cov-core==1.15.0
coverage==4.2
deprecation==2.0.7
dill==0.3.4
distro==1.1.0
fasteners==0.19
future==0.16.0
idna==3.10
importlib-metadata==4.8.3
importlib-resources==5.4.0
iniconfig==1.1.1
isort==5.10.1
lazy-object-proxy==1.7.1
mccabe==0.7.0
mock==1.3.0
node-semver==0.6.1
nose==1.3.7
nose-cov==1.6
packaging==21.3
parameterized==0.8.1
patch==1.16
pbr==6.1.1
platformdirs==2.4.0
pluggy==1.0.0
pluginbase==0.7
py==1.11.0
Pygments==2.14.0
PyJWT==1.7.1
pylint==2.13.9
pyparsing==3.1.4
pytest==7.0.1
PyYAML==3.13
requests==2.27.1
six==1.17.0
soupsieve==2.3.2.post1
tomli==1.2.3
tqdm==4.64.1
typed-ast==1.5.5
typing_extensions==4.1.1
urllib3==1.26.20
waitress==2.0.0
WebOb==1.8.9
WebTest==2.0.35
wrapt==1.16.0
zipp==3.6.0

name: conan
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - ca-certificates=2025.2.25=h06a4308_0
  - certifi=2021.5.30=py36h06a4308_0
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.3=he6710b0_2
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - ncurses=6.4=h6a678d5_0
  - openssl=1.1.1w=h7f8727e_0
  - pip=21.2.2=py36h06a4308_0
  - python=3.6.13=h12debd9_1
  - readline=8.2=h5eee18b_0
  - setuptools=58.0.4=py36h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - wheel=0.37.1=pyhd3eb1b0_0
  - xz=5.6.4=h5eee18b_1
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - astroid==2.11.7
      - attrs==22.2.0
      - beautifulsoup4==4.12.3
      - bottle==0.12.25
      - charset-normalizer==2.0.12
      - codecov==2.1.13
      - colorama==0.4.5
      - cov-core==1.15.0
      - coverage==4.2
      - deprecation==2.0.7
      - dill==0.3.4
      - distro==1.1.0
      - fasteners==0.19
      - future==0.16.0
      - idna==3.10
      - importlib-metadata==4.8.3
      - importlib-resources==5.4.0
      - iniconfig==1.1.1
      - isort==5.10.1
      - lazy-object-proxy==1.7.1
      - mccabe==0.7.0
      - mock==1.3.0
      - node-semver==0.6.1
      - nose==1.3.7
      - nose-cov==1.6
      - packaging==21.3
      - parameterized==0.8.1
      - patch==1.16
      - pbr==6.1.1
      - platformdirs==2.4.0
      - pluggy==1.0.0
      - pluginbase==0.7
      - py==1.11.0
      - pygments==2.14.0
      - pyjwt==1.7.1
      - pylint==2.13.9
      - pyparsing==3.1.4
      - pytest==7.0.1
      - pyyaml==3.13
      - requests==2.27.1
      - six==1.17.0
      - soupsieve==2.3.2.post1
      - tomli==1.2.3
      - tqdm==4.64.1
      - typed-ast==1.5.5
      - typing-extensions==4.1.1
      - urllib3==1.26.20
      - waitress==2.0.0
      - webob==1.8.9
      - webtest==2.0.35
      - wrapt==1.16.0
      - zipp==3.6.0
prefix: /opt/conda/envs/conan

conans/test/functional/command/config_install_test.py::ConfigInstallTest::test_git_checkout_is_possible conans/test/functional/command/config_install_test.py::ConfigInstallTest::test_without_profile_folder
conans/client/conf/config_installer.py conans/client/conan_api.py conans/client/tools/scm.py
conans/client/conf/config_installer.py conans/client/conan_api.py conans/client/tools/scm.py