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

{core_universal4-4.50.4.dev1/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.dev1
+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.dev1 → 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.dev1
+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.dev1 → core_universal4-4.50.4.dev3}/core_universal4.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ LICENSE
 MANIFEST.in
 README.rst
 pyproject.toml
+setup-legacy.py
 setup.py
 applitools/core_universal/__init__.py
 applitools/core_universal/__main__.py

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

@@ -1,3 +1,33 @@
+"""
+Legacy setup.py for restricted environments without wheel package.
+
+This setup file:
+- Builds source distributions (sdist) for restricted environments
+- Generates setup.cfg from pyproject.toml during sdist build
+- 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 for building sdist:
+    make core_universal/prepare_binaries  # Prepare binaries first
+    python setup-legacy.py sdist           # Build legacy sdist
+
+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
 from shutil import rmtree
@@ -7,23 +37,8 @@ from setuptools import setup
 from setuptools.command.build_py import build_py as _build_py
 from setuptools.command.sdist import sdist as _sdist
 
-# Import bdist_wheel only if wheel package is available
-# This allows the package to be built without wheel in restricted environments
-try:
-    from setuptools.command.bdist_wheel import bdist_wheel as _bdist_wheel
-
-    HAS_WHEEL = True
-except ImportError:
-    _bdist_wheel = None
-    HAS_WHEEL = False
-
 PKG_BIN_DIR = "applitools/core_universal/bin"
-# USDK_BUILD_DIR: Directory containing pre-built platform binaries
-# - Required for: bdist_wheel (wheel builds)
-# - Not required for: sdist (source distributions - uses built_bins/ directly)
-# - Default: applitools/core_universal/built_bins
-# Note: Use 'or' to handle empty string same as unset (CI may set it to "")
-USDK_BUILD_DIR = os.getenv("USDK_BUILD_DIR") or "applitools/core_universal/built_bins"
+PKG_BUILT_BINS_DIR = "applitools/core_universal/built_bins"
 
 PLAT_EXECUTABLE = {
     "macosx_10_7_x86_64": "core-macos",
@@ -42,10 +57,6 @@ def get_included_platforms():
     - INCLUDE_PLATFORMS environment variable (comma-separated)
     - --include-platforms command-line argument (comma-separated)
 
-    Examples:
-        INCLUDE_PLATFORMS=manylinux1_x86_64,manylinux2014_aarch64 python setup.py sdist
-        python setup.py sdist --include-platforms=manylinux1_x86_64,manylinux2014_aarch64
-
     If not specified, all platforms are included.
     """
     # Check environment variable first
@@ -67,6 +78,7 @@ def get_included_platforms():
 
 
 def current_plat():
+    """Detect current platform."""
     if platform == "darwin":
         if os.uname().machine == "arm64":
             return "macosx_11_0_arm64"
@@ -85,7 +97,7 @@ def current_plat():
 
 
 def get_target_platform():
-    """Get the target platform from environment variable, build command arguments, or fall back to current platform."""
+    """Get the target platform from environment variable or detect current."""
     # Check if PLAT_NAME is specified in environment variable
     if "PLAT_NAME" in os.environ:
         return os.environ["PLAT_NAME"]
@@ -106,54 +118,32 @@ target_platform = get_target_platform()
 selected_executable = PLAT_EXECUTABLE.get(
     target_platform, PLAT_EXECUTABLE[current_plat()]
 )
-commands = set()
 
-# Download previously selected executable.
-# It is downloaded to the source tree (so editable setup works).
-@commands.add
-class build_py(_build_py):  # noqa
+
+class build_py(_build_py):
+    """Build command that copies platform binary from built_bins/ directory."""
+
     def get_data_files(self):
-        # Determine source directory for binaries:
-        # 1. If built_bins/ exists (sdist install), use it
-        # 2. Otherwise, require USDK_BUILD_DIR (wheel build)
-        PKG_BUILT_BINS_DIR = "applitools/core_universal/built_bins"
-
-        if os.path.isdir(PKG_BUILT_BINS_DIR):
-            # Installing from sdist - use built_bins/ directory
-            source_dir = PKG_BUILT_BINS_DIR
-            source_type = "sdist (built_bins/)"
-        elif USDK_BUILD_DIR and os.path.isdir(USDK_BUILD_DIR):
-            # Building wheel - use USDK_BUILD_DIR
-            source_dir = USDK_BUILD_DIR
-            source_type = "wheel build (USDK_BUILD_DIR)"
-        else:
-            # Neither source available - error
+        # Legacy builds always use built_bins/ directory (from sdist)
+        source_dir = PKG_BUILT_BINS_DIR
+
+        if not os.path.isdir(source_dir):
             raise RuntimeError(
-                f"No binary source directory found.\n\n"
-                f"For installing from source distribution:\n"
-                f"  Expected: {PKG_BUILT_BINS_DIR}/ directory with pre-built binaries\n"
-                f"  Status: Not found\n\n"
-                f"For building wheels:\n"
-                f"  Expected: USDK_BUILD_DIR environment variable pointing to binaries\n"
-                f"  Current value: {USDK_BUILD_DIR!r}\n\n"
-                f"To fix this:\n"
-                f"  1. If installing from sdist: Ensure built_bins/ directory exists\n"
-                f"  2. If building wheel: Set USDK_BUILD_DIR to the directory containing binaries:\n"
-                f"     export USDK_BUILD_DIR=/path/to/built/binaries\n"
-                f"     python setup.py bdist_wheel"
+                f"Binary source directory not found: {source_dir}\n"
+                f"Legacy builds require built_bins/ directory with pre-built binaries.\n"
+                f"This directory should be present in the source distribution."
             )
 
         if not self.dry_run and os.path.isdir(PKG_BIN_DIR):
             rmtree(PKG_BIN_DIR)
 
-        # Use os.makedirs instead of self.mkpath for better reliability
         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(source_dir, selected_executable)
 
-        # Verify the source file exists before trying to copy
+        # Verify the source file exists
         if not os.path.isfile(built_file_name):
             available_files = (
                 ", ".join(os.listdir(source_dir))
@@ -161,112 +151,45 @@ class build_py(_build_py):  # noqa
                 else "N/A"
             )
             raise RuntimeError(
-                f"Expected binary not found: {built_file_name}\n"
-                f"Source: {source_type}\n"
-                f"Looking for platform: {target_platform}\n"
-                f"Expected binary name: {selected_executable}\n"
-                f"Available files in {source_dir}:\n"
-                f"  {available_files}\n\n"
-                f"Make sure you have the binary for the target platform."
+                f"Binary not found: {built_file_name}\n"
+                f"Platform: {target_platform}\n"
+                f"Expected: {selected_executable}\n"
+                f"Available in {source_dir}: {available_files}"
             )
 
-        self.announce(f"Copying {selected_executable} from {source_type}", 2)
         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 then remove built_bins from build directory (for wheels only)."""
+        """Run build_py and remove built_bins from build directory."""
         _build_py.run(self)
-        # Remove built_bins from build directory after the build completes
+        # Remove built_bins from build directory after build completes
         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)
+            self.announce(f"Removing {built_bins_in_build} from build", 2)
             rmtree(built_bins_in_build)
 
 
-# Define bdist_wheel command conditionally
-if HAS_WHEEL:
-    # Full bdist_wheel implementation when wheel package is available
-    @commands.add
-    class bdist_wheel(_bdist_wheel):  # noqa
-        def finalize_options(self):
-            super().finalize_options()
-            # Always set the platform name to match the target platform
-            self.plat_name = target_platform
-            # Also ensure the 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
-
-else:
-    # Stub implementation when wheel package is not available
-    # This allows setup.py to work in environments without wheel
-    from setuptools import Command
-
-    @commands.add
-    class bdist_wheel(Command):  # noqa
-        """Stub bdist_wheel command for environments without wheel package."""
-
-        description = "create a wheel distribution (requires wheel package)"
-        user_options = []
-
-        def initialize_options(self):
-            pass
-
-        def finalize_options(self):
-            pass
+class sdist(_sdist):
+    """Sdist command that generates setup.cfg and removes pyproject.toml."""
 
-        def run(self):
-            raise RuntimeError(
-                "bdist_wheel command requires the 'wheel' package. "
-                "Install it with: pip install wheel"
-            )
-
-        @staticmethod
-        def egg2dist(egginfo_path, distinfo_path):
-            """Stub method to satisfy setuptools dist_info command.
-
-            This method is called by setuptools when generating metadata.
-            Since we're in a restricted environment without wheel, we raise
-            a clear error if this is actually invoked during metadata generation.
-
-            However, for legacy setup.py install mode, this should not be called.
-            """
-            raise RuntimeError(
-                "egg2dist requires the 'wheel' package. "
-                "This error suggests pip is trying to use PEP 517 mode.\n"
-                "For restricted environments, use legacy mode:\n"
-                "  pip install <package> --no-build-isolation --no-use-pep517"
-            )
-
-
-@commands.add
-class sdist(_sdist):  # noqa
     def make_release_tree(self, base_dir, files):
         # Create the source tree
         super().make_release_tree(base_dir, files)
 
-        # Generate setup.cfg from pyproject.toml (required for sdist only)
-        # This is needed because we remove pyproject.toml to force legacy mode
+        # Generate setup.cfg from pyproject.toml (required for legacy mode)
         try:
-            import sys
-
             if sys.version_info >= (3, 11):
                 import tomllib
             else:
                 import tomli as tomllib
         except ImportError:
             raise RuntimeError(
-                "Building sdist requires tomllib (Python 3.11+) or tomli package.\n"
-                "Install with: pip install tomli\n"
-                "This is only needed for building sdist, not for wheels."
+                "Building legacy sdist requires tomllib (Python 3.11+) or tomli package.\n"
+                "Install with: pip install tomli"
             )
 
         with open("pyproject.toml", "rb") as f:
@@ -314,8 +237,6 @@ tag_date = 0
         )
 
         # Remove pyproject.toml from source distribution to force legacy mode
-        # This ensures pip uses setup.py install instead of PEP 517 build
-        # which is required for environments without wheel package
         pyproject_toml = os.path.join(base_dir, "pyproject.toml")
         if os.path.isfile(pyproject_toml):
             self.announce(
@@ -326,8 +247,6 @@ tag_date = 0
             os.remove(pyproject_toml)
 
         # Remove bin/ directory from source distribution
-        # The universal sdist should only contain built_bins/ with all platform binaries
-        # Wheels will create bin/ with platform-specific binary during build
         bin_dir_in_sdist = os.path.join(base_dir, "applitools", "core_universal", "bin")
         if os.path.isdir(bin_dir_in_sdist):
             self.announce(f"Removing {bin_dir_in_sdist} from source distribution", 2)
@@ -363,5 +282,14 @@ tag_date = 0
                 2,
             )
 
+        # 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={c.__name__: c for c in commands})
+setup(cmdclass={"build_py": build_py, "sdist": sdist})

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

@@ -1,6 +1,6 @@
 [metadata]
 name = core-universal4
-version = 4.50.4.dev1
+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})