[optimize] early-ignore dependencies not matching chosen markers

docs/dependency-specification.md

@@ -228,3 +228,31 @@ markers = "platform_python_implementation == 'CPython'"
 The same information is still present, and ends up providing the exact
 same specification. It's simply split into multiple, slightly more readable,
 lines.
+
+## Optimizing by environment pre-filtering
+
+Poetry may take long to build a lock when they are exponentially many combinations of downstream packages, due to different variants of OS, platform architecture, Python versions and so on.
+
+With this [PR 4956 ](https://github.com/python-poetry/poetry/pull/4956) we can narrow down the search space in the beginning.
+
+As a real use-case consider Azure packages
+```
+[tool.poetry]
+name = "test"
+version = "0.1.0"
+description = "demonstrates that poetry triggers overrides to easily (can be early pruned?)"
+authors = ["Maciej Skorski <maciej.skorski@gmail.com>"]
+
+[tool.poetry.dependencies]
+python = "~3.8"
+azureml-dataset-runtime = {version="1.37.0"}
+```
+
+Installing with debugging `poetry install --dry-run -vv` reveals that poetry considers many package combinations for Windows.
+However, after adding the section `tool.poetry.dependencies` and specifying [environment markers](https://www.python.org/dev/peps/pep-0508/#environment-markers) there is no branching anymore.
+
+```
+[tool.poetry.target_env]
+sys_platform = "linux"
+platform_system = "Linux"
+```

src/poetry/console/commands/install.py

@@ -67,6 +67,13 @@ class InstallCommand(InstallerCommand):
             flag=False,
             multiple=True,
         ),
+        option(
+            "match-marker",
+            None,
+            "List of environment markers to be matched early, to speed up resolving dependencies (see PEP 508).",
+            flag=False,
+            multiple=True,
+        ),
     ]
 
     help = """The <info>install</info> command reads the <comment>poetry.lock</> file from
@@ -94,6 +101,10 @@ def handle(self) -> int:
             self.poetry.config.get("experimental.new-installer", False)
         )
 
+        markers_to_filter = self.option("match-marker")
+        if markers_to_filter:
+            self._installer.match_markers(markers_to_filter)
+
         extras = []
         for extra in self.option("extras"):
             if " " in extra:

src/poetry/factory.py

@@ -37,6 +37,14 @@ def create_poetry(
         if io is None:
             io = NullIO()
 
+        # redirect to the extended schema (from poetry, not from poetry-core)
+        import os
+
+        import poetry.core.json
+
+        poetry.core.json.SCHEMA_DIR = os.path.join(
+            os.path.dirname(__file__), "json/schemas/extended"
+        )
         base_poetry = super().create_poetry(cwd)
 
         locker = Locker(

src/poetry/installation/installer.py

@@ -66,6 +66,8 @@ def __init__(
 
         self._extras = []
 
+        self._match_markers = []
+
         if executor is None:
             executor = Executor(self._env, self._pool, config, self._io)
 
@@ -190,6 +192,11 @@ def extras(self, extras: list) -> "Installer":
 
         return self
 
+    def match_markers(self, markers: list) -> "Installer":
+        self._match_markers = markers
+
+        return self
+
     def use_executor(self, use_executor: bool = True) -> "Installer":
         self._use_executor = use_executor
 
@@ -249,7 +256,21 @@ def _do_install(self, local_repo: Repository) -> int:
                 self._io,
             )
 
-            ops = solver.solve(use_latest=self._whitelist).calculate_operations()
+            if (
+                hasattr(self._locker, "_local_config")
+                and "target_env" in self._locker._local_config
+            ):
+                # load and format as VirtualEnv from poetry.utils.env
+                markers_to_filter = self._locker._local_config["target_env"]
+                if markers_to_filter:
+                    version_info = markers_to_filter.get("version_info")
+                    if version_info:
+                        markers_to_filter["version_info"] = tuple(version_info)
+            else:
+                markers_to_filter = {}
+
+            with solver.use_markers_filter(markers_to_filter):
+                ops = solver.solve(use_latest=self._whitelist).calculate_operations()
         else:
             self._io.write_line("<info>Installing dependencies from lock file</>")