Fix wasm

Author: kunitoki

cmake/yup_standalone.cmake

@@ -187,7 +187,7 @@ function (yup_standalone_app)
             -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='$dynCall'
             --shell-file "${YUP_ARG_CUSTOM_SHELL}")
 
-        foreach (preload_file IN ITEMS ${YUP_ARG_PRELOAD_FILES})
+        foreach (preload_file IN LISTS YUP_ARG_PRELOAD_FILES)
             list (APPEND additional_link_options --preload-file "${preload_file}")
         endforeach()
 

python/tools/ArchivePythonStdlib.py

@@ -9,34 +9,26 @@
 
 def file_hash(file):
     h = hashlib.md5()
-
     with open(file, "rb") as f:
         h.update(f.read())
-
     return h.hexdigest()
 
 
 def should_exclude(path, name, exclude_patterns):
-    """Check if a path should be excluded based on patterns."""
-    # Check if the name itself matches any pattern
     for pattern in exclude_patterns:
-        # Exact name match
         if name == pattern:
             return True
 
-        # Directory patterns (e.g., __pycache__, test)
         if pattern.startswith('**/'):
             pattern_name = pattern[3:]
             if name == pattern_name:
                 return True
 
-        # Extension patterns (e.g., *.pyc)
         if pattern.startswith('**/*.'):
             ext = pattern[4:]  # Remove **/*
             if name.endswith(ext):
                 return True
 
-        # Wildcard patterns
         if '*' in pattern and not pattern.startswith('**/'):
             import fnmatch
             if fnmatch.fnmatch(name, pattern):
@@ -45,71 +37,49 @@ def should_exclude(path, name, exclude_patterns):
     return False
 
 
-def copy_filtered_tree(src, dst, exclude_patterns, verbose=False):
-    """Recursively copy directory tree with filtering."""
+def copy_filtered_tree(src, dst, exclude_patterns):
     if not os.path.exists(dst):
         os.makedirs(dst)
 
     for item in os.listdir(src):
         src_path = os.path.join(src, item)
         dst_path = os.path.join(dst, item)
 
-        # Check if should exclude
         if should_exclude(src_path, item, exclude_patterns):
-            if verbose:
-                print(f"Excluding: {os.path.relpath(src_path, src)}")
             continue
 
         if os.path.isdir(src_path):
-            copy_filtered_tree(src_path, dst_path, exclude_patterns, verbose)
+            copy_filtered_tree(src_path, dst_path, exclude_patterns)
         else:
             shutil.copy2(src_path, dst_path)
-            if verbose:
-                print(f"Copied: {os.path.relpath(src_path, src)}")
 
 
-def clean_duplicate_libraries(directory, verbose=False):
-    """Keep only one of each dynamic library type."""
+def clean_duplicate_libraries(directory):
     lib_files = {}
-
-    for root, dirs, files in os.walk(directory):
+    for root, _, files in os.walk(directory):
         for file in files:
             file_path = os.path.join(root, file)
 
-            # Group by base name without version numbers
-            # e.g., libpython3.13.dylib -> libpython, libpython3.13.a -> libpython
-            if any(ext in file for ext in ['.dylib', '.dll', '.so', '.a', '.lib']):
-                # Extract base name and extension type
-                base_name = file.split('.')[0]
-
-                # Determine library type
-                if '.dylib' in file:
-                    lib_type = 'dylib'
-                elif '.dll' in file:
-                    lib_type = 'dll'
-                elif '.so' in file:
-                    lib_type = 'so'
-                elif '.a' in file:
-                    lib_type = 'static'
-                elif '.lib' in file:
-                    lib_type = 'lib'
-                else:
-                    continue
+            if not any(ext in file for ext in ['.dylib', '.dll', '.so', '.a', '.lib']):
+                continue
 
-                key = (base_name, lib_type)
+            base_name = file.split('.')[0]
 
-                if key not in lib_files:
-                    lib_files[key] = file_path
-                    if verbose:
-                        print(f"Keeping library: {file}")
-                else:
-                    # Remove duplicate
-                    if verbose:
-                        print(f"Removing duplicate library: {file}")
-                    os.remove(file_path)
+            if '.dylib' in file:    lib_type = 'dylib'
+            elif '.dll' in file:    lib_type = 'dll'
+            elif '.so' in file:     lib_type = 'so'
+            elif '.a' in file:      lib_type = 'static'
+            elif '.lib' in file:    lib_type = 'lib'
+            else:                   continue
+
+            key = (base_name, lib_type)
+            if key not in lib_files:
+                lib_files[key] = file_path
+            else:
+                os.remove(file_path)
 
 
-def make_archive(file, directory, verbose=False):
+def make_archive(file, directory):
     archived_files = []
     for dirname, _, files in os.walk(directory):
         for filename in files:
@@ -127,20 +97,16 @@ def make_archive(file, directory, verbose=False):
             with open(path, "rb") as fp:
                 zf.writestr(zip_info, fp.read(), compress_type=zipfile.ZIP_DEFLATED, compresslevel=9)
 
-            if verbose:
-                print(f"Added to zip: {archive_path}")
-
 
 if __name__ == "__main__":
-    print(f"starting python standard lib archiving tool...")
+    print(f"-- YUP -- Starting python standard lib archiving tool...")
 
     parser = ArgumentParser()
     parser.add_argument("-r", "--root-folder", type=Path, help="Path to the python base folder.")
     parser.add_argument("-o", "--output-folder", type=Path, help="Path to the output folder.")
     parser.add_argument("-M", "--version-major", type=int, help="Major version number (integer).")
     parser.add_argument("-m", "--version-minor", type=int, help="Minor version number (integer).")
     parser.add_argument("-x", "--exclude-patterns", type=str, default=None, help="Excluded patterns (semicolon separated list).")
-    parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output.")
 
     args = parser.parse_args()
 
@@ -180,7 +146,7 @@ def make_archive(file, directory, verbose=False):
         custom_patterns = [x.strip() for x in args.exclude_patterns.replace('"', '').split(";")]
         base_patterns += custom_patterns
 
-    print(f"cleaning up {final_location}...")
+    print(f"-- YUP -- Cleaning up {final_location}...")
     if final_location.exists():
         shutil.rmtree(final_location)
 
@@ -196,34 +162,32 @@ def make_archive(file, directory, verbose=False):
         python_lib_src = lib_src / python_folder_name
         if python_lib_src.exists():
             python_lib_dst = lib_dst / python_folder_name
-            print(f"copying library from {python_lib_src} to {python_lib_dst}...")
-            copy_filtered_tree(python_lib_src, python_lib_dst, base_patterns, verbose=args.verbose)
+            print(f"-- YUP -- Copying library from {python_lib_src} to {python_lib_dst}...")
+            copy_filtered_tree(python_lib_src, python_lib_dst, base_patterns)
 
             # Create site-packages directory
             site_packages = python_lib_dst / "site-packages"
             site_packages.mkdir(parents=True, exist_ok=True)
         else:
-            print(f"Warning: Python library path {python_lib_src} does not exist")
+            print(f"-- YUP -- Warning: Python library path {python_lib_src} does not exist")
 
         # Copy dynamic libraries from lib root (e.g., libpython3.13.dylib)
-        print(f"copying dynamic libraries from {lib_src}...")
+        print(f"-- YUP -- Copying dynamic libraries from {lib_src}...")
         for item in lib_src.iterdir():
             if item.is_file():
                 if any(ext in item.name for ext in ['.dylib', '.dll', '.so', '.a', '.lib']):
                     if not should_exclude(str(item), item.name, base_patterns):
                         shutil.copy2(item, lib_dst / item.name)
-                        if args.verbose:
-                            print(f"Copied library: {item.name}")
     else:
-        print(f"Warning: Library path {lib_src} does not exist")
+        print(f"-- YUP -- Warning: Library path {lib_src} does not exist")
 
     # Copy bin folder
     bin_src = base_python / "bin"
     if bin_src.exists():
         bin_dst = final_location / "bin"
         bin_dst.mkdir(parents=True, exist_ok=True)
 
-        print(f"copying binaries from {bin_src} to {bin_dst}...")
+        print(f"-- YUP -- Copying binaries from {bin_src} to {bin_dst}...")
 
         # Copy python executables and symlinks (deduplicate with set)
         executables = list(set([
@@ -241,8 +205,6 @@ def make_archive(file, directory, verbose=False):
             if exe_path.exists():
                 # Skip if destination already exists
                 if dst_path.exists():
-                    if args.verbose:
-                        print(f"Skipping existing binary: {executable}")
                     continue
 
                 if exe_path.is_symlink():
@@ -251,18 +213,16 @@ def make_archive(file, directory, verbose=False):
                     os.symlink(link_target, dst_path)
                 else:
                     shutil.copy2(exe_path, dst_path)
-                if args.verbose:
-                    print(f"Copied binary: {executable}")
     else:
-        print(f"Warning: Binary path {bin_src} does not exist")
+        print(f"-- YUP -- Warning: Binary path {bin_src} does not exist")
 
     # Copy include folder
     include_src = base_python / "include"
     if include_src.exists():
         include_dst = final_location / "include"
         include_dst.mkdir(parents=True, exist_ok=True)
 
-        print(f"copying include files from {include_src} to {include_dst}...")
+        print(f"-- YUP -- Copying include files from {include_src} to {include_dst}...")
 
         # Copy the python version include folder
         python_include_src = include_src / python_folder_name
@@ -276,33 +236,28 @@ def make_archive(file, directory, verbose=False):
                     shutil.copytree(item, include_dst / item.name, dirs_exist_ok=True)
                 else:
                     shutil.copy2(item, include_dst / item.name)
-
-        if args.verbose:
-            print(f"Copied include files")
     else:
-        print(f"Warning: Include path {include_src} does not exist")
+        print(f"-- YUP -- Warning: Include path {include_src} does not exist")
 
     # Clean up duplicate libraries
-    print(f"cleaning up duplicate libraries...")
-    clean_duplicate_libraries(final_location, verbose=args.verbose)
+    print(f"-- YUP -- Cleaning up duplicate libraries...")
+    clean_duplicate_libraries(final_location)
 
     # Create archive from final_location contents (not including the python/ wrapper)
-    print(f"making archive {temp_archive} to {final_archive}...")
+    print(f"-- YUP -- Making archive {temp_archive} to {final_archive}...")
     if os.path.exists(final_archive):
-        make_archive(temp_archive, final_location, verbose=args.verbose)
+        make_archive(temp_archive, final_location)
         if file_hash(temp_archive) != file_hash(final_archive):
             shutil.copy(temp_archive, final_archive)
             os.remove(temp_archive)
-            print(f"Archive updated")
+            print("-- YUP -- Archive updated")
         else:
             os.remove(temp_archive)
-            print(f"Archive unchanged")
+            print("-- YUP -- Archive unchanged")
     else:
-        make_archive(final_archive, final_location, verbose=args.verbose)
-        print(f"Archive created")
+        make_archive(final_archive, final_location)
+        print("-- YUP -- Archive created")
 
     # Clean up temporary directory
-    print(f"cleaning up {final_location}...")
+    print(f"-- YUP -- Cleaning up {final_location}...")
     shutil.rmtree(final_location)
-
-    print("Done!")