req-compile 1.2.0__tar.gz → 1.3.0__tar.gz

{req_compile-1.2.0 → req_compile-1.3.0}/CHANGELOG.rst

@@ -1,5 +1,21 @@
 New in version 1.2.0:
 
+* ``requirements.parse`` now maps lock files to ids in ``requirements_locks`` and config settings to those
+  ids in the new ``config_settings`` attribute. Both are label keyed, so each is resolved by the module
+  defining the hub and any config setting visible to it can be used. ``//conditions:default`` names a
+  fallback lock. Without ``config_settings``, locks compiled with the ``platform`` attribute of
+  ``py_reqs_compiler`` are selected by the platform read from the header of the file. Label strings as
+  ``requirements_locks`` values still work but are deprecated.
+* Every distinct wheel is downloaded once into a repository named ``{package}_{version}_{sha256[:8]}``
+  and shared by all hubs of all modules pinning it. Each hub keeps its own dependency edges, so extras
+  and version differences between hubs are preserved. Hub names must be unique across modules.
+* ``package_annotation`` applies to the hubs of the module declaring it unless its new ``hubs``
+  attribute names particular hubs or ``"*"`` for every hub. Hubs annotated differently get their own
+  repository for the package.
+* Hubs whose locks do not all contain the same packages are supported. A package missing from a lock
+  is incompatible with that lock's platform, so targets depending on it are skipped there.
+* Removed the ``defs_id_map`` attribute of the ``parse`` tag and the WORKSPACE-only ``repositories()``
+  flow. ``py_requirements_repository`` is now only instantiated by the module extension.
 * Cross-platform compilation. ``--platform``, ``--python-version`` and ``--implementation`` select
   wheels and evaluate environment markers for an environment other than the one running ``req-compile``.
   ``--platform`` takes a wheel platform tag such as ``manylinux_2_28_x86_64`` or ``macosx_11_0_arm64``,

{req_compile-1.2.0/req_compile.egg-info → req_compile-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: req-compile
-Version: 1.2.0
+Version: 1.3.0
 Summary: Python requirements compiler
 Home-page: https://github.com/periareon/req-compile
 Author: Spencer Putt
@@ -40,6 +40,22 @@ Dynamic: summary
 
 New in version 1.2.0:
 
+* ``requirements.parse`` now maps lock files to ids in ``requirements_locks`` and config settings to those
+  ids in the new ``config_settings`` attribute. Both are label keyed, so each is resolved by the module
+  defining the hub and any config setting visible to it can be used. ``//conditions:default`` names a
+  fallback lock. Without ``config_settings``, locks compiled with the ``platform`` attribute of
+  ``py_reqs_compiler`` are selected by the platform read from the header of the file. Label strings as
+  ``requirements_locks`` values still work but are deprecated.
+* Every distinct wheel is downloaded once into a repository named ``{package}_{version}_{sha256[:8]}``
+  and shared by all hubs of all modules pinning it. Each hub keeps its own dependency edges, so extras
+  and version differences between hubs are preserved. Hub names must be unique across modules.
+* ``package_annotation`` applies to the hubs of the module declaring it unless its new ``hubs``
+  attribute names particular hubs or ``"*"`` for every hub. Hubs annotated differently get their own
+  repository for the package.
+* Hubs whose locks do not all contain the same packages are supported. A package missing from a lock
+  is incompatible with that lock's platform, so targets depending on it are skipped there.
+* Removed the ``defs_id_map`` attribute of the ``parse`` tag and the WORKSPACE-only ``repositories()``
+  flow. ``py_requirements_repository`` is now only instantiated by the module extension.
 * Cross-platform compilation. ``--platform``, ``--python-version`` and ``--implementation`` select
   wheels and evaluate environment markers for an environment other than the one running ``req-compile``.
   ``--platform`` takes a wheel platform tag such as ``manylinux_2_28_x86_64`` or ``macosx_11_0_arm64``,
@@ -114,19 +130,26 @@ To get started with Bazel, add the following to your ``MODULE.bazel`` file:
     # Find {version} on the req-compile GitHub releases page.
     bazel_dep(name = "rules_req_compile", version = "{version}")
 
-    requirements = use_extension("//extensions:python.bzl", "requirements")
+    requirements = use_extension("@rules_req_compile//extensions:python.bzl", "requirements")
     requirements.parse(
         name = "my_pip_deps",
         requirements_locks = {
-            "//3rdparty:requirements.linux.txt": "@platforms//os:linux",
-            "//3rdparty:requirements.macos.txt": "@platforms//os:macos",
-            "//3rdparty:requirements.windows.txt": "@platforms//os:windows",
+            "//3rdparty:requirements.linux_x86_64.txt": "linux_x86_64",
+            "//3rdparty:requirements.macos_aarch64.txt": "macos_aarch64",
+            "//3rdparty:requirements.windows_x86_64.txt": "windows_x86_64",
         },
     )
     use_repo(requirements, "my_pip_deps")
 
-The solutions for every platform can be compiled from a single machine with the ``platform`` attribute of
-``py_reqs_compiler``. See the `Bazel rules documentation <docs/docs.md>`_ for details.
+Each lock is the solution for one platform and is given an id. Locks compiled with the ``platform``
+attribute of ``py_reqs_compiler`` record their platform, which is used to select them. To decide
+yourself, map your own ``config_setting`` labels to the lock ids with ``config_settings``. The solutions
+for every platform can be compiled from a single machine.
+
+Every wheel is downloaded once and shared by all the hubs of all the modules pinning it, while each hub
+keeps the dependencies it resolved. Packages missing from the lock of a platform make the targets using
+them incompatible with that platform instead of failing the build.
+See the `Bazel rules documentation <docs/docs.md>`_ for details.
 
 
 Why use it?

{req_compile-1.2.0 → req_compile-1.3.0}/README.rst

@@ -36,19 +36,26 @@ To get started with Bazel, add the following to your ``MODULE.bazel`` file:
     # Find {version} on the req-compile GitHub releases page.
     bazel_dep(name = "rules_req_compile", version = "{version}")
 
-    requirements = use_extension("//extensions:python.bzl", "requirements")
+    requirements = use_extension("@rules_req_compile//extensions:python.bzl", "requirements")
     requirements.parse(
         name = "my_pip_deps",
         requirements_locks = {
-            "//3rdparty:requirements.linux.txt": "@platforms//os:linux",
-            "//3rdparty:requirements.macos.txt": "@platforms//os:macos",
-            "//3rdparty:requirements.windows.txt": "@platforms//os:windows",
+            "//3rdparty:requirements.linux_x86_64.txt": "linux_x86_64",
+            "//3rdparty:requirements.macos_aarch64.txt": "macos_aarch64",
+            "//3rdparty:requirements.windows_x86_64.txt": "windows_x86_64",
         },
     )
     use_repo(requirements, "my_pip_deps")
 
-The solutions for every platform can be compiled from a single machine with the ``platform`` attribute of
-``py_reqs_compiler``. See the `Bazel rules documentation <docs/docs.md>`_ for details.
+Each lock is the solution for one platform and is given an id. Locks compiled with the ``platform``
+attribute of ``py_reqs_compiler`` record their platform, which is used to select them. To decide
+yourself, map your own ``config_setting`` labels to the lock ids with ``config_settings``. The solutions
+for every platform can be compiled from a single machine.
+
+Every wheel is downloaded once and shared by all the hubs of all the modules pinning it, while each hub
+keeps the dependencies it resolved. Packages missing from the lock of a platform make the targets using
+them incompatible with that platform instead of failing the build.
+See the `Bazel rules documentation <docs/docs.md>`_ for details.
 
 
 Why use it?

{req_compile-1.2.0 → req_compile-1.3.0}/req_compile/target.py

@@ -90,14 +90,10 @@ def _mac_platform_tags(
             arch = plat_arch
         key = (major, minor)
 
-        # Universal and arm tags are ranked higher.
+        # packaging already yields x86_64 and intel for an x86_64 target.
+        # Never add them for arm64: a native arm64 interpreter cannot load them.
         mac_platforms[key].add(plat)
 
-        if major == 10 and plat_arch == "universal2":
-            mac_platforms[key].add(plat.replace(plat_arch, "x86_64"))
-            if int(minor) <= 10:
-                mac_platforms[key].add(plat.replace(plat_arch, "intel"))
-
     def _rank(plat: str) -> Tuple[int, str]:
         # Within a release, prefer wheels built for exactly this architecture,
         # then universal wheels, then anything else.

{req_compile-1.2.0 → req_compile-1.3.0/req_compile.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: req-compile
-Version: 1.2.0
+Version: 1.3.0
 Summary: Python requirements compiler
 Home-page: https://github.com/periareon/req-compile
 Author: Spencer Putt
@@ -40,6 +40,22 @@ Dynamic: summary
 
 New in version 1.2.0:
 
+* ``requirements.parse`` now maps lock files to ids in ``requirements_locks`` and config settings to those
+  ids in the new ``config_settings`` attribute. Both are label keyed, so each is resolved by the module
+  defining the hub and any config setting visible to it can be used. ``//conditions:default`` names a
+  fallback lock. Without ``config_settings``, locks compiled with the ``platform`` attribute of
+  ``py_reqs_compiler`` are selected by the platform read from the header of the file. Label strings as
+  ``requirements_locks`` values still work but are deprecated.
+* Every distinct wheel is downloaded once into a repository named ``{package}_{version}_{sha256[:8]}``
+  and shared by all hubs of all modules pinning it. Each hub keeps its own dependency edges, so extras
+  and version differences between hubs are preserved. Hub names must be unique across modules.
+* ``package_annotation`` applies to the hubs of the module declaring it unless its new ``hubs``
+  attribute names particular hubs or ``"*"`` for every hub. Hubs annotated differently get their own
+  repository for the package.
+* Hubs whose locks do not all contain the same packages are supported. A package missing from a lock
+  is incompatible with that lock's platform, so targets depending on it are skipped there.
+* Removed the ``defs_id_map`` attribute of the ``parse`` tag and the WORKSPACE-only ``repositories()``
+  flow. ``py_requirements_repository`` is now only instantiated by the module extension.
 * Cross-platform compilation. ``--platform``, ``--python-version`` and ``--implementation`` select
   wheels and evaluate environment markers for an environment other than the one running ``req-compile``.
   ``--platform`` takes a wheel platform tag such as ``manylinux_2_28_x86_64`` or ``macosx_11_0_arm64``,
@@ -114,19 +130,26 @@ To get started with Bazel, add the following to your ``MODULE.bazel`` file:
     # Find {version} on the req-compile GitHub releases page.
     bazel_dep(name = "rules_req_compile", version = "{version}")
 
-    requirements = use_extension("//extensions:python.bzl", "requirements")
+    requirements = use_extension("@rules_req_compile//extensions:python.bzl", "requirements")
     requirements.parse(
         name = "my_pip_deps",
         requirements_locks = {
-            "//3rdparty:requirements.linux.txt": "@platforms//os:linux",
-            "//3rdparty:requirements.macos.txt": "@platforms//os:macos",
-            "//3rdparty:requirements.windows.txt": "@platforms//os:windows",
+            "//3rdparty:requirements.linux_x86_64.txt": "linux_x86_64",
+            "//3rdparty:requirements.macos_aarch64.txt": "macos_aarch64",
+            "//3rdparty:requirements.windows_x86_64.txt": "windows_x86_64",
         },
     )
     use_repo(requirements, "my_pip_deps")
 
-The solutions for every platform can be compiled from a single machine with the ``platform`` attribute of
-``py_reqs_compiler``. See the `Bazel rules documentation <docs/docs.md>`_ for details.
+Each lock is the solution for one platform and is given an id. Locks compiled with the ``platform``
+attribute of ``py_reqs_compiler`` record their platform, which is used to select them. To decide
+yourself, map your own ``config_setting`` labels to the lock ids with ``config_settings``. The solutions
+for every platform can be compiled from a single machine.
+
+Every wheel is downloaded once and shared by all the hubs of all the modules pinning it, while each hub
+keeps the dependencies it resolved. Packages missing from the lock of a platform make the targets using
+them incompatible with that platform instead of failing the build.
+See the `Bazel rules documentation <docs/docs.md>`_ for details.
 
 
 Why use it?

{req_compile-1.2.0 → req_compile-1.3.0}/tests/test_repositories.py

@@ -2,6 +2,7 @@ import random
 import sys
 
 import pytest
+from req_compile.target import TargetEnvironment
 from req_compile.utils import parse_version
 
 from req_compile.repos.repository import (
@@ -165,8 +166,9 @@ def test_sort_macos():
         ["macosx_10_9_x86_64"],
         None,
     )
-    assert candidate1.sortkey > candidate2.sortkey
-    assert candidate2.sortkey > candidate3.sortkey
+    target = TargetEnvironment.from_spec("macosx_10_15_x86_64", "3.7")
+    assert candidate1.sort_key(target) > candidate2.sort_key(target)
+    assert candidate2.sort_key(target) > candidate3.sort_key(target)
 
 
 @pytest.mark.parametrize(

{req_compile-1.2.0 → req_compile-1.3.0}/tests/test_target.py

@@ -273,8 +273,9 @@ WINDOWS = TargetEnvironment.from_spec("win_amd64", "3.11")
         ("cp311-cp311-musllinux_1_2_x86_64", []),
         ("cp311-cp311-macosx_11_0_arm64", [MACOS]),
         ("cp311-cp311-macosx_10_9_universal2", [MACOS, MACOS_INTEL]),
-        ("cp311-cp311-macosx_10_9_x86_64", [MACOS, MACOS_INTEL]),
-        ("cp311-cp311-macosx_10_15_x86_64", [MACOS, MACOS_INTEL]),
+        ("cp311-cp311-macosx_10_9_x86_64", [MACOS_INTEL]),
+        ("cp311-cp311-macosx_10_9_intel", [MACOS_INTEL]),
+        ("cp311-cp311-macosx_10_15_x86_64", [MACOS_INTEL]),
         ("cp311-cp311-macosx_12_0_arm64", []),
         ("cp311-cp311-win_amd64", [WINDOWS]),
         ("cp311-cp311-win32", []),

{req_compile-1.2.0 → req_compile-1.3.0}/version.bzl

@@ -1,3 +1,3 @@
 """req-compile version"""
 
-VERSION = "1.2.0"
+VERSION = "1.3.0"