Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions batch_template.csv
Original file line number Diff line number Diff line change
@@ -0,0 +1,2 @@
prompt,mode,map_type,gsm,extra_option,model,font,palette_theme,output
"Population density by country in Europe",number,default,15,none,gemini-3.8-flash,Bips.ttf,auto,europe_population.png
116 changes: 116 additions & 0 deletions cli.py
Original file line number Diff line number Diff line change
Expand Up @@ -141,6 +141,122 @@ def make(prompt, mode, map_type, size_mod, optional_feature, model, font_name, s
raise click.ClickException("Map generation failed. See errors above.")


@main.command()
@click.argument("ideas_file", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("-o", "--output-dir",
"output_dir",
type=click.Path(file_okay=False, path_type=Path),
default=Path("output_maps"),
show_default=True,
help="Directory where generated PNG maps will be saved.")
@click.option("-m", "--mode",
type=click.Choice(["text", "number"], case_sensitive=False),
default="text",
show_default=True,
help="Default data mode: text (default) or number.")
@click.option("-mp", "--map-type",
"map_type",
type=click.Choice(["default", "flag", "world"], case_sensitive=False),
default="default",
show_default=True,
help="Default map type: default, flag or world.")
@click.option("-gsm", "--global-size-modifier",
"size_mod",
type=int,
default=15,
show_default=True,
help="Default global font size modifier (default 15).")
@click.option("-eop", "--extra-option",
"optional_feature",
type=click.Choice(["none", "show_most_least", "short_form"], case_sensitive=False),
default="none",
show_default=True,
help="Default extra option: none, show_most_least or short_form.")
@click.option("--model",
type=click.Choice(AVAILABLE_MODELS, case_sensitive=False),
default=AVAILABLE_MODELS[0],
show_default=True,
help="Default AI model to use.")
@click.option("--font",
"font_name",
type=click.Choice(_available_fonts(), case_sensitive=True),
default="Bips.ttf",
show_default=True,
help="Default font file name from resources/fonts.")
@click.option("-v", "--verbose",
is_flag=True,
default=False,
help="Print detailed progress output.")
@click.option("--key",
"api_key",
default=None,
help="Gemini API key for this run (overrides GEMINI_API_KEY env var).")
def batch(ideas_file, output_dir, mode, map_type, size_mod, optional_feature, model, font_name, verbose, api_key):
"""Generate multiple maps from ideas listed in a .csv IDEAS_FILE."""
from map import log
from map.auto_map import auto_map
from map.functions import load_ideas_from_file, slugify_prompt

log.set_verbose(verbose)
if api_key:
os.environ["GEMINI_API_KEY"] = api_key

try:
ideas = load_ideas_from_file(ideas_file)
except ValueError as err:
raise click.ClickException(str(err)) from err

if not ideas:
raise click.ClickException(f"No valid map ideas found in {ideas_file}.")

output_dir.mkdir(parents=True, exist_ok=True)
available_fonts = set(_available_fonts())
succeeded = 0

for idx, idea in enumerate(ideas, start=1):
prompt = str(idea["prompt"])
item_mode = str(idea.get("mode") or mode).lower()
item_map_type = str(idea.get("map_type") or map_type).lower()
item_size_mod = int(idea.get("gsm", size_mod))
raw_eop = str(idea.get("extra_option") or optional_feature).lower()
item_feature = None if raw_eop == "none" else raw_eop
item_model = str(idea.get("model") or model)
item_font = str(idea.get("font") or font_name)
if item_font not in available_fonts:
item_font = font_name

log.step(f"[{idx}/{len(ideas)}] Generating map: {prompt}")
buffer = auto_map(
prompt=prompt,
mode=item_mode,
map_type=item_map_type,
size_mod=item_size_mod,
optional_feature=item_feature,
model=item_model,
font_name=item_font,
show_result=False,
io_res=True,
api_key=api_key,
)
if buffer is None:
log.warning(f"[{idx}/{len(ideas)}] Failed to generate map for: {prompt}")
continue

custom_out = str(idea.get("output") or "").strip()
filename = Path(custom_out).name if custom_out else f"{idx:02d}_{slugify_prompt(prompt)}.png"
if not filename.lower().endswith(".png"):
filename += ".png"
target = output_dir / filename
target.write_bytes(buffer.getvalue())
succeeded += 1
log.success(f"Saved {target}")

if succeeded == 0:
raise click.ClickException("All batch map generations failed.")

log.finished(f"Generated {succeeded}/{len(ideas)} maps in {output_dir}")


if __name__ == "__main__":
main()

201 changes: 199 additions & 2 deletions main.py
Original file line number Diff line number Diff line change
Expand Up @@ -54,7 +54,7 @@
_to_rgba_tuple,
)
from map.constants import europe_coords, world_coords
from map.functions import validate_temperature
from map.functions import parse_ideas_content, slugify_prompt, validate_temperature

from flask import Flask, request, jsonify, send_file, render_template, Response

Expand Down Expand Up @@ -82,6 +82,7 @@ def _available_fonts():


app = Flask(__name__)
app.config["MAX_CONTENT_LENGTH"] = 32 * 1024 * 1024

@app.route('/')
def main():
Expand Down Expand Up @@ -494,6 +495,202 @@ def generate():
return jsonify(resp_payload)


@app.route('/api/models', methods=['POST'])
def list_available_models():
"""Return Gemini/Gemma models available for the active API key."""
data = request.get_json(silent=True) or {}
req_key = str(data.get("api_key") or "").strip()
env_key = (os.getenv("GEMINI_API_KEY") or "").strip()
key = req_key or env_key
if not key:
return jsonify({"status": "error", "error": "API key required.", "models": []}), 400
try:
from google import genai
client = genai.Client(api_key=key)
models: list[str] = []
for m in client.models.list():
name = getattr(m, "name", "") or ""
if name.startswith("models/"):
name = name[len("models/"):]
actions = getattr(m, "supported_actions", None) or []
if actions and "generateContent" not in actions:
continue
low = name.lower()
if not (low.startswith("gemini") or low.startswith("gemma")):
continue
if any(skip in low for skip in ("embedding", "imagen", "veo", "tts", "aqa", "robotics", "computer-use")):
continue
models.append(name)
return jsonify({"status": "success", "models": sorted(set(models), reverse=True)})
except Exception as err: # noqa: BLE001
return jsonify({"status": "error", "error": str(err), "models": []}), 500


@app.route('/api/batch-template', methods=['GET'])
def download_batch_template():
"""Serve the downloadable batch CSV template."""
template_path = Path(__file__).resolve().parent / "batch_template.csv"
if not template_path.is_file():
return jsonify({"status": "error", "error": "batch_template.csv not found."}), 404
return send_file(
template_path,
mimetype="text/csv",
as_attachment=True,
download_name="batch_template.csv",
)


@app.route('/api/generate_batch/', methods=['POST'])
@app.route('/api/generate_batch', methods=['POST'])
def generate_batch():
"""Generate multiple maps from an uploaded .csv ideas file."""
if request.files and "file" in request.files:
uploaded = request.files["file"]
filename = uploaded.filename or ""
ideas_text = uploaded.read().decode("utf-8", errors="replace")
data: dict[str, object] = dict(request.form)
else:
data = request.get_json(silent=True) or {}
filename = str(data.get("filename") or "")
ideas_text = str(data.get("ideas_text") or "")

api_key = str(data.get("api_key") or "").strip() or None
if needs_api_key and not api_key:
return jsonify({
"status": "error",
"error": "API key required. Provide GEMINI_API_KEY via .env or the web form.",
}), 400

try:
ideas = parse_ideas_content(ideas_text, filename=filename)
except ValueError as err:
return jsonify({"status": "error", "error": str(err)}), 400

if not ideas:
return jsonify({"status": "error", "error": "No valid map ideas found in the uploaded file."}), 400

default_font, default_eop, default_gsm = _parse_render_params(data)
default_mode = str(data.get("mode") or "text").lower()
default_map_type = str(data.get("map_type") or "default").lower()
default_model = str(data.get("model") or "gemini-2.5-flash")
available_fonts = set(_available_fonts())

temperature_options: dict[str, object] = {}
if "temperature" in data and str(data["temperature"]).strip() != "":
try:
temperature_options["temperature"] = validate_temperature(data["temperature"])
except ValueError as err:
return jsonify({"status": "error", "error": str(err)}), 400

base_style_kwargs: dict[str, object] = {}
for style_key, kw_name in (
("filling_txt", "filling_txt_override"),
("filling_num", "filling_num_override"),
("label_style", "label_style"),
("auto_style", "auto_style"),
("palette_theme", "palette_theme"),
):
if style_key in data:
base_style_kwargs[kw_name] = data[style_key]

results: list[dict[str, object]] = []
succeeded = 0

for idx, idea in enumerate(ideas, start=1):
prompt = str(idea["prompt"])
item_mode = str(idea.get("mode") or default_mode).lower()
item_map_type = str(idea.get("map_type") or default_map_type).lower()
item_gsm = int(idea.get("gsm", default_gsm))
raw_eop = str(idea.get("extra_option") or default_eop or "none").lower()
item_eop = None if raw_eop in ("none", "") else raw_eop
item_model = str(idea.get("model") or default_model)
item_font = str(idea.get("font") or default_font)
if item_font not in available_fonts:

Copy link
Copy Markdown
Owner

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

[P1] Add batch_template.csv file. CSV File example with 1 example. And it must be able to be downloaded from web

item_font = default_font

item_style_kwargs = dict(base_style_kwargs)
if "palette_theme" in idea:
item_style_kwargs["palette_theme"] = idea["palette_theme"]

custom_out = str(idea.get("output") or "").strip()
out_filename = Path(custom_out).name if custom_out else f"{idx:02d}_{slugify_prompt(prompt)}.png"
if not out_filename.lower().endswith(".png"):
out_filename += ".png"

try:
buffer = auto_map(
prompt=prompt,
mode=item_mode,
map_type=item_map_type,
size_mod=item_gsm,
optional_feature=item_eop,
model=item_model,
font_name=item_font,
show_result=False,
io_res=True,
api_key=api_key,
**temperature_options,
**item_style_kwargs,
)
except Exception as err: # noqa: BLE001
results.append({
"index": idx,
"prompt": prompt,
"filename": out_filename,
"status": "error",
"error": str(err),
})
continue

if buffer is None:
results.append({
"index": idx,
"prompt": prompt,
"filename": out_filename,
"status": "error",
"error": "Map generation failed.",
})
continue

encoded = base64.b64encode(buffer.getvalue()).decode("ascii")
item_payload: dict[str, object] = {
"index": idx,
"prompt": prompt,
"filename": out_filename,
"status": "success",
"image_url": f"data:image/png;base64,{encoded}",
"mode": item_mode,
"map_type": item_map_type,
"gsm": item_gsm,
"extra_option": item_eop or "none",
"model": item_model,
"font": item_font,
"palette_theme": item_style_kwargs.get("palette_theme", "auto"),
}
if temperature_options:
item_payload["temperature"] = temperature_options["temperature"]
render_meta = getattr(buffer, "map_meta", None)
ai_vals = render_meta.get("ai_answer") if isinstance(render_meta, dict) else None
if isinstance(ai_vals, dict) and ai_vals:
item_payload["map_values"] = ai_vals
item_payload["analysis"] = _build_analysis_from_ai(
ai_vals,
mode=item_mode,
palette_theme=str(item_style_kwargs.get("palette_theme") or "auto"),
topic=prompt,
render_meta=render_meta,
)
results.append(item_payload)
succeeded += 1

return jsonify({
"status": "success" if succeeded > 0 else "error",
"total": len(ideas),
"succeeded": succeeded,
"results": results,
}), (200 if succeeded > 0 else 500)


@app.route('/api/restyle_map/', methods=['POST'])
@app.route('/api/restyle_map', methods=['POST'])
def api_restyle_map():
Expand Down Expand Up @@ -864,4 +1061,4 @@ def _generate():

if __name__ == "__main__":

app.run(host='0.0.0.0',debug=True)
app.run(host='0.0.0.0', debug=True)
Loading
Loading