refactor: Simplify JAR filtering - filter once in download-jars job

Major simplification:
- Move JAR exclusion from per-platform to single upstream filter
- Filter JARs once in download-jars job (Ubuntu) before artifact upload
- Remove duplicate filtering logic from build-native.sh (native builds)
- Simplify setup_jars.py (Docker builds get pre-filtered JARs)

Benefits:
- Fixes Windows glob pattern issues automatically (no filtering needed)
- Reduces artifact size by ~40MB (83 JARs vs 84 JARs)
- Eliminates cross-platform compatibility issues (find/glob)
- Single source of truth for JAR filtering (jar_exclusions.txt)
- Cleaner, more maintainable codebase

Changes:
- .github/workflows/test-python-bindings.yml:
  - Add 'Remove excluded JARs' step after download
  - Filters using jar_exclusions.txt with bash glob (works on Ubuntu)
  - Artifact now contains pre-filtered JARs

- bindings/python/build-native.sh:
  - Removed JAR filtering logic (~30 lines)
  - Simplified to just copy pre-filtered JARs from artifact

- bindings/python/setup_jars.py:
  - Removed load_jar_exclusions() and should_exclude_jar()
  - Removed filtering logic from find_jar_files()
  - Now just copies pre-filtered JARs (~60 lines simpler)

Note: Docker builds (Dockerfile.build) still filter JARs independently
because they download directly from ArcadeDB image, not from artifact.

Author: tae898

.github/workflows/test-python-bindings.yml

@@ -50,7 +50,41 @@ jobs:
           JAR_COUNT=$(ls -1 src/arcadedb_embedded/jars/*.jar 2>/dev/null | wc -l)
           echo "✅ Downloaded $JAR_COUNT JAR files"
 
-      - name: Upload JARs as artifact
+      - name: Remove excluded JARs
+        shell: bash
+        run: |
+          cd bindings/python
+
+          JARS_DIR="src/arcadedb_embedded/jars"
+          EXCLUSIONS_FILE="jar_exclusions.txt"
+
+          if [[ -f "$EXCLUSIONS_FILE" ]]; then
+            echo "🗑️  Removing excluded JARs from jar_exclusions.txt..."
+            EXCLUSION_COUNT=0
+
+            while IFS= read -r pattern || [[ -n "$pattern" ]]; do
+              # Skip empty lines and comments
+              if [[ -n "$pattern" ]] && [[ ! "$pattern" =~ ^# ]]; then
+                echo "   Processing pattern: $pattern"
+
+                # Remove matching JARs
+                for jar in "$JARS_DIR"/$pattern; do
+                  if [[ -f "$jar" ]]; then
+                    rm -f "$jar"
+                    echo "   - Removed: $(basename "$jar")"
+                    ((EXCLUSION_COUNT++))
+                  fi
+                done
+              fi
+            done < "$EXCLUSIONS_FILE"
+
+            JAR_COUNT_AFTER=$(ls -1 "$JARS_DIR"/*.jar 2>/dev/null | wc -l)
+            echo "✅ Removed $EXCLUSION_COUNT JAR(s), $JAR_COUNT_AFTER remaining"
+          else
+            echo "⚠️  No jar_exclusions.txt found, skipping exclusions"
+          fi
+
+      - name: Upload filtered JARs as artifact
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: arcadedb-jars

bindings/python/build-native.sh

@@ -110,31 +110,9 @@ echo -e "${GREEN}✅ JRE built${NC}"
 JRE_SIZE=$(du -sh "$SCRIPT_DIR/temp_jre" | cut -f1)
 echo -e "${CYAN}📊 JRE size: ${YELLOW}${JRE_SIZE}${NC}"
 
-# Step 3: Copy JRE to package (JARs already in place)
+# Step 3: Copy JRE to package (JARs already filtered and in place from artifact)
 echo -e "${CYAN}📦 Preparing package...${NC}"
 
-# Remove excluded JARs based on jar_exclusions.txt
-EXCLUSIONS_FILE="$SCRIPT_DIR/jar_exclusions.txt"
-if [[ -f "$EXCLUSIONS_FILE" ]]; then
-    echo -e "${YELLOW}🗑️  Removing excluded JARs from jar_exclusions.txt...${NC}"
-    EXCLUSION_COUNT=0
-    while IFS= read -r pattern || [[ -n "$pattern" ]]; do
-        # Skip empty lines and comments
-        if [[ -n "$pattern" ]] && [[ ! "$pattern" =~ ^# ]]; then
-            echo -e "${CYAN}   Processing pattern: $pattern${NC}"
-            # Use find instead of glob for better cross-platform compatibility
-            while IFS= read -r jar; do
-                if [[ -f "$jar" ]]; then
-                    rm -f "$jar"
-                    echo -e "${YELLOW}   - Removed: $(basename "$jar")${NC}"
-                    ((EXCLUSION_COUNT++))
-                fi
-            done < <(find "$JARS_DIR" -maxdepth 1 -name "$pattern" -type f 2> /dev/null)
-        fi
-    done < "$EXCLUSIONS_FILE"
-    echo -e "${GREEN}✅ Removed $EXCLUSION_COUNT JAR(s)${NC}"
-fi
-
 # Build and copy JRE
 rm -rf "$SCRIPT_DIR/src/arcadedb_embedded/jre"
 mkdir -p "$SCRIPT_DIR/src/arcadedb_embedded/jre"

bindings/python/setup_jars.py

@@ -4,49 +4,20 @@
 
 This script should be run as part of the build process to ensure
 all necessary JAR files and the bundled JRE are included in the wheel.
+
+Note: JAR filtering is done upstream:
+  - Docker builds: Filtered in Dockerfile.build (jre-builder stage)
+  - Native builds: Filtered in download-jars GitHub Actions job
 """
 
-import fnmatch
 import shutil
 from pathlib import Path
 
 
-def load_jar_exclusions():
-    """Load JAR exclusion patterns from jar_exclusions.txt."""
-    exclusions_file = Path(__file__).parent / "jar_exclusions.txt"
-    patterns = []
-
-    if exclusions_file.exists():
-        with open(exclusions_file, encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                # Skip empty lines and comments
-                if line and not line.startswith("#"):
-                    patterns.append(line)
-
-    return patterns
-
-
-def should_exclude_jar(jar_name, exclusion_patterns):
-    """Check if a JAR should be excluded based on exclusion patterns."""
-    for pattern in exclusion_patterns:
-        if fnmatch.fnmatch(jar_name, pattern):
-            return True
-    return False
-
-
 def find_jar_files():
-    """Find all necessary ArcadeDB JAR files using custom filtering."""
+    """Find all ArcadeDB JAR files (already filtered upstream)."""
     print("📦 Building arcadedb-embedded with bundled JRE")
 
-    # Load exclusion patterns
-    exclusion_patterns = load_jar_exclusions()
-    if exclusion_patterns:
-        print(
-            f"📋 Loaded {len(exclusion_patterns)} exclusion pattern(s) "
-            "from jar_exclusions.txt"
-        )
-
     # Look for JAR files copied from the ArcadeDB Docker image
     # The Dockerfile copies JARs from the full distribution image to these locations
     quick_paths = [
@@ -61,43 +32,18 @@ def find_jar_files():
         if quick.exists():
             jars = list(map(str, quick.glob("*.jar")))
             if jars:
-                print("✅ Found {} JAR files in: {}".format(len(jars), quick))
+                print(f"✅ Found {len(jars)} JAR files in: {quick}")
                 all_jars.extend(jars)
                 break
 
-    # Filter JARs based on exclusion patterns
     if all_jars:
-        included_jars = []
-        excluded_jars = []
-
+        print("\n✅ JAR files (already filtered):")
         for jar in all_jars:
-            jar_name = Path(jar).name
-            if should_exclude_jar(jar_name, exclusion_patterns):
-                excluded_jars.append(jar)
-            else:
-                included_jars.append(jar)
-
-        print("\n📊 JAR Filtering Results:")
-        print(f"   Total found: {len(all_jars)}")
-        print(f"   Included: {len(included_jars)}")
-        print(f"   Excluded: {len(excluded_jars)}")
-
-        if excluded_jars:
-            print("\n❌ Excluded JARs:")
-            for jar in excluded_jars:
-                jar_name = Path(jar).name
-                size_mb = Path(jar).stat().st_size / 1024 / 1024
-                print(f"   - {jar_name} ({size_mb:.1f}MB)")
-
-        print("\n✅ Included JARs:")
-        for jar in included_jars:
             jar_name = Path(jar).name
             size_mb = Path(jar).stat().st_size / 1024 / 1024
             print(f"   - {jar_name} ({size_mb:.1f}MB)")
 
-        return included_jars
-
-    return []
+    return all_jars
 
 
 def copy_jars_to_package():