init commit

.gitignore

@@ -0,0 +1 @@
+error*

get_pages.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+
+import bs4
+import requests
+import time
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+NUM_PAGES = 422
+BASE_URL = 'https://www.grabcraft.com'
+MAX_RETRIES = 5
+RETRY_DELAY = 2  # seconds
+
+def fetch_page(i):
+  for attempt in range(MAX_RETRIES):
+    try:
+      r = requests.get(f'{BASE_URL}/minecraft/pg/{i}')
+      if r.status_code == 200:
+        soup = bs4.BeautifulSoup(r.text, 'html.parser')
+        return [BASE_URL + '/'.join(a['href'].split('/')[:-1]) for a in soup.find_all('a', attrs={'class': 'button more-info details'})]
+      else:
+        print(f'Error: {r.status_code} on page {i}')
+    except requests.RequestException as e:
+      print(f'Exception: {e} on page {i}')
+    time.sleep(RETRY_DELAY)
+  with open('errors.txt', 'a') as error_file:
+      error_file.write(f'Failed to fetch page {i} after {MAX_RETRIES} attempts.\n')
+  return []
+
+if __name__ == '__main__':
+  pages = []
+  with ThreadPoolExecutor() as executor:
+    futures = {executor.submit(fetch_page, i): i for i in range(NUM_PAGES + 1)}
+    for future in tqdm(as_completed(futures), total=len(futures)):
+      pages += future.result()
+  with open('pages.txt', 'w') as f:
+    f.write('\n'.join(set(pages)))

minecraft_structures.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91a2f09180db716b37d4a9bdcaa1a17b8ce5fd18bd49e693078ea1fb564a29d4
+size 16516703

parse_pages.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+
+import urllib3
+from bs4 import BeautifulSoup
+import json
+import sqlite3
+import concurrent.futures
+from tqdm import tqdm
+import traceback
+
+def process_url(url):
+  try:
+    structure_name = url.split('/minecraft/')[-1].replace('#blueprints', '')
+    http = urllib3.PoolManager()
+    r = http.request('GET', url)
+    soup = BeautifulSoup(r.data.decode('utf-8'), 'html.parser')
+
+    obj = next(s['src'] for s in soup.find_all('script') if 'src' in s.attrs and 'myRenderObject' in s['src'])
+    r = http.request('GET', obj)
+    data = r.data.decode('utf-8')
+    eq = data.find('=')
+    d = json.loads(data[eq+1:])
+
+    conn = sqlite3.connect('minecraft_structures.db')
+    cur = conn.cursor()
+
+    cur.execute(f'''
+      CREATE TABLE IF NOT EXISTS "{structure_name}" (
+        x INTEGER,
+        y INTEGER,
+        z INTEGER,
+        block_name TEXT
+      )
+    ''')
+
+    for level, blocks in d.items():
+      for x, z_block in blocks.items():
+        for z, block in z_block.items():
+          cur.execute(f'INSERT INTO "{structure_name}" (x, y, z, block_name) VALUES (?, ?, ?, ?)',
+                (int(x), int(level), int(z), block['name']))
+
+    conn.commit()
+    conn.close()
+    return None
+  except Exception as e:
+    return f"Error processing {url}: {str(e)}\n{traceback.format_exc()}"
+
+with open('pages.txt', 'r') as f:
+  urls = [line.strip() for line in f if line.strip()]
+
+errors = []
+with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+  futures = [executor.submit(process_url, url) for url in urls]
+  for future in tqdm(concurrent.futures.as_completed(futures), total=len(urls), desc="Processing URLs"):
+    result = future.result()
+    if result:
+      errors.append(result)
+
+if errors:
+  with open('errors.log', 'w') as f:
+    for error in errors:
+      f.write(f"{error}\n")
+  print(f"Encountered {len(errors)} errors. Check errors.log for details.")
+else:
+  print("All URLs processed successfully.")

sql_to_parquet.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+import sqlite3
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+def sqlite_to_parquet(sqlite_file, parquet_file):
+  conn = sqlite3.connect(sqlite_file)
+  cur = conn.cursor()
+
+  cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
+  tables = cur.fetchall()
+
+  df_list = []
+
+  for table in tables:
+    table_name = table[0]
+    query = f'SELECT x, y, z, block_name as mat FROM "{table_name}"'
+    df = pd.read_sql_query(query, conn)
+    df['structure'] = table_name
+    df_list.append(df)
+
+  final_df = pd.concat(df_list, ignore_index=True)
+
+  table = pa.Table.from_pandas(final_df)
+  pq.write_table(table, parquet_file)
+
+  conn.close()
+
+if __name__ == '__main__':
+  sqlite_to_parquet('minecraft_structures.db', 'minecraft_structures.parquet')
+  print("Conversion to Parquet completed successfully.")