| import unittest |
| from unittest import mock |
| |
| from python.private.pypi.whl_installer import wheel |
| from python.private.pypi.whl_installer.platform import OS, Arch, Platform |
| |
| _HOST_INTERPRETER_FN = ( |
| "python.private.pypi.whl_installer.wheel.host_interpreter_minor_version" |
| ) |
| |
| |
| class DepsTest(unittest.TestCase): |
| def test_simple(self): |
| deps = wheel.Deps("foo", requires_dist=["bar"]) |
| |
| got = deps.build() |
| |
| self.assertIsInstance(got, wheel.FrozenDeps) |
| self.assertEqual(["bar"], got.deps) |
| self.assertEqual({}, got.deps_select) |
| |
| def test_can_add_os_specific_deps(self): |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=[ |
| "bar", |
| "an_osx_dep; sys_platform=='darwin'", |
| "posix_dep; os_name=='posix'", |
| "win_dep; os_name=='nt'", |
| ], |
| platforms={ |
| Platform(os=OS.linux, arch=Arch.x86_64), |
| Platform(os=OS.osx, arch=Arch.x86_64), |
| Platform(os=OS.osx, arch=Arch.aarch64), |
| Platform(os=OS.windows, arch=Arch.x86_64), |
| }, |
| ) |
| |
| got = deps.build() |
| |
| self.assertEqual(["bar"], got.deps) |
| self.assertEqual( |
| { |
| "@platforms//os:linux": ["posix_dep"], |
| "@platforms//os:osx": ["an_osx_dep", "posix_dep"], |
| "@platforms//os:windows": ["win_dep"], |
| }, |
| got.deps_select, |
| ) |
| |
| def test_can_add_os_specific_deps_with_specific_python_version(self): |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=[ |
| "bar", |
| "an_osx_dep; sys_platform=='darwin'", |
| "posix_dep; os_name=='posix'", |
| "win_dep; os_name=='nt'", |
| ], |
| platforms={ |
| Platform(os=OS.linux, arch=Arch.x86_64, minor_version=8), |
| Platform(os=OS.osx, arch=Arch.x86_64, minor_version=8), |
| Platform(os=OS.osx, arch=Arch.aarch64, minor_version=8), |
| Platform(os=OS.windows, arch=Arch.x86_64, minor_version=8), |
| }, |
| ) |
| |
| got = deps.build() |
| |
| self.assertEqual(["bar"], got.deps) |
| self.assertEqual( |
| { |
| "@platforms//os:linux": ["posix_dep"], |
| "@platforms//os:osx": ["an_osx_dep", "posix_dep"], |
| "@platforms//os:windows": ["win_dep"], |
| }, |
| got.deps_select, |
| ) |
| |
| def test_deps_are_added_to_more_specialized_platforms(self): |
| got = wheel.Deps( |
| "foo", |
| requires_dist=[ |
| "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", |
| "mac_dep; sys_platform=='darwin'", |
| ], |
| platforms={ |
| Platform(os=OS.osx, arch=Arch.x86_64), |
| Platform(os=OS.osx, arch=Arch.aarch64), |
| }, |
| ).build() |
| |
| self.assertEqual( |
| wheel.FrozenDeps( |
| deps=[], |
| deps_select={ |
| "osx_aarch64": ["m1_dep", "mac_dep"], |
| "@platforms//os:osx": ["mac_dep"], |
| }, |
| ), |
| got, |
| ) |
| |
| def test_deps_from_more_specialized_platforms_are_propagated(self): |
| got = wheel.Deps( |
| "foo", |
| requires_dist=[ |
| "a_mac_dep; sys_platform=='darwin'", |
| "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", |
| ], |
| platforms={ |
| Platform(os=OS.osx, arch=Arch.x86_64), |
| Platform(os=OS.osx, arch=Arch.aarch64), |
| }, |
| ).build() |
| |
| self.assertEqual([], got.deps) |
| self.assertEqual( |
| { |
| "osx_aarch64": ["a_mac_dep", "m1_dep"], |
| "@platforms//os:osx": ["a_mac_dep"], |
| }, |
| got.deps_select, |
| ) |
| |
| def test_non_platform_markers_are_added_to_common_deps(self): |
| got = wheel.Deps( |
| "foo", |
| requires_dist=[ |
| "bar", |
| "baz; implementation_name=='cpython'", |
| "m1_dep; sys_platform=='darwin' and platform_machine=='arm64'", |
| ], |
| platforms={ |
| Platform(os=OS.linux, arch=Arch.x86_64), |
| Platform(os=OS.osx, arch=Arch.x86_64), |
| Platform(os=OS.osx, arch=Arch.aarch64), |
| Platform(os=OS.windows, arch=Arch.x86_64), |
| }, |
| ).build() |
| |
| self.assertEqual(["bar", "baz"], got.deps) |
| self.assertEqual( |
| { |
| "osx_aarch64": ["m1_dep"], |
| }, |
| got.deps_select, |
| ) |
| |
| def test_self_is_ignored(self): |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=[ |
| "bar", |
| "req_dep; extra == 'requests'", |
| "foo[requests]; extra == 'ssl'", |
| "ssl_lib; extra == 'ssl'", |
| ], |
| extras={"ssl"}, |
| ) |
| |
| got = deps.build() |
| |
| self.assertEqual(["bar", "req_dep", "ssl_lib"], got.deps) |
| self.assertEqual({}, got.deps_select) |
| |
| def test_self_dependencies_can_come_in_any_order(self): |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=[ |
| "bar", |
| "baz; extra == 'feat'", |
| "foo[feat2]; extra == 'all'", |
| "foo[feat]; extra == 'feat2'", |
| "zdep; extra == 'all'", |
| ], |
| extras={"all"}, |
| ) |
| |
| got = deps.build() |
| |
| self.assertEqual(["bar", "baz", "zdep"], got.deps) |
| self.assertEqual({}, got.deps_select) |
| |
| def test_can_get_deps_based_on_specific_python_version(self): |
| requires_dist = [ |
| "bar", |
| "baz; python_version < '3.8'", |
| "posix_dep; os_name=='posix' and python_version >= '3.8'", |
| ] |
| |
| py38_deps = wheel.Deps( |
| "foo", |
| requires_dist=requires_dist, |
| platforms=[ |
| Platform(os=OS.linux, arch=Arch.x86_64, minor_version=8), |
| ], |
| ).build() |
| py37_deps = wheel.Deps( |
| "foo", |
| requires_dist=requires_dist, |
| platforms=[ |
| Platform(os=OS.linux, arch=Arch.x86_64, minor_version=7), |
| ], |
| ).build() |
| |
| self.assertEqual(["bar", "baz"], py37_deps.deps) |
| self.assertEqual({}, py37_deps.deps_select) |
| self.assertEqual(["bar"], py38_deps.deps) |
| self.assertEqual({"@platforms//os:linux": ["posix_dep"]}, py38_deps.deps_select) |
| |
| @mock.patch(_HOST_INTERPRETER_FN) |
| def test_no_version_select_when_single_version(self, mock_host_interpreter_version): |
| requires_dist = [ |
| "bar", |
| "baz; python_version >= '3.8'", |
| "posix_dep; os_name=='posix'", |
| "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", |
| "arch_dep; platform_machine=='x86_64' and python_version >= '3.8'", |
| ] |
| mock_host_interpreter_version.return_value = 7 |
| |
| self.maxDiff = None |
| |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=requires_dist, |
| platforms=[ |
| Platform(os=os, arch=Arch.x86_64, minor_version=minor) |
| for minor in [8] |
| for os in [OS.linux, OS.windows] |
| ], |
| ) |
| got = deps.build() |
| |
| self.assertEqual(["bar", "baz"], got.deps) |
| self.assertEqual( |
| { |
| "@platforms//os:linux": ["posix_dep", "posix_dep_with_version"], |
| "linux_x86_64": ["arch_dep", "posix_dep", "posix_dep_with_version"], |
| "windows_x86_64": ["arch_dep"], |
| }, |
| got.deps_select, |
| ) |
| |
| @mock.patch(_HOST_INTERPRETER_FN) |
| def test_can_get_version_select(self, mock_host_interpreter_version): |
| requires_dist = [ |
| "bar", |
| "baz; python_version < '3.8'", |
| "baz_new; python_version >= '3.8'", |
| "posix_dep; os_name=='posix'", |
| "posix_dep_with_version; os_name=='posix' and python_version >= '3.8'", |
| "arch_dep; platform_machine=='x86_64' and python_version < '3.8'", |
| ] |
| mock_host_interpreter_version.return_value = 7 |
| |
| self.maxDiff = None |
| |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=requires_dist, |
| platforms=[ |
| Platform(os=os, arch=Arch.x86_64, minor_version=minor) |
| for minor in [7, 8, 9] |
| for os in [OS.linux, OS.windows] |
| ], |
| ) |
| got = deps.build() |
| |
| self.assertEqual(["bar"], got.deps) |
| self.assertEqual( |
| { |
| "//conditions:default": ["baz"], |
| "@//python/config_settings:is_python_3.7": ["baz"], |
| "@//python/config_settings:is_python_3.8": ["baz_new"], |
| "@//python/config_settings:is_python_3.9": ["baz_new"], |
| "@platforms//os:linux": ["baz", "posix_dep"], |
| "cp37_linux_x86_64": ["arch_dep", "baz", "posix_dep"], |
| "cp37_windows_x86_64": ["arch_dep", "baz"], |
| "cp37_linux_anyarch": ["baz", "posix_dep"], |
| "cp38_linux_anyarch": [ |
| "baz_new", |
| "posix_dep", |
| "posix_dep_with_version", |
| ], |
| "cp39_linux_anyarch": [ |
| "baz_new", |
| "posix_dep", |
| "posix_dep_with_version", |
| ], |
| "linux_x86_64": ["arch_dep", "baz", "posix_dep"], |
| "windows_x86_64": ["arch_dep", "baz"], |
| }, |
| got.deps_select, |
| ) |
| |
| @mock.patch(_HOST_INTERPRETER_FN) |
| def test_deps_spanning_all_target_py_versions_are_added_to_common( |
| self, mock_host_version |
| ): |
| requires_dist = [ |
| "bar", |
| "baz (<2,>=1.11) ; python_version < '3.8'", |
| "baz (<2,>=1.14) ; python_version >= '3.8'", |
| ] |
| mock_host_version.return_value = 8 |
| |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=requires_dist, |
| platforms=Platform.from_string(["cp37_*", "cp38_*", "cp39_*"]), |
| ) |
| got = deps.build() |
| |
| self.assertEqual(["bar", "baz"], got.deps) |
| self.assertEqual({}, got.deps_select) |
| |
| @mock.patch(_HOST_INTERPRETER_FN) |
| def test_deps_are_not_duplicated(self, mock_host_version): |
| mock_host_version.return_value = 7 |
| |
| # See an example in |
| # https://files.pythonhosted.org/packages/76/9e/db1c2d56c04b97981c06663384f45f28950a73d9acf840c4006d60d0a1ff/opencv_python-4.9.0.80-cp37-abi3-win32.whl.metadata |
| requires_dist = [ |
| "bar >=0.1.0 ; python_version < '3.7'", |
| "bar >=0.2.0 ; python_version >= '3.7'", |
| "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", |
| "bar >=0.4.0 ; python_version >= '3.9'", |
| "bar >=0.5.0 ; python_version <= '3.9' and platform_system == 'Darwin' and platform_machine == 'arm64'", |
| "bar >=0.5.0 ; python_version >= '3.10' and platform_system == 'Darwin'", |
| "bar >=0.5.0 ; python_version >= '3.10'", |
| "bar >=0.6.0 ; python_version >= '3.11'", |
| ] |
| |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=requires_dist, |
| platforms=Platform.from_string(["cp37_*", "cp310_*"]), |
| ) |
| got = deps.build() |
| |
| self.assertEqual(["bar"], got.deps) |
| self.assertEqual({}, got.deps_select) |
| |
| @mock.patch(_HOST_INTERPRETER_FN) |
| def test_deps_are_not_duplicated_when_encountering_platform_dep_first( |
| self, mock_host_version |
| ): |
| mock_host_version.return_value = 7 |
| |
| # Note, that we are sorting the incoming `requires_dist` and we need to ensure that we are not getting any |
| # issues even if the platform-specific line comes first. |
| requires_dist = [ |
| "bar >=0.4.0 ; python_version >= '3.6' and platform_system == 'Linux' and platform_machine == 'aarch64'", |
| "bar >=0.5.0 ; python_version >= '3.9'", |
| ] |
| |
| deps = wheel.Deps( |
| "foo", |
| requires_dist=requires_dist, |
| platforms=Platform.from_string(["cp37_*", "cp310_*"]), |
| ) |
| got = deps.build() |
| |
| self.assertEqual(["bar"], got.deps) |
| self.assertEqual({}, got.deps_select) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
