#!/usr/bin/env python3
"""
Static job board generator — fast, modern, and SEO-optimized.
This script is configured for: OmniCareers (omnijobs.eu.com)
Ad implementation reverted to direct injection (like 1p24-flight-old-003.py).
[REMOVED] JavaScript for resizing main content based on ad width is removed.
Usage:
pip install orjson lxml beautifulsoup4
python 1psimple27-add.py
"""
import os
import random
import re
import datetime
import logging
import shutil
import argparse
import sys
import concurrent.futures
from datetime import timezone, timedelta
from textwrap import wrap
import html
import textwrap # <-- ADDED FOR IMPROVED IMAGE GENERATION
# ---------- JSON helpers (robust across orjson / stdlib) ----------
try:
import orjson as _oj
_USE_OJ = True
logging.info("Using 'orjson' for faster JSON processing.")
except ImportError:
_oj = None
_USE_OJ = False
logging.info("Using standard 'json' library. For a speed boost, consider 'pip install orjson'.")
import json as _sj
def jloads(s):
"""Safely load a JSON string."""
return _oj.loads(s) if _USE_OJ else _sj.loads(s)
def jdumps(obj, indent=False):
"""Safely dump an object to a JSON string."""
if _USE_OJ:
opt = _oj.OPT_INDENT_2 if indent else 0
return _oj.dumps(obj, option=opt).decode('utf-8')
return _sj.dumps(obj, ensure_ascii=False, indent=2 if indent else None)
# ---------- HTML parsing ----------
try:
import lxml # noqa: F401
BS4_PARSER = 'lxml'
logging.info("Using 'lxml' parser.")
except ImportError:
BS4_PARSER = 'html.parser'
logging.info("Using 'html.parser'. For speed: pip install lxml.")
from bs4 import BeautifulSoup, Comment
# ---------- Config ----------
CONFIG = {
"NDJSON_PATH": r'./schema.ndjson',
"OUTPUT_DIR": r'./jobs',
"PAGE_LIMIT": 300000,
"SITE_BASE_URL": 'https://walmart.uscareers.co.com',
"STATIC_SITE_HEADER_TITLE": "WalmartJobs",
"SITE_AUTHOR": "WalmartJobs",
"SITE_LOGO_URL": "https://walmart.uscareers.co.com/logo.png",
"FALLBACK_SALARY_TEXT": "Negotiable",
"JOBS_LISTING_PAGE_SLUG": "jobs",
"JOBS_LISTING_BREADCRUMB_NAME": "All Jobs",
"JOB_LISTING_PAGE_TITLE": "New WalmartJobs (Warehouse, Driver, etc.)",
"JOBS_PER_PAGE": 12,
"DEFAULT_JOB_PAGE_IMAGE_URL": "https://walmart.uscareers.co.com/logo.png",
"HOMEPAGE_TITLE": "WalmartJobs | Find Warehouse, Driver & Pharmacy Jobs",
"HOMEPAGE_META_DESCRIPTION": "Discover thousands of job opportunities at Walmart. Find roles in our fulfillment centers, as a delivery driver, or in our pharmacies.",
"HOMEPAGE_OG_IMAGE_URL": "https://walmart.uscareers.co.com/logo.png",
"HOMEPAGE_TWITTER_HANDLE": "@walmart_careers_jobs",
"SOCIAL_LINKS": [
"https://www.facebook.com/WalmartCareers",
"https://www.linkedin.com/company/Walmart",
"https://twitter.com/WalmartCareers"
],
"GENERATE_ONLY_JOB_POSTS": False,
"APPLY_EMAIL": "contact@walmart.uscareers.co.com",
# --- New Static Page Content ---
"ABOUT_PAGE_TITLE": "About WalmartJobs",
"ABOUT_PAGE_META_DESCRIPTION": "Learn more about the opportunities, culture, and benefits of working at Walmart.",
"ABOUT_PAGE_CONTENT": (
"
Our Mission
"
"
Welcome to our WalmartJobs portal. We are dedicated to finding talented individuals to join our teams, from our fulfillment centers to our corporate offices.
"
"
We are a company of builders. We look for people who are passionate about innovation and customer obsession. Explore our openings to find your next opportunity.
"
"
Why Choose Us?
"
"
We offer competitive wages, comprehensive benefits, and opportunities for growth. Whether you're looking for a seasonal role or a long-term career, you can build your future with us.
"
),
"CONTACT_PAGE_TITLE": "Contact Us | WalmartJobs",
"CONTACT_PAGE_META_DESCRIPTION": "Get in touch with the WalmartJobs team. We're here to help with your questions, feedback, or support needs.",
"CONTACT_SUPPORT_EMAIL": "support@walmart.uscareers.co.com", # For general support
"CONTACT_PAGE_CONTENT": (
"
We'd love to hear from you! Whether you have a question about a job listing, "
"need help with your application, or want to provide feedback, our team is ready to assist.
"
"
For general inquiries or support: "
"Please email us at: {{ support_email }}
"
"
For partnership inquiries: "
"Please reach out to our team at: {{ apply_email }}
"
"
We strive to respond to all inquiries within 24-48 business hours.
"""
# ---------- Logging ----------
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
# ---------- Helpers ----------
def read_ad_file(filename):
"""Reads an ad file, returning empty string if not found."""
try:
with open(filename, 'r', encoding='utf-8') as f:
return f.read()
except FileNotFoundError:
logging.warning(f"Ad file not found: {filename}. Skipping this ad section.")
return ""
def print_progress_bar(iteration, total, prefix='', suffix='', decimals=1, length=50, fill='█'):
"""Displays a simple progress bar in the console."""
if total == 0: total = 1
percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
filled_length = int(length * iteration // total)
bar = fill * filled_length + '-' * (length - filled_length)
sys.stdout.write(f'\r{prefix} |{bar}| {percent}% {suffix}')
sys.stdout.flush()
if iteration == total:
sys.stdout.write('\n')
sys.stdout.flush()
# [PERF] Add HTML minification function
def minify_html(html_text:str)->str:
"""
Minifies HTML text, skipping JSON-LD and standard script blocks more reliably.
"""
result_lines = []
in_script = False
for line in html_text.splitlines():
original_line = line # Keep the original line content
# --- Script Block Detection ---
is_script_start = False
if not in_script: # Only check for start if not already inside
if "" in line:
is_script_end = True
# Don't set in_script = False until *after* processing this line
# --- Processing ---
if in_script:
# If we are inside a script block (including the start/end lines),
# append the original line without modification.
result_lines.append(original_line)
else:
# Only apply minification if we are outside a script block
minified_line = re.sub(r'', '', line, flags=re.DOTALL) # drop comments
minified_line = re.sub(r'>\s+<', '><', minified_line) # collapse gaps between tags
minified_line = minified_line.strip() # strip leading/trailing whitespace
if minified_line: # Only add if there's content left after minifying
result_lines.append(minified_line)
# Update in_script status *after* processing the line containing
if is_script_end:
in_script = False
# Join the processed lines back together
return '\n'.join(result_lines)
def slugify(title_str):
"""Generates a clean, URL-safe slug from a string, with a random suffix."""
if not title_str: title_str = "untitled-job"
s = title_str.lower().strip()
s = re.sub(r'[\s_-]+', '-', s) # Replace spaces/underscores with dashes
s = re.sub(r'[^\w-]', '', s) # Remove invalid characters
s = re.sub(r'-+', '-', s).strip('-') # Remove duplicate/trailing dashes
words = s.split('-')[:7] # Limit to 7 words
slug_base = '-'.join(words)
# Add a random suffix to prevent URL collisions
rand_suffix = ''.join(random.choices('0123456789abcdef', k=6))
return f"{slug_base}-{rand_suffix}" if slug_base else f"job-{rand_suffix}"
def get_field(data_dict, *field_keys, default_val=None):
"""
Safely retrieves a nested value from a dictionary.
Example: get_field(data, 'a', 'b', 'c', default_val='-')
"""
current_level = data_dict
for key in field_keys:
if isinstance(current_level, dict) and key in current_level and current_level[key] is not None:
current_level = current_level[key]
else:
return default_val
return current_level
def format_location_display(job_location_schema):
"""Formats the schema 'jobLocation' into a readable string."""
if not job_location_schema: return "Location not specified"
if isinstance(job_location_schema, list):
if not job_location_schema: return "Location not specified"
loc = job_location_schema[0]
else:
loc = job_location_schema
if get_field(loc, '@type') == "Place":
address = get_field(loc, 'address', default_val={})
city = get_field(address, 'addressLocality')
region = get_field(address, 'addressRegion')
if city and region: return f"{city}, {region}"
if city: return city
if region: return region
return "Remote or Unspecified"
def format_employment_type_display(employment_type_data):
"""Formats the schema 'employmentType' into a readable string."""
if not employment_type_data: return "Not Specified"
if isinstance(employment_type_data, list):
return ', '.join([str(et).replace('_', ' ').title() for et in employment_type_data])
return str(employment_type_data).replace('_', ' ').title()
def format_display_date(date_str, output_format="%B %d, %Y"):
"""Formats an ISO date string into a human-readable format."""
if not date_str: return "N/A"
try:
return datetime.datetime.fromisoformat(date_str.replace("Z", "+00:00")).strftime(output_format)
except (ValueError, TypeError):
return date_str # Fallback to original string if parsing fails
def format_salary_display(monetary_amount_schema, config):
"""Formats the schema 'baseSalary' into a readable string."""
if not monetary_amount_schema or not isinstance(monetary_amount_schema, dict):
return config['FALLBACK_SALARY_TEXT']
currency_map = {"USD": "$", "EUR": "€", "GBP": "£"}
currency = get_field(monetary_amount_schema, 'currency', default_val='USD')
currency_symbol = currency_map.get(currency, currency + " ")
value_node = get_field(monetary_amount_schema, 'value')
if not value_node or not isinstance(value_node, dict):
# Handle simple value (e.g., "value": "Negotiable")
return str(get_field(monetary_amount_schema, 'value', default_val=config['FALLBACK_SALARY_TEXT']))
min_val = get_field(value_node, 'minValue')
max_val = get_field(value_node, 'maxValue')
try:
# Format as a range, e.g., "$50,000 - $70,000"
if min_val and max_val:
return f"{currency_symbol}{int(float(min_val)):,} - {currency_symbol}{int(float(max_val)):,}"
if min_val:
return f"From {currency_symbol}{int(float(min_val)):,}"
except (ValueError, TypeError):
pass # Fallback if values are not numeric
return config['FALLBACK_SALARY_TEXT']
def parse_salary_for_chart(base_salary_schema):
"""Extracts min/max salary as floats for the SVG chart."""
min_val, max_val = None, None
try:
value_node = get_field(base_salary_schema, 'value', default_val={})
raw_min = get_field(value_node, 'minValue')
raw_max = get_field(value_node, 'maxValue')
if raw_min is not None:
min_val = float(raw_min)
if raw_max is not None:
max_val = float(raw_max)
except (ValueError, TypeError):
return None, None
return min_val, max_val
def process_job_body_and_create_toc(html_string):
"""
Cleans the job description HTML and generates a Table of Contents
based on
tags.
"""
if not html_string or not isinstance(html_string, str):
return '
Job description not provided.
', ""
# If the input is plain text with newlines, convert it to
tags.
if '<' not in html_string and '\n' in html_string:
html_string = "".join([f"
{p.strip()}
" for p in html_string.split('\n') if p.strip()])
soup = BeautifulSoup(html_string, BS4_PARSER)
# Unwrap 'html' and 'body' tags if they exist
for tag in soup.find_all(['html', 'body']):
tag.unwrap()
# Sanitize: Remove tags that could break the layout or cause security issues
for tag in soup.find_all(['script', 'style', 'iframe', 'link', 'meta']):
tag.decompose()
# Remove HTML comments
for comment in soup.find_all(string=lambda text: isinstance(text, Comment)):
comment.extract()
headings = soup.find_all('h2')
toc_html = ""
# Only create a TOC if there are 2 or more H2s
if len(headings) > 1:
toc_items = []
for h in headings:
text = h.get_text(strip=True)
if text:
slug = slugify(text)
h['id'] = slug # Add an 'id' attribute to the H2 for anchoring
toc_items.append({'href': f'#{slug}', 'text': text})
# Final check, only render if we have multiple valid items
if len(toc_items) > 1:
list_items = "".join([f'
' for item in toc_items])
toc_html = f''
return str(soup), toc_html
# Keywords builder
STOPWORDS = set("a an the in at to for of on and or with from by into over under within near as is are be being been it this that those these their our your you".split())
def build_meta_keywords(title, company):
"""Generates a comma-separated list of keywords from the title and company."""
tokens = re.findall(r"[a-z0-9]+", f"{title} {company}".lower())
cleaned = [t for t in tokens if t not in STOPWORDS and len(t) > 2]
dedup = []
for t in cleaned:
if t not in dedup:
dedup.append(t)
# Ensure company name is prioritized
if company and company.lower() not in dedup:
dedup.insert(0, company.lower())
return ", ".join(dedup[:12]) # Cap at 12 keywords
def update_job_schema(job_schema_input, job_slug, full_job_url, config):
"""Enriches the raw JobPosting schema with required and default values."""
schema = job_schema_input.copy() if isinstance(job_schema_input, dict) else {}
schema['@context'] = "https://schema.org/"
schema['@type'] = "JobPosting"
# Set 'datePosted' and 'validThrough' (e.g., 60 days from now)
usa_timezone = timezone(timedelta(hours=-5)) # Example timezone
now = datetime.datetime.now(usa_timezone)
schema['datePosted'] = now.isoformat()
schema['validThrough'] = (now + datetime.timedelta(days=200)).isoformat()
# Add identifier and URL
schema['identifier'] = {"@type": "PropertyValue", "name": get_field(schema, 'hiringOrganization', 'name', default_val=config['STATIC_SITE_HEADER_TITLE']), "value": job_slug}
schema['url'] = full_job_url
# Ensure hiringOrganization is well-formed
org = get_field(schema, 'hiringOrganization', default_val={})
schema['hiringOrganization'] = {
"@type": "Organization",
"name": get_field(org, 'name', default_val=config['STATIC_SITE_HEADER_TITLE']),
"sameAs": get_field(org, 'sameAs', default_val=config['SITE_BASE_URL']),
"logo": get_field(org, 'logo', default_val=config['SITE_LOGO_URL'])
}
# Ensure description exists
schema['description'] = str(get_field(job_schema_input, 'description', default_val="
No job description provided.
"))
return schema
def get_footer_links_html(config):
"""Generates the HTML for footer links."""
footer_links_style = "display: flex; justify-content: center; gap: 1.5rem; margin-bottom: 1.5rem; font-weight: 500;"
return f"""
"""
def render_html_template(template_str, data_dict):
"""
A simple template renderer. Replaces '{{ key }}' and handles
a basic '{% for job in similar_jobs %}' loop.
"""
# Handle simple {{ key }} replacements
for key, value in data_dict.items():
if not isinstance(value, list):
template_str = template_str.replace(f'{{{{ {key} }}}}', str(value))
# Handle the specific 'similar_jobs' loop
list_pattern = re.compile(r'{% for job in similar_jobs %}(.*?){% endfor %}', re.DOTALL)
match = list_pattern.search(template_str)
if match:
loop_template = match.group(1)
rendered_html = ""
for job in data_dict.get('similar_jobs', []):
item_html = loop_template.replace('{{ job.url }}', job.get('url', '#')).replace('{{ job.title }}', job.get('title', 'Untitled Job'))
rendered_html += item_html
# --- THE FIX IS HERE ---
# Use a lambda (function) to return the string.
# This treats backslashes as literal text, preventing the "bad escape" error.
template_str = list_pattern.sub(lambda m: rendered_html, template_str)
return template_str
def write_stylesheet(output_dir):
"""Writes the minified CSS to style.css in the specified directory."""
css_path = os.path.join(output_dir, "style.css")
try:
os.makedirs(output_dir, exist_ok=True)
with open(css_path, 'w', encoding='utf-8') as f:
f.write(CSS_STYLES)
logging.info(f"Successfully created stylesheet: {css_path}")
except IOError as e:
logging.error(f"Error writing stylesheet {css_path}: {e}")
# --- START: NEW IMAGE GENERATION CODE ---
def wrap_text(text, char_width, max_lines=2):
"""
Wraps text to a specified character width.
Returns a list of lines, truncating with "..." if over max_lines.
"""
# Use Python's built-in textwrap for robust wrapping
lines = textwrap.wrap(
text,
width=char_width,
break_long_words=True,
replace_whitespace=True
)
if not lines:
return [""]
if len(lines) > max_lines:
# If wrapped text exceeds max lines, truncate the last line
lines = lines[:max_lines]
lines[-1] = lines[-1][: char_width - 3] + "..."
return [html.escape(line) for line in lines]
def generate_job_thumbnail_svg(job_data, base_salary_schema):
"""
Generates a professional, clear, and colorful 1200x630 SVG thumbnail.
This new version specifically addresses text-overflow issues by:
1. Adding the company name as a "pre-title".
2. Intelligently wrapping the main job title onto multiple lines.
3. Adjusting font sizes and positions for a clean, professional layout.
4. Using the theme colors from the global CONFIG.
5. Adding accessibility tags (, <desc>).
"""
# --- 1. Get Data & Define Colors ---
# Use html.escape for all user-facing data
company = html.escape(job_data.get('company_name', 'Company'))
title = job_data.get('title', 'Job Title') # Escaping handled by wrap_text
location = html.escape(job_data.get('location_str', 'Remote'))
job_type = html.escape(job_data.get('employment_type', 'Full Time'))
# Use the existing helper to format salary text
salary_text = html.escape(format_salary_display(base_salary_schema, CONFIG))
# Calculate salary percentage for the bar
# We don't have min/max in this scope, so we'll use a default
salary_perc = 70 # Default to a visually appealing 70%
# Pull colors from global config
colors = CONFIG.get("THEME_COLORS", {})
C_CARD_BG = colors.get("card_bg", "#ffffff")
C_PRIMARY = colors.get("primary_text", "#111827")
C_SECONDARY = colors.get("secondary_text", "#4B5563")
C_LOGO_BG = colors.get("logo_bg", "#34D399")
C_LOGO_TEXT = colors.get("logo_text", "#ffffff")
C_BAR_BG = colors.get("bar_bg", "#E5E7EB")
C_BAR_FILL = colors.get("bar_fill", "#4F46E5") # Using accent for the dot
# --- 2. Define SVG Structure & Styles (Targeting 1200x630) ---
svg_width = 1200
svg_height = 630
font_family = "Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif"
# Accessibility: Create descriptive title and description
svg_title_text = f"{title} - {company} Job Opening in {location}"
# REVERTED Description Text
svg_desc_text = (
f"OmniCareers job post for a {job_type} {title} position at {company} in {location}. "
f"The salary is {salary_text}. Find this and other Walmart Warehouse, Driving, Logistic & more jobs on OmniCareers."
)
# Adjusted layout for 1200x630
svg_content = f'''<svg width="{svg_width}" height="{svg_height}" viewBox="0 0 {svg_width} {svg_height}" fill="none" xmlns="http://www.w3.org/2000/svg"
aria-labelledby="svg-title svg-desc">
<title id="svg-title">{html.escape(svg_title_text)}{html.escape(svg_desc_text)}{html.escape(CONFIG.get("STATIC_SITE_HEADER_TITLE", "OmniCareers"))}{company} is hiring a
'''
# --- 3. Text Wrapping Logic ---
# Wrap title text to ~35 characters for the larger font
title_lines = wrap_text(title, 35, max_lines=2)
y_offset = 0
line_height = 76 # 64px font + 12px leading
for i, line in enumerate(title_lines):
svg_content += f'{line}\n'
y_offset += line_height
svg_content += '\n' # End of title group
# --- 4. Bottom Row (Location, Type, Salary) ---
# --- Location ---
svg_content += 'LOCATION\n'
svg_content += f'{location}\n'
# --- Job Type ---
svg_content += 'JOB TYPE\n'
svg_content += f'{job_type}\n'
# --- Salary Range ---
svg_content += 'SALARY RANGE\n'
svg_content += f'{salary_text}\n'
# --- Salary Bar ---
svg_content += f'\n'
# Position the dot
bar_dot_x = 820 + (300 * (salary_perc / 100))
# Clamp dot position to be within the bar
bar_dot_x = max(825, min(bar_dot_x, 1115))
svg_content += f'\n'
svg_content += '' # Close SVG tag
# --- 5. Return SVG string ---
return svg_content.strip()
# --- END: NEW IMAGE GENERATION CODE ---
def generate_single_job_page(task_args):
"""
The main function for building a single job page.
This is designed to be run in parallel by a ProcessPoolExecutor.
"""
current_job_meta, config, job_postings_output_dir, html_template, smooth_scroll_js, ad_content_1, ad_content_2 = task_args
try:
# --- 1. Load and Process Data ---
job_schema_input = jloads(current_job_meta['raw_json'])
job_posting_schema = update_job_schema(job_schema_input, current_job_meta['slug'], current_job_meta['url'], config)
job_title = current_job_meta['title']
hiring_org_name = current_job_meta['company_name']
# Create meta description from the first 150 chars of the description
snippet = ' '.join(BeautifulSoup(get_field(job_posting_schema, 'description', default_val=''), BS4_PARSER).get_text(separator=' ').split())[:150]
meta_description = f"Apply for the {job_title} position at {hiring_org_name}. {snippet}..."
keywords = build_meta_keywords(job_title, hiring_org_name)
# --- 2. Generate Thumbnail Image ---
thumbnail_dir = os.path.join(os.path.dirname(job_postings_output_dir), "thumbnails")
os.makedirs(thumbnail_dir, exist_ok=True)
thumbnail_path = os.path.join(thumbnail_dir, f"{current_job_meta['slug']}.svg")
base_salary_schema = get_field(job_posting_schema, 'baseSalary')
thumbnail_data = {
'title': job_title,
'company_name': hiring_org_name,
'location_str': current_job_meta['location_str'],
'employment_type': current_job_meta['employment_type']
}
# --- [MODIFICATION] Check if thumbnail already exists before generating ---
# If the file already exists, skip generating it to save time
if not os.path.exists(thumbnail_path):
# --- THIS IS THE KEY CHANGE: CALLING THE NEW FUNCTION ---
svg_content = generate_job_thumbnail_svg(thumbnail_data, base_salary_schema)
with open(thumbnail_path, 'w', encoding='utf-8') as f:
f.write(svg_content)
# --- End modification ---
# [IMPROVED] Use absolute URLs for social/SEO, relative for on-page
og_image_url_abs = f"{config['SITE_BASE_URL']}/thumbnails/{current_job_meta['slug']}.svg"
page_image_url = f"../thumbnails/{current_job_meta['slug']}.svg"
# --- 3. Generate Schema.org JSON-LD ---
breadcrumb_schema = {
"@context": "https://schema.org/", "@type": "BreadcrumbList",
"itemListElement": [
{"@type": "ListItem", "position": 1, "name": config['STATIC_SITE_HEADER_TITLE'], "item": f"{config['SITE_BASE_URL']}/"},
{"@type": "ListItem", "position": 2, "name": config['JOBS_LISTING_BREADCRUMB_NAME'], "item": f"{config['SITE_BASE_URL']}/{config['JOBS_LISTING_PAGE_SLUG']}/"},
{"@type": "ListItem", "position": 3, "name": job_title, "item": current_job_meta['url']}
]
}
organization_schema = {
"@context": "https://schema.org", "@type": "Organization",
"name": config['STATIC_SITE_HEADER_TITLE'], "url": f"{config['SITE_BASE_URL']}/",
"logo": config['SITE_LOGO_URL'], "sameAs": config.get('SOCIAL_LINKS', []),
"contactPoint": {
"@type": "ContactPoint",
"contactType": "customer support",
"email": config['APPLY_EMAIL']
}
}
article_schema = {
"@context": "https://schema.org", "@type": "Article",
"url": current_job_meta['url'], # [FIX] Added "url"
"mainEntityOfPage": {"@type": "WebPage", "@id": current_job_meta['url']},
"headline": job_title,
"image": og_image_url_abs,
"datePublished": job_posting_schema.get('datePosted'),
"dateModified": job_posting_schema.get('datePosted'),
"author": {"@type": "Organization", "name": config['SITE_AUTHOR']},
"publisher": {"@type": "Organization", "name": config['STATIC_SITE_HEADER_TITLE'], "logo": {"@type": "ImageObject", "url": config['SITE_LOGO_URL']}}
}
def create_schema_script(schema_data):
"""Wraps JSON-LD in a '
# --- 4. Generate HTML Components ---
breadcrumb_html = ''
job_body_html, toc_html = process_job_body_and_create_toc(get_field(job_posting_schema, 'description'))
# --- 5. Assemble and Render Template ---
# --- NEW: Create dynamic, keyword-rich alt text ---
salary_for_alt = format_salary_display(get_field(job_posting_schema, 'baseSalary'), CONFIG)
# REVERTED Alt Text
image_alt_text = (
f"OmniCareers Job Posting: {job_title} at {hiring_org_name}. "
f"This is a {current_job_meta['employment_type']} role in {current_job_meta['location_str']}. "
f"Salary: {salary_for_alt}."
)
render_data = {
"seo_title": f"{job_title} | {hiring_org_name}",
"meta_description": meta_description, "meta_keywords": keywords,
"site_author": config['SITE_AUTHOR'], "job_url": current_job_meta['url'],
"date_posted_iso": job_posting_schema.get('datePosted'),
"site_name": config['STATIC_SITE_HEADER_TITLE'],
"og_image_url_abs": og_image_url_abs,
"page_image_url": page_image_url,
"image_alt_text": html.escape(image_alt_text), # <-- ADDED
"job_title": job_title,
"hiring_org_name": hiring_org_name, # Pass for alt text
"site_base_url": config['SITE_BASE_URL'],
"job_posting_schema_script": create_schema_script(job_posting_schema),
"breadcrumb_schema_script": create_schema_script(breadcrumb_schema),
"organization_schema_script": create_schema_script(organization_schema),
"article_schema_script": create_schema_script(article_schema),
"breadcrumb_html": breadcrumb_html,
"date_posted_display": format_display_date(job_posting_schema.get('datePosted')),
"location": current_job_meta['location_str'],
"employment_type_display": current_job_meta['employment_type'],
"salary_display": format_salary_display(get_field(job_posting_schema, 'baseSalary'), CONFIG),
"table_of_contents": toc_html, "job_body_html": job_body_html,
"similar_jobs": current_job_meta.get('similar_jobs', []),
"jobs_listing_url": f"/{config['JOBS_LISTING_PAGE_SLUG'].strip('/')}/",
"css_path": "../style.css", # Relative path from /jobs/slug.html
"smooth_scroll_script": smooth_scroll_js if toc_html else "",
# [AD REVERT] Pass raw ad content directly
"ad_section_1": ad_content_1,
"ad_section_2": ad_content_2,
# [AD RESIZE REMOVED] Removed ad_resize_script from render data
"critical_css": CRITICAL_CSS,
"footer_links_html": get_footer_links_html(config), # <-- ADDED
}
final_html = render_html_template(html_template, render_data)
# [PERF] Minify HTML before writing
final_html = minify_html(final_html)
# --- 6. Write File ---
output_path = os.path.join(job_postings_output_dir, f"{current_job_meta['slug']}.html")
with open(output_path, 'w', encoding='utf-8') as f:
f.write(final_html)
return True # Signal success
except Exception as e:
# Log error instead of crashing the whole build
sys.stderr.write(f"Failed to generate page for '{current_job_meta.get('title', 'N/A')}'. Error: {e}\n")
return False # Signal failure
def _website_schema(config):
"""Generates the Website schema for the homepage."""
return {
"@context": "https://schema.org",
"@type": "WebSite",
"url": config['SITE_BASE_URL'] + "/",
"name": config['STATIC_SITE_HEADER_TITLE'],
"potentialAction": {
"@type": "SearchAction",
"target": f"{config['SITE_BASE_URL']}/{config['JOBS_LISTING_PAGE_SLUG']}/?q={{search_term_string}}",
"query-input": "required name=search_term_string"
}
}
def generate_main_homepage(config, latest_jobs):
"""Generates the main index.html for the site root."""
logging.info("Generating main homepage (index.html)...")
site_root_dir = os.path.dirname(config['OUTPUT_DIR'].rstrip('/\\')) or '.'
homepage_path = os.path.join(site_root_dir, "index.html")
latest_jobs_html = ""
if latest_jobs:
for job in latest_jobs:
# URL is relative to the root
job_url = f"{config['JOBS_LISTING_PAGE_SLUG']}/{job['slug']}.html"
latest_jobs_html += f"""