265 lines
10 KiB
Python
265 lines
10 KiB
Python
#!/usr/bin/env python
|
|
"""
|
|
From the packwiz toml files, look up the mod descriptions from the modrinth API
|
|
and collect them into an html page using yattag.
|
|
|
|
The toml files look like:
|
|
|
|
```
|
|
name = "almostunified-fabric-1.20.1-0.9.4"
|
|
filename = "almostunified-fabric-1.20.1-0.9.4.jar"
|
|
side = "both"
|
|
|
|
[download]
|
|
url = "https://cdn.modrinth.com/data/sdaSaQEz/versions/iVBf0ICr/almostunified-fabric-1.20.1-0.9.4.jar"
|
|
hash = "ec47335d9d8b98c107a2b4cb4bada845669728f78c65df2ef2ee5e06d9ac866d276d09892896c216e30eb028a6fdd0a6cc92a8741eee1c14fa3d0ca24444cbdb"
|
|
hash-format = "sha512"
|
|
mode = "url"
|
|
|
|
[option]
|
|
optional = false
|
|
default = false
|
|
|
|
[update.modrinth]
|
|
mod-id = "sdaSaQEz"
|
|
version = "iVBf0ICr"
|
|
```
|
|
|
|
So the update.modrinth.mod-id is the one to look up.
|
|
"""
|
|
|
|
import os
|
|
import toml
|
|
import requests
|
|
from yattag import Doc, indent
|
|
import requests_cache
|
|
import logging
|
|
from tqdm import tqdm
|
|
import json
|
|
import os
|
|
import markdown
|
|
from bs4 import BeautifulSoup
|
|
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
session = requests_cache.CachedSession('collectmoddescriptions', cache_control=True)
|
|
|
|
|
|
def collect_mod_info(directory):
|
|
mods = {}
|
|
files = os.listdir(directory)
|
|
for filename in tqdm(files, desc="Processing mod files", unit="file"):
|
|
if filename.endswith('.toml'):
|
|
file_path = os.path.join(directory, filename)
|
|
logger.debug(f"Processing file: {file_path}")
|
|
with open(file_path, 'r') as file:
|
|
data = toml.load(file)
|
|
if 'update' in data and 'modrinth' in data['update']:
|
|
mod_id = data['update']['modrinth'].get('mod-id')
|
|
if mod_id:
|
|
url = f"https://api.modrinth.com/v2/project/{mod_id}"
|
|
response = session.get(url)
|
|
if response.status_code == 200:
|
|
project_data = response.json()
|
|
mods[mod_id] = project_data
|
|
else:
|
|
raise Exception(f"Failed to fetch data for mod ID: {mod_id}")
|
|
return mods
|
|
|
|
"""
|
|
Calculate the dependency tree of the flat list of mod version ids, such that mods that aren't
|
|
depended on by other mods are at the top level, and other mods are nested
|
|
under the top-level mods that depend on them (possibly mulitiple times).
|
|
|
|
In the Modrinth schema, a project has versions, which have dependencies on other
|
|
project's versions.
|
|
"""
|
|
def get_mod_dependencies(version_id):
|
|
url = f"https://api.modrinth.com/v2/version/{version_id}"
|
|
response = requests.get(url)
|
|
if response.status_code == 200:
|
|
version_data = response.json()
|
|
dependencies = version_data.get('dependencies', [])
|
|
return [dep["project_id"] for dep in dependencies if dep.get('dependency_type') == 'required']
|
|
else:
|
|
print(f"Error fetching version data: {response.status_code}")
|
|
return []
|
|
|
|
def build_dependency_tree(directory):
|
|
cache_file = 'dependency_tree_cache.json'
|
|
if os.path.exists(cache_file):
|
|
with open(cache_file, 'r') as f:
|
|
return json.load(f)
|
|
|
|
dependency_tree = {}
|
|
files = os.listdir(directory)
|
|
for filename in tqdm(files, desc="Building dependency tree", unit="file"):
|
|
if filename.endswith('.toml'):
|
|
file_path = os.path.join(directory, filename)
|
|
with open(file_path, 'r') as file:
|
|
data = toml.load(file)
|
|
if 'update' in data and 'modrinth' in data['update']:
|
|
mod_id = data['update']['modrinth'].get('mod-id')
|
|
version_id = data['update']['modrinth'].get('version')
|
|
if mod_id and version_id:
|
|
dependencies = get_mod_dependencies(version_id)
|
|
dependency_tree[mod_id] = {
|
|
'name': data['name'],
|
|
'version_id': version_id,
|
|
'dependencies': dependencies
|
|
}
|
|
|
|
with open(cache_file, 'w') as f:
|
|
json.dump(dependency_tree, f)
|
|
|
|
return dependency_tree
|
|
|
|
def get_modrinth_url(slug):
|
|
return f"https://modrinth.com/mod/{slug}"
|
|
|
|
def render_dependency_tree(tree, mod_id, mod_info, level=0):
|
|
doc, tag, text = Doc().tagtext()
|
|
mod_data = tree.get(mod_id)
|
|
if mod_data:
|
|
with tag('div', style=f"margin-left: {level * 20}px;"):
|
|
with tag('h3'):
|
|
with tag('a', href=get_modrinth_url(mod_info[mod_id]['slug'])):
|
|
text(mod_data['name'])
|
|
for dep_id in mod_data['dependencies']:
|
|
if dep_id in tree:
|
|
doc.asis(render_dependency_tree(tree, dep_id, mod_info, level + 1))
|
|
return doc.getvalue()
|
|
# mods you need to know about
|
|
# content you can find in the world
|
|
# optimization
|
|
# dependencies
|
|
|
|
def generate_html(mod_info, dependency_tree):
|
|
doc, tag, text = Doc().tagtext()
|
|
|
|
doc.asis('<!DOCTYPE html>')
|
|
with tag('html'):
|
|
with tag('head'):
|
|
with tag('title'):
|
|
text('Mod Descriptions and Dependencies')
|
|
doc.stag('link', rel='stylesheet', href='pico.min.css')
|
|
doc.stag('link', rel='stylesheet', href='style.css')
|
|
|
|
with tag('main', klass="container"):
|
|
with tag('h1'):
|
|
text('Mod Descriptions and Dependencies')
|
|
|
|
with tag('h2'):
|
|
text('Mod Descriptions')
|
|
with tag('div', id='mod-descriptions'):
|
|
for mod_id, info in mod_info.items():
|
|
with tag('article', klass='mod-description'):
|
|
with tag('header'):
|
|
with tag('h3'):
|
|
if 'icon_url' in info and info['icon_url']:
|
|
src = ""+info['icon_url']
|
|
doc.stag('img', src=src, klass='mod-icon')
|
|
with tag('a', href=get_modrinth_url(info['slug'])):
|
|
text(info['title'])
|
|
with tag('ul', klass='categories'):
|
|
for category in info['categories']:
|
|
with tag('li', klass=category.lower().replace(' ', '-')):
|
|
text(category)
|
|
with tag('p'):
|
|
with tag('details'):
|
|
with tag('summary'):
|
|
text(info['description'])
|
|
with tag('div', klass='full-description'):
|
|
bodydoc = BeautifulSoup(markdown.markdown(info['body']), features='html.parser')
|
|
doc.asis(bodydoc.prettify())
|
|
|
|
with tag('h2'):
|
|
text('Mods by Category')
|
|
categories = {}
|
|
for mod_id, mod_info_dict in mod_info.items():
|
|
for category in mod_info_dict['categories']:
|
|
if category not in categories:
|
|
categories[category] = []
|
|
categories[category].append((mod_info_dict['title'], mod_info_dict['slug'], mod_info_dict['description'], mod_info_dict['icon_url']))
|
|
|
|
for category, mods in categories.items():
|
|
with tag('h3'):
|
|
text(category)
|
|
with tag('ul'):
|
|
for (mod_name, slug, description, icon_url) in mods:
|
|
with tag('li'):
|
|
if icon_url:
|
|
doc.stag('img', src=icon_url, alt=f"{mod_name} icon", klass="mod-icon-category")
|
|
with tag('a', href=get_modrinth_url(slug)):
|
|
text(mod_name)
|
|
text(f": {description}")
|
|
|
|
with tag('h2'):
|
|
text('Dependency Tree')
|
|
for mod_id in dependency_tree:
|
|
if not any(mod_id in dep['dependencies'] for dep in dependency_tree.values()):
|
|
doc.asis(render_dependency_tree(dependency_tree, mod_id, mod_info))
|
|
|
|
return doc.getvalue()
|
|
|
|
def generate_dot_graph(mod_info, dependency_tree):
|
|
dot_content = "digraph ModDependencies {\n"
|
|
dot_content += " node [shape=box];\n"
|
|
|
|
for mod_id, info in mod_info.items():
|
|
url = get_modrinth_url(info['slug'])
|
|
dot_content += f' "{mod_id}" [label="{info["title"]}", URL="{url}"];\n'
|
|
|
|
for mod_id, deps in dependency_tree.items():
|
|
for dep in deps['dependencies']:
|
|
dot_content += f' "{mod_id}" -> "{dep}";\n'
|
|
|
|
dot_content += "}"
|
|
return dot_content
|
|
|
|
|
|
def main(directory, output_filename, output_format='html'):
|
|
mod_info = collect_mod_info(directory)
|
|
dependency_tree = build_dependency_tree(directory)
|
|
|
|
if output_format == 'html':
|
|
output_content = generate_html(mod_info, dependency_tree)
|
|
elif output_format == 'json':
|
|
import json
|
|
output_content = json.dumps({
|
|
'mod_info': mod_info,
|
|
'dependency_tree': dependency_tree
|
|
}, indent=2)
|
|
elif output_format == 'dot':
|
|
output_content = generate_dot_graph(mod_info, dependency_tree)
|
|
else:
|
|
raise ValueError("Invalid output format. Use 'html', 'json', or 'dot'.")
|
|
|
|
with open(output_filename, 'w', encoding='utf-8') as f:
|
|
f.write(output_content)
|
|
|
|
print(f"File with mod descriptions and dependency tree has been generated: {output_filename}")
|
|
|
|
if __name__ == '__main__':
|
|
import sys
|
|
if len(sys.argv) != 3:
|
|
print("Usage: python script.py <directory> <output_filename>")
|
|
print("output_filename should end with '.html', '.json', or '.dot'")
|
|
sys.exit(1)
|
|
|
|
directory = sys.argv[1]
|
|
output_filename = sys.argv[2]
|
|
|
|
if output_filename.lower().endswith('.html'):
|
|
output_format = 'html'
|
|
elif output_filename.lower().endswith('.json'):
|
|
output_format = 'json'
|
|
elif output_filename.lower().endswith('.dot'):
|
|
output_format = 'dot'
|
|
else:
|
|
print("Error: output_filename must end with '.html', '.json', or '.dot'")
|
|
sys.exit(1)
|
|
|
|
main(directory, output_filename, output_format)
|