{escaped_code}{md5_hash}'),
("type_label", media['media_type']),
("mime_label", media.get('mime_type') or 'unknown'),
("size_label", f"{media.get('file_size') or 0:,} bytes"),
("alt_label", media.get('alt_text') or '-'),
("keywords_label", keywords_html),
]
# Download button - prioritize original filename from URL
download_filename = None
if sources and sources[0].get('media_uri'):
from urllib.parse import unquote
parsed = Uri(sources[0]['media_uri'])
orig_name = Path(unquote(parsed.path)).name
if orig_name and '.' in orig_name:
download_filename = orig_name
# Fallback to alt_text/title
if not download_filename:
name_source = media.get('alt_text') or media.get('title')
if name_source:
ext_map = {'image/jpeg': '.jpg', 'image/png': '.png', 'image/gif': '.gif', 'image/webp': '.webp',
'video/mp4': '.mp4', 'video/webm': '.webm', 'audio/mpeg': '.mp3', 'audio/wav': '.wav',
'text/javascript': '.js', 'text/python': '.py', 'text/css': '.css', 'text/html': '.html',
'text/markdown': '.md', 'text/rust': '.rs', 'text/go': '.go', 'text/c': '.c', 'text/cpp': '.cpp'}
ext = ext_map.get(media.get('mime_type', ''), '')
if not ext:
try:
subdir = app_config.VAULT_PATH / hash_to_path(md5_hash).parent
for f in subdir.iterdir():
if f.stem == md5_hash:
ext = f.suffix
break
except Exception:
pass
download_filename = f"{slugify(name_source)}{ext}"
# Fallback to page_title + hash
if not download_filename and sources:
pt = sources[0].get('page_title', '')
media_idx = int(md5_hash[:4], 16)
name_source = f"{pt}-{media_idx}" if pt else f"media-{media_idx}"
download_filename = f"{slugify(name_source)}.bin"
# Default
if not download_filename:
download_filename = f"{md5_hash[:12]}.bin"
download_btn = f'Download ({download_filename})'
# Get page media items (siblings)
media_items = await db.get_page_media(page_uri) if page_uri else []
# Exclude current item from gallery
media_items = [m for m in media_items if m.get("md5_hash") != md5_hash]
# Get rendered content
content_html = ""
if page_uri:
page_row = await db.get_page_by_uri(page_uri)
if page_row and page_row.get("markdown"):
try:
import markdown
md_converter = markdown.Markdown(extensions=['fenced_code', 'tables', 'nl2br'])
content_html = md_converter.convert(page_row["markdown"][:100000])
# Hydrate images and links
img_urls = re.findall(r'{html_module.escape(page_row['markdown'][:50000])}"
# Get screenshots (exclude current if it's a screenshot)
screenshot_hashes = await db.get_page_screenshots(page_uri) if page_uri else []
screenshot_hashes = [h for h in screenshot_hashes if h != md5_hash]
# Build "Used on X pages" section (reverse image search)
t = TRANSLATIONS.get(language, TRANSLATIONS["en"])
sources_html = ""
if sources and len(sources) > 0:
import hashlib as hl
unique_pages = {}
for s in sources:
pu = s.get('page_uri', '')
if pu and pu not in unique_pages:
unique_pages[pu] = s
if unique_pages:
rows_html = ""
for pu, s in unique_pages.items():
pt = html_module.escape(s.get('page_title', '') or pu[:60])
ph = hl.md5(pu.encode()).hexdigest()
rows_html += f'''| {t["page"]} | {t["discovered"]} |
|---|
{html_module.escape(page.get('markdown', '')[:50000])}"
elif page.get("content"):
escaped = html_module.escape(page["content"][:50000])
content_html = f"{escaped}"
# Get screenshots and media
screenshot_hashes = await db.get_page_screenshots(uri)
media_items = await db.get_page_media(uri)
# Metadata rows - (key, value) where key is looked up via t.get(key, key)
import hashlib
uri_hash = hashlib.md5(uri.encode()).hexdigest()
neopig_page_uri = f"/page/{uri_hash}"
keywords = json.loads(page.get('keywords') or '[]') if page.get('keywords') else []
keywords_html = ''.join([f'{k}' for k in keywords]) or '-'
meta_rows = [
("source_uri", f'{uri}'),
("neopig_uri", f'{neopig_page_uri}'),
("description_label", page.get('description') or '-'),
("keywords_label", keywords_html),
("media", f"{len(media_items)}"),
]
return templates.TemplateResponse("view.html.j2", {
"request": request,
"t": TRANSLATIONS.get(language, TRANSLATIONS["en"]),
"t_json": json.dumps(TRANSLATIONS.get(language, TRANSLATIONS["en"])),
"title": page_title,
"hero_html": "",
"meta_rows": meta_rows,
"media_items": media_items,
"content_html": content_html,
"screenshot_hashes": screenshot_hashes,
"source_domain": source_domain,
"page_uri": uri,
"download_btn_html": "",
"noai": noai,
"sources_html": "",
"lang": language,
"langs": LANG_NAMES,
"import_mode": IMPORT_MODE,
})
@app.get("/page/{uri_hash}", response_class=HTMLResponse)
async def view_page_by_hash(request: Request, uri_hash: str, noai: bool = Query(False), language: str = Depends(get_language)):
"""View an archived page by URI hash."""
page = await db.get_page_by_hash(uri_hash)
if not page:
raise HTTPException(status_code=404, detail="Page not found")
return await _render_page(request, page['uri'], noai, language)
@app.get("/page/view", response_class=HTMLResponse)
async def view_page(request: Request, uri: str = Query(...), noai: bool = Query(False), language: str = Depends(get_language)):
"""View an archived page by URI. Use ?lang=XX to force language."""
return await _render_page(request, uri, noai, language)
@app.get("/phantom/export")
async def phantom_export(domain: str = Query(None, description="Filter by domain")):
"""
Export a phantom HTML site - original HTML with media URLs rewritten to vault.
Creates a downloadable zip of the phantom site ready for static hosting.
"""
import io
import re
import zipfile
from urllib.parse import urljoin
from fastapi.responses import StreamingResponse
# Get all pages with raw_html
pages = await db.get_pages_by_domain(domain)
if not pages:
raise HTTPException(status_code=404, detail="No pages with raw HTML found")
# Get all media URL to hash mappings
url_to_hash = await db.get_all_media_uri_mappings()
# Create zip in memory
zip_buffer = io.BytesIO()
with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
pages_written = 0
media_hashes = set()
for page in pages:
uri = page['uri']
raw_html = page.get('raw_html')
if not raw_html:
continue
# Parse URI to get path
parsed = Uri(uri)
site_domain = parsed.hostname
path = parsed.path.strip('/') or 'index'
if not path.endswith('.html') and '.' not in path.split('/')[-1]:
path = f"{path}/index.html" if path else "index.html"
# Rewrite media URLs to local paths
html = raw_html
# Find all src and href attributes pointing to media
patterns = [
(r'src=["\']([^"\']+)["\']', 'src'),
(r'href=["\']([^"\']+\.(jpg|jpeg|png|gif|webp|mp4|webm|svg|ico))["\']', 'href'),
]
for pattern, attr in patterns:
matches = re.findall(pattern, html, re.IGNORECASE)
for match in matches:
url = match[0] if isinstance(match, tuple) else match
# Resolve relative URLs
full_url = urljoin(uri, url)
# Check if we have this media
if full_url in url_to_hash:
md5 = url_to_hash[full_url]
media_hashes.add(md5)
# Replace with local path
ext = Path(url).suffix or '.bin'
local_path = f"media/{md5}{ext}"
html = html.replace(f'{attr}="{url}"', f'{attr}="{local_path}"')
html = html.replace(f"{attr}='{url}'", f'{attr}="{local_path}"')
elif url in url_to_hash:
md5 = url_to_hash[url]
media_hashes.add(md5)
ext = Path(url).suffix or '.bin'
local_path = f"media/{md5}{ext}"
html = html.replace(f'{attr}="{url}"', f'{attr}="{local_path}"')
html = html.replace(f"{attr}='{url}'", f'{attr}="{local_path}"')
# Write HTML file
zf.writestr(f"site/{path}", html.encode('utf-8'))
pages_written += 1
# Copy media files from vault
media_copied = 0
for md5 in media_hashes:
subdir = app_config.VAULT_PATH / md5[:2]
if subdir.exists():
for f in subdir.iterdir():
if f.name.startswith(md5):
ext = f.suffix or '.bin'
zf.write(f, f"site/media/{md5}{ext}")
media_copied += 1
break
# Write index
index_html = f"""
Domain: {site_domain}
Pages: {pages_written}
Media: {media_copied}