Unified Device Support

Author: DelightReza

assets/scripts/sync_all_devices.py

@@ -28,12 +28,7 @@ def fetch_json(url):
         return None
 
 def fetch_sourceforge_builds(target_codename):
-    """
-    Fetches builds from SourceForge using the target_codename.
-    For unified devices, this target_codename is the unified name (e.g., 'miatoll').
-    """
     rss_url = f"https://sourceforge.net/projects/pbrp/rss?path=/{target_codename}"
-    
     builds = []
 
     try:
@@ -42,28 +37,20 @@ def fetch_sourceforge_builds(target_codename):
             data=None, 
             headers={'User-Agent': 'PBRP-Manager/1.0'}
         )
-        
         with urllib.request.urlopen(req) as response:
             xml_data = response.read().decode()
 
         root = ET.fromstring(xml_data)
-        
         for item in root.findall('./channel/item'):
             title = item.find('title').text 
             link = item.find('link').text
             pub_date_str = item.find('pubDate').text
 
-            # Strict path check
-            if not title.startswith(f"/{target_codename}/"):
-                continue
-                
+            if not title.startswith(f"/{target_codename}/"): continue
             filename = title.split('/')[-1]
-            
-            if not (filename.endswith('.zip') or filename.endswith('.img')):
-                continue
+            if not (filename.endswith('.zip') or filename.endswith('.img')): continue
 
             match = ZIP_META_PATTERN.search(filename)
-            
             version = "Unknown"
             build_type = "UNOFFICIAL"
             date_str = "Unknown"
@@ -73,14 +60,12 @@ def fetch_sourceforge_builds(target_codename):
                 dt = parsedate_to_datetime(pub_date_str)
                 date_str = dt.strftime("%Y-%m-%d")
                 timestamp = dt.timestamp()
-            except:
-                pass
+            except: pass
 
             if match:
                 version = match.group(1)
                 raw_date = match.group(2)
                 build_type = match.group(3).upper()
-                
                 if len(raw_date) == 8:
                     date_str = f"{raw_date[0:4]}-{raw_date[4:6]}-{raw_date[6:8]}"
             elif filename.endswith('.img'):
@@ -89,73 +74,51 @@ def fetch_sourceforge_builds(target_codename):
 
             download_link = link if link.endswith('/download') else f"{link}/download"
 
-            build_info = {
+            builds.append({
                 "version": version,
                 "build_type": build_type,
                 "date": date_str,
                 "download_link": download_link,
                 "github_release": None,
                 "changelog": "- Auto-fetched from SourceForge",
                 "_timestamp": timestamp
-            }
-            builds.append(build_info)
+            })
 
     except urllib.error.HTTPError as e:
-        if e.code == 404:
-            return [] # Folder doesn't exist
+        if e.code == 404: return []
         print(f"    -> Warning: SF HTTP Error ({e.code})")
         return []
     except Exception as e:
         print(f"    -> Warning: Could not fetch SF data ({e})")
         return []
 
-    # Sort by timestamp descending
     builds.sort(key=lambda x: x['_timestamp'], reverse=True)
-    
-    for b in builds:
-        del b['_timestamp']
-        
+    for b in builds: del b['_timestamp']
     return builds
 
 def process_device(vendor, device_codename, build_source_codename, specific_data):
-    """
-    vendor: Manufacturer
-    device_codename: The actual device (e.g. curtana)
-    build_source_codename: Where files are located (e.g. miatoll)
-    specific_data: JSON object containing 'name', 'maintainer' etc.
-    """
     vendor_lower = vendor.lower()
     vendor_dir = os.path.join(OEM_DIR, vendor_lower)
     md_path = os.path.join(vendor_dir, f"{device_codename}.md")
 
-    # 1. Skip if MD exists
-    if os.path.exists(md_path):
-        return False
+    if os.path.exists(md_path): return False
 
     print(f"Checking: {vendor}/{device_codename} (Source: {build_source_codename})...")
 
-    # 2. Check SourceForge using the BUILD SOURCE codename
     found_builds = fetch_sourceforge_builds(build_source_codename)
-    
     if not found_builds:
         print(f"  -> [SKIP] No builds found on SourceForge for '{build_source_codename}'")
         return False
 
-    # If we are here, files exist on SF. Proceed to create pages.
-    if not os.path.exists(vendor_dir):
-        os.makedirs(vendor_dir)
-
+    if not os.path.exists(vendor_dir): os.makedirs(vendor_dir)
     print(f"  -> [NEW] Found {len(found_builds)} builds! Creating pages...")
 
-    # 3. Create Markdown File
-    # Use specific name if available, otherwise capitalize codename
     device_name = specific_data.get('name', device_codename.capitalize())
-    
-    # Clean maintainer name
     raw_maintainer = specific_data.get('maintainer', 'Unknown')
     maintainer = raw_maintainer.replace('@', '').strip()
 
-    tree_url = f"https://github.com/PitchBlackRecoveryProject/android_device_{vendor_lower}_{device_codename}-pbrp"
+    # Use build_source_codename (Parent) for the repo tree URL
+    tree_url = f"https://github.com/PitchBlackRecoveryProject/android_device_{vendor_lower}_{build_source_codename}-pbrp"
 
     md_content = f"""---
 layout: device
@@ -175,17 +138,13 @@ def process_device(vendor, device_codename, build_source_codename, specific_data
 {{% include pbrpinstall.html %}}
 """
     try:
-        with open(md_path, 'w') as f:
-            f.write(md_content)
+        with open(md_path, 'w') as f: f.write(md_content)
         print(f"  -> Created MD: {md_path}")
     except Exception as e:
         print(f"  -> Error creating MD: {e}")
         return False
 
-    # 4. Create JSON Build File
-    if not os.path.exists(JSON_DIR):
-        os.makedirs(JSON_DIR)
-
+    if not os.path.exists(JSON_DIR): os.makedirs(JSON_DIR)
     json_path = os.path.join(JSON_DIR, f"builds-{device_codename}.json")
 
     json_data = {
@@ -194,8 +153,7 @@ def process_device(vendor, device_codename, build_source_codename, specific_data
     }
 
     try:
-        with open(json_path, 'w') as f:
-            json.dump(json_data, f, indent=2)
+        with open(json_path, 'w') as f: json.dump(json_data, f, indent=2)
         print(f"  -> Created JSON: {json_path}")
     except Exception as e:
         print(f"  -> Error creating JSON: {e}")
@@ -205,56 +163,37 @@ def process_device(vendor, device_codename, build_source_codename, specific_data
 def main():
     print(f"Connecting to master device list...")
     data = fetch_json(DEVICES_JSON_URL)
-    if not data:
-        return
+    if not data: return
 
-    # 1. Build a map of Child -> Parent for unified devices
-    # e.g. {'curtana': 'miatoll', 'joyeuse': 'miatoll'}
     child_to_parent_map = {}
-    
     for vendor, devices in data.items():
         for key, device_data in devices.items():
             if "unified" in device_data and isinstance(device_data["unified"], list):
                 for child in device_data["unified"]:
-                    # We map child to the parent key (which matches SF folder)
                     child_to_parent_map[child] = key
 
     processed_codenames = set()
     new_devices_count = 0
 
-    # 2. First Pass: Process every device EXPLICITLY listed in the JSON
-    # This ensures 'curtana' uses its own "name" field, even if it's unified.
+    # 1. Process Explicit Entries
     for vendor, devices in data.items():
         for key, device_data in devices.items():
-            
-            # Determine Build Source
-            # If this key is a child in the map, use parent. Otherwise use self.
             build_source = child_to_parent_map.get(key, key)
-            
             if process_device(vendor, key, build_source, device_data):
                 new_devices_count += 1
-            
             processed_codenames.add(key)
 
-    # 3. Second Pass: Process "Implicit" children
-    # Devices listed in a "unified" array but NOT having their own key in the JSON
+    # 2. Process Implicit Children
     for vendor, devices in data.items():
         for key, device_data in devices.items():
             if "unified" in device_data and isinstance(device_data["unified"], list):
                 parent_source = key
                 parent_maintainer = device_data.get('maintainer', 'Unknown')
-                
                 for child in device_data["unified"]:
                     if child not in processed_codenames:
-                        # Fallback data for implicit child
-                        fallback_data = {
-                            "name": child.capitalize(), 
-                            "maintainer": parent_maintainer
-                        }
-                        
+                        fallback_data = {"name": child.capitalize(), "maintainer": parent_maintainer}
                         if process_device(vendor, child, parent_source, fallback_data):
                             new_devices_count += 1
-                        
                         processed_codenames.add(child)
 
     print("-" * 30)