core-universal4 4.50.4.dev2__tar.gz → 4.50.4.dev3__tar.gz

{core_universal4-4.50.4.dev2/core_universal4.egg-info → core_universal4-4.50.4.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-universal4
-Version: 4.50.4.dev2
+Version: 4.50.4.dev3
 Summary: Applitools Eyes Core SDK Server
 Author-email: Applitools Team <team@applitools.com>
 License-Expression: LicenseRef-Proprietary

{core_universal4-4.50.4.dev2 → core_universal4-4.50.4.dev3/core_universal4.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-universal4
-Version: 4.50.4.dev2
+Version: 4.50.4.dev3
 Summary: Applitools Eyes Core SDK Server
 Author-email: Applitools Team <team@applitools.com>
 License-Expression: LicenseRef-Proprietary

core_universal4-4.50.4.dev2/setup.py → core_universal4-4.50.4.dev3/setup-legacy.py

@@ -7,16 +7,26 @@ This setup file:
 - Removes pyproject.toml from sdist to force legacy mode
 - Uses built_bins/ directory for platform binaries
 - Works without wheel package installed
+- Kept alongside setup.py in sdist for maximum compatibility
 
 Binary source:
   - built_bins/ directory containing all platform binaries
   - Makefile prepares this directory before building
 
-Usage:
+Usage for building sdist:
     make core_universal/prepare_binaries  # Prepare binaries first
     python setup-legacy.py sdist           # Build legacy sdist
 
-For modern wheel builds, use setup.py with `make core_universal/dist`.
+Usage for installing from sdist:
+    # If wheel package is available (most environments):
+    pip install core_universal4-X.Y.Z.tar.gz
+    # This will use setup.py to build and install a wheel
+
+    # If wheel package is NOT available (truly restricted environments):
+    python setup-legacy.py install
+    # This will install directly without building a wheel
+
+For modern wheel builds from source, use setup.py with `make core_universal/dist`.
 """
 import os
 import sys
@@ -272,29 +282,14 @@ tag_date = 0
                 2,
             )
 
-        # Replace modern setup.py with setup-legacy.py for restricted environment compatibility
-        # The modern setup.py imports wheel directly and will fail in restricted environments
-        modern_setup_py = os.path.join(base_dir, "setup.py")
-        legacy_setup_py = os.path.join(base_dir, "setup-legacy.py")
-
-        if os.path.isfile(modern_setup_py) and os.path.isfile(legacy_setup_py):
-            self.announce(
-                f"Replacing {modern_setup_py} with {legacy_setup_py} "
-                "(modern setup.py requires wheel package)",
-                2,
-            )
-            # Copy setup-legacy.py content to setup.py
-            import shutil
-
-            shutil.copy2(legacy_setup_py, modern_setup_py)
-
-            # Remove setup-legacy.py from sdist (setup.py now contains the legacy code)
-            self.announce(
-                f"Removing {legacy_setup_py} from source distribution "
-                "(setup.py already contains legacy implementation)",
-                2,
-            )
-            os.remove(legacy_setup_py)
+        # Keep both setup.py and setup-legacy.py in sdist
+        # - setup.py: For environments that can build wheels (requires wheel package)
+        # - setup-legacy.py: For truly restricted environments (Amazon Fire TV)
+        # Users can choose which one to use based on their environment
+        self.announce(
+            "Keeping both setup.py and setup-legacy.py in source distribution",
+            2,
+        )
 
 
 setup(cmdclass={"build_py": build_py, "sdist": sdist})

{core_universal4-4.50.4.dev2 → core_universal4-4.50.4.dev3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = core-universal4
-version = 4.50.4.dev2
+version = 4.50.4.dev3
 description = Applitools Eyes Core SDK Server
 long_description = file: README.rst
 long_description_content_type = text/x-rst

core_universal4-4.50.4.dev3/setup.py

@@ -0,0 +1,153 @@
+"""
+Modern PEP 517 setup.py for core_universal.
+
+This setup file:
+- Builds platform-specific wheels for modern environments
+- Uses pyproject.toml for all metadata (PEP 517)
+- Requires wheel package for building wheels
+- Uses built_bins/ directory for platform binaries
+
+Binary source:
+  - built_bins/ directory containing all platform binaries
+  - Makefile prepares this directory before building
+
+Usage:
+    make core_universal/prepare_binaries  # Prepare binaries first
+    python -m build --wheel                # Build wheels
+
+For restricted environments without wheel package, use setup-legacy.py instead.
+"""
+import os
+import sys
+from shutil import rmtree
+from sys import platform
+
+from setuptools import setup
+from setuptools.command.bdist_wheel import bdist_wheel as _bdist_wheel
+from setuptools.command.build_py import build_py as _build_py
+
+PKG_BIN_DIR = "applitools/core_universal/bin"
+PKG_BUILT_BINS_DIR = "applitools/core_universal/built_bins"
+
+PLAT_EXECUTABLE = {
+    "macosx_10_7_x86_64": "core-macos",
+    "macosx_11_0_arm64": "core-macos-arm64",
+    "manylinux1_x86_64": "core-linux",
+    "manylinux2014_aarch64": "core-linux-arm64",
+    "musllinux_1_2_x86_64": "core-alpine",
+    "win_amd64": "core-win.exe",
+}
+
+
+def current_plat():
+    if platform == "darwin":
+        if os.uname().machine == "arm64":
+            return "macosx_11_0_arm64"
+        return "macosx_10_7_x86_64"
+    elif platform == "win32":
+        return "win_amd64"
+    elif platform in ("linux", "linux2"):
+        if os.uname().machine == "aarch64":
+            return "manylinux2014_aarch64"
+        if os.path.exists("/etc/alpine-release"):
+            return "musllinux_1_2_x86_64"
+        else:
+            return "manylinux1_x86_64"
+    else:
+        raise Exception("Platform is not supported", platform)
+
+
+def get_target_platform():
+    """Get the target platform from environment variable or command line arguments."""
+    # Check if PLAT_NAME is specified in environment variable
+    if "PLAT_NAME" in os.environ:
+        return os.environ["PLAT_NAME"]
+
+    # Check if --plat-name is specified in command line arguments
+    for i, arg in enumerate(sys.argv):
+        if arg == "--plat-name" and i + 1 < len(sys.argv):
+            return sys.argv[i + 1]
+        elif arg.startswith("--plat-name="):
+            return arg.split("=", 1)[1]
+
+    # Fall back to current platform
+    return current_plat()
+
+
+# Select executable based on target platform
+target_platform = get_target_platform()
+selected_executable = PLAT_EXECUTABLE.get(
+    target_platform, PLAT_EXECUTABLE[current_plat()]
+)
+
+
+class build_py(_build_py):
+    """Build command that copies platform binary from built_bins/ directory."""
+
+    def get_data_files(self):
+        # Check if binary source directory exists
+        if not os.path.isdir(PKG_BUILT_BINS_DIR):
+            raise RuntimeError(
+                f"Binary source directory not found: {PKG_BUILT_BINS_DIR}\n"
+                f"Run 'make core_universal/prepare_binaries' to prepare binaries before building.\n\n"
+                f"For source installs without wheel package, use setup-legacy.py instead."
+            )
+
+        if not self.dry_run and os.path.isdir(PKG_BIN_DIR):
+            rmtree(PKG_BIN_DIR)
+
+        os.makedirs(PKG_BIN_DIR, exist_ok=True)
+
+        _, ext = os.path.splitext(selected_executable)
+        target_name = os.path.join(PKG_BIN_DIR, "core" + ext)
+        built_file_name = os.path.join(PKG_BUILT_BINS_DIR, selected_executable)
+
+        # Verify the source file exists
+        if not os.path.isfile(built_file_name):
+            available_files = (
+                ", ".join(os.listdir(PKG_BUILT_BINS_DIR))
+                if os.path.isdir(PKG_BUILT_BINS_DIR)
+                else "N/A"
+            )
+            raise RuntimeError(
+                f"Binary not found: {built_file_name}\n"
+                f"Platform: {target_platform}\n"
+                f"Expected: {selected_executable}\n"
+                f"Available in {PKG_BUILT_BINS_DIR}: {available_files}\n\n"
+                f"Run 'make core_universal/prepare_binaries' to prepare all platform binaries."
+            )
+
+        self.copy_file(built_file_name, target_name)
+        os.chmod(target_name, 0o755)
+        return _build_py.get_data_files(self)
+
+    def run(self):
+        """Run build_py and clean up built_bins directory."""
+        _build_py.run(self)
+        # Remove built_bins from build directory (wheels should only contain bin/)
+        built_bins_in_build = os.path.join(
+            self.build_lib, "applitools", "core_universal", "built_bins"
+        )
+        if os.path.isdir(built_bins_in_build):
+            self.announce(f"Removing {built_bins_in_build} from wheel build", 2)
+            rmtree(built_bins_in_build)
+
+
+class bdist_wheel(_bdist_wheel):
+    """Custom bdist_wheel to set platform-specific tags."""
+
+    def finalize_options(self):
+        super().finalize_options()
+        # Always set the platform name to match the target platform
+        self.plat_name = target_platform
+        # Ensure root_is_pure is False since we have platform-specific binaries
+        self.root_is_pure = False
+
+    def get_tag(self):
+        # Force the platform tag to match our target platform
+        # Use py3 tag to make wheels compatible with all Python 3.x versions
+        impl, abi, plat = super().get_tag()
+        return "py3", "none", target_platform
+
+
+setup(cmdclass={"build_py": build_py, "bdist_wheel": bdist_wheel})