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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-universal4
-Version: 4.50.4.dev1
+Version: 4.50.4.dev2
 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.dev2/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.dev2
 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.dev2}/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 → core_universal4-4.50.4.dev2}/setup.cfg

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

{core_universal4-4.50.4.dev1 → core_universal4-4.50.4.dev2}/setup.py

@@ -1,3 +1,23 @@
+"""
+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
+
+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 setup-legacy.py sdist           # Build legacy sdist
+
+For modern wheel builds, use setup.py with `make core_universal/dist`.
+"""
 import os
 import sys
 from shutil import rmtree
@@ -7,23 +27,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 +47,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 +68,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 +87,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 +108,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 +141,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
+class sdist(_sdist):
+    """Sdist command that generates setup.cfg and removes pyproject.toml."""
 
-    @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
-
-        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 +227,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 +237,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 +272,29 @@ 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)
+
 
-setup(cmdclass={c.__name__: c for c in commands})
+setup(cmdclass={"build_py": build_py, "sdist": sdist})