import os import re import subprocess import tempfile import zipfile import urllib from bs4 import BeautifulSoup from pathlib import Path from django.core.exceptions import MultipleObjectsReturned, ObjectDoesNotExist from django.http import HttpResponse, HttpResponseNotFound, HttpResponseRedirect, FileResponse from django.shortcuts import render, redirect from django.urls import NoReverseMatch, reverse import troggle.settings as settings from troggle.core.forms import CaveAndEntranceFormSet, CaveForm, EntranceForm, EntranceLetterForm from troggle.core.models.caves import Cave, CaveAndEntrance, Entrance, GetCaveLookup from troggle.core.models.logbooks import CaveSlug, QM from troggle.core.utils import write_and_commit from troggle.core.views import expo from troggle.settings import CAVEDESCRIPTIONS, ENTRANCEDESCRIPTIONS from troggle.parsers.caves import read_cave, read_entrance from django.template import loader from django.utils.safestring import mark_safe from .auth import login_required_if_public """Manages the complex procedures to assemble a cave description out of the compnoents Manages the use of cavern to parse survex files to produce 3d and pos files """ todo = """ - in getCaves() search GCavelookup first, which should raise a MultpleObjectsReturned exception if no duplicates - Learn to use Django .select_related() and .prefetch_related() to speed things up especially on the big report pages https://zerotobyte.com/how-to-use-django-select-related-and-prefetch-related/ """ def getCaves(cave_id): """Only gets called if a call to getCave() raises a MultipleObjects exception TO DO: search GCavelookup first, which should raise a MultpleObjectsReturned exception if there are duplicates""" try: caves = Cave.objects.filter(kataster_number=cave_id) caveset = set(caves) Gcavelookup = GetCaveLookup() # dictionary makes strings to Cave objects if cave_id in Gcavelookup: caveset.add(Gcavelookup[cave_id]) return list(caveset) except: return [] def getCave(cave_id): """Returns a cave object when given a cave name or number. It is used by views including cavehref, ent, and qm. TO DO: search GCavelookup first, which should raise a MultpleObjectsReturned exception if there are duplicates""" try: cave = Cave.objects.get(kataster_number=cave_id) return cave except Cave.MultipleObjectsReturned as ex: raise MultipleObjectsReturned("Duplicate kataster number") from ex # propagate this up except Cave.DoesNotExist as ex: Gcavelookup = GetCaveLookup() # dictionary makes strings to Cave objects if cave_id in Gcavelookup: return Gcavelookup[cave_id] else: raise ObjectDoesNotExist("No cave found with this identifier in any id field") from ex # propagate this up except: raise ObjectDoesNotExist("No cave found with this identifier in any id field") def pad5(x): return "0" * (5 - len(x.group(0))) + x.group(0) def padnumber(x): return re.sub("\d+", pad5, x) def numericalcmp(x, y): return cmp(padnumber(x), padnumber(y)) def caveKey(c): """This function goes into a lexicogrpahic sort function, and the values are strings, but we want to sort numberically on kataster number before sorting on unofficial number. """ if not c.kataster_number: return "9999." + c.unofficial_number else: if int(c.kataster_number) >= 100: return "99." + c.kataster_number if int(c.kataster_number) >= 10: return "9." + c.kataster_number return c.kataster_number def getnotablecaves(): notablecaves = [] for kataster_number in settings.NOTABLECAVESHREFS: try: cave = Cave.objects.get(kataster_number=kataster_number, areacode="1623") notablecaves.append(cave) except: print(" ! Notable Caves: FAILED to get only one cave per kataster_number OR invalid number for: "+kataster_number) try: hc = Cave.objects.get(kataster_number=359, areacode="1626") notablecaves.append(hc) except: # fails during the tests because this cave has not been loaded for tests, so catch it here. pass print(notablecaves) return notablecaves def caveindex(request): caves1623 = list(Cave.objects.filter(areacode="1623")) caves1626 = list(Cave.objects.filter(areacode="1626")) caves1627 = list(Cave.objects.filter(areacode="1627")) caves1623.sort(key=caveKey) caves1626.sort(key=caveKey) caves1627.sort(key=caveKey) return render( request, "caveindex.html", {"caves1623": caves1623, "caves1626": caves1626, "caves1627": caves1627, "notablecaves": getnotablecaves(), "cavepage": True}, ) def entranceindex(request): ents = Entrance.objects.all().order_by("slug") return render( request, "entranceindex.html", {"entrances": ents}, ) def cave3d(request, cave_id=""): """This is used to create a download url in templates/cave.html if anyone wants to download the .3d file The caller template tries kataster first, then unofficial_number if that kataster number does not exist but only if Cave.survex_file is non-empty """ try: cave = getCave(cave_id) except ObjectDoesNotExist: return HttpResponseNotFound except Cave.MultipleObjectsReturned: # should really produce a better error message. This is a failure of ambiguous aliases probably. caves = Cave.objects.filter(url=kpath) return render(request, "svxcaveseveral.html", {"settings": settings, "caves": caves}) else: return file3d(request, cave, cave_id) def file3d(request, cave, cave_id): """Produces a .3d file directly for download. survex_file should be in valid path format 'caves-1623/264/264.svx' but it might be mis-entered as simply '2012-ns-10.svx' Also the cave.survex_file may well not match the cave description path: e.g. it might be to the whole system 'smk-system.svx' instead of just for the specific cave. - If the expected .3d file corresponding to cave.survex_file is present, return it. - If the cave.survex_file exists, generate the 3d file, cache it and return it - Use the cave_id to guess what the 3d file might be and, if in the cache, return it - Use the cave_id to guess what the .svx file might be and generate the .3d file and return it - (Use the incomplete cave.survex_file and a guess at the missing directories to guess the real .svx file location ?) """ def runcavern(survexpath): """This has not yet been properly updated with respect to putting the .3d file in the same folder as the .svx filse as done in runcavern3d() in parsers/survex.py Needs testing. """ # print(" - Regenerating cavern .log and .3d for '{}'".format(survexpath)) if not survexpath.is_file(): # print(" - - Regeneration ABORT\n - - from '{}'".format(survexpath)) pass try: completed_process = subprocess.run( [settings.CAVERN, "--log", f"--output={settings.SURVEX_DATA}", f"{survexpath}"] ) except OSError as ex: # propagate this to caller. raise OSError(completed_process.stdout) from ex op3d = (Path(settings.SURVEX_DATA) / Path(survexpath).name).with_suffix(".3d") op3dlog = Path(op3d.with_suffix(".log")) if not op3d.is_file(): print(f" - - Regeneration FAILED\n - - from '{survexpath}'\n - - to '{op3d}'") print(" - - Regeneration stdout: ", completed_process.stdout) print(" - - Regeneration cavern log output: ", op3dlog.read_text()) def return3d(threedpath): if threedpath.is_file(): response = HttpResponse(content=open(threedpath, "rb"), content_type="application/3d") response["Content-Disposition"] = f"attachment; filename={threedpath.name}" return response else: message = f'

Path provided does not correspond to any actual 3d file.

path: "{threedpath}"' # print(message) return HttpResponseNotFound(message) survexname = Path(cave.survex_file).name # removes directories survexpath = Path(settings.SURVEX_DATA, cave.survex_file) threedname = Path(survexname).with_suffix(".3d") # removes .svx, replaces with .3d threedpath = Path(settings.SURVEX_DATA, threedname) # These if statements need refactoring more cleanly if cave.survex_file: # print(" - cave.survex_file '{}'".format(cave.survex_file)) if threedpath.is_file(): # print(" - threedpath '{}'".format(threedpath)) # possible error here as several .svx files of same names in different directories will overwrite in /3d/ if survexpath.is_file(): if os.path.getmtime(survexpath) > os.path.getmtime(threedpath): runcavern(survexpath) return return3d(threedpath) else: # print(" - - survexpath '{}'".format(survexpath)) if survexpath.is_file(): # print(" - - - survexpath '{}'".format(survexpath)) runcavern(survexpath) return return3d(threedpath) # Get here if cave.survex_file was set but did not correspond to a valid svx file if survexpath.is_file(): # a file, but invalid format message = f'

File is not valid .svx format.

Could not generate 3d file from "{survexpath}"' else: # we could try to guess that 'caves-1623/' is missing,... nah. message = f'

Path provided does not correspond to any actual file.

path: "{survexpath}"' return HttpResponseNotFound(message) def rendercave(request, cave, slug, cave_id=""): """Gets the data and files ready and then triggers Django to render the template. The resulting html contains urls which are dispatched independently, e.g. the 'download' link """ # print(" ! rendercave:'{}' START slug:'{}' cave_id:'{}'".format(cave, slug, cave_id)) if cave.non_public and settings.PUBLIC_SITE and not request.user.is_authenticated: return render(request, "nonpublic.html", {"instance": cave, "cavepage": True, "cave_id": cave_id}) else: # print(f" ! rendercave: slug:'{slug}' survex file:'{cave.survex_file}'") try: svx3d = Path(cave.survex_file).stem svxstem = Path(settings.SURVEX_DATA) / Path(cave.survex_file) # print(f" ! rendercave: slug:'{slug}' '' ++ '{svxstem}'") except: svx3d = "" svxstem = "" print(f" ! rendercave: slug:'{slug}' FAIL TO MANAGE survex file:'{cave.survex_file}'") # NOTE the template itself loads the 3d file using javascript before it loads anything else. # Django cannot see what this javascript is doing, so we need to ensure that the 3d file exists first. # So only do this render if a valid .3d file exists. TO BE DONE -Not yet as CaveView is currently disabled # see design docum in troggle/templates/cave.html # see rendercave() in troggle/core/views/caves.py templatefile = "cave.html" if not cave_id: cave_id = slug # cave.unofficial_number context = { "cave_editable": True, "settings": settings, "cave": cave, "cavepage": True, "cave_id": cave_id, "svxstem": str(svxstem), "svx3d": svx3d, } # Do not catch any exceptions here: propagate up to caller r = render( request, templatefile, context ) # crashes here with NoReverseMatch if url not set up for 'edit_cave' in urls.py return r def cavepagefwd(request, karea=None, subpath=None): """archaic, just send to the caves list page """ return redirect("/caves") def caveslugfwd(request, slug): """This is ass backwards. It would be better style to have the slug-identified request be the master, and have other paths redirect to it, rather than what we have here. Pending a change where we remove cave.url as a field and have an explicit fixed convention instead. """ if slug: Gcavelookup = GetCaveLookup() if slug in Gcavelookup: cave = Gcavelookup[slug] else: message = f"Failed to find cave from identifier given: {slug}." return render(request, "errors/generic.html", {"message": message}) return redirect(f"/{cave.url}") def cavepage(request, karea=None, subpath=None): """Displays a cave description page accessed by kataster area number specifically OR accessed by cave.url specifically set in data, e.g. "1623/000/000" <= cave-data/1623-000.html "1623/41/115.htm" <= cave-data/1623-115.html so we have to query the database to find the URL as we cannot rely on the url actually telling us the cave by inspection. NOTE that old caves have ".html" (or ".htm") in the URL as they used to be actual files. But since 2006 these URLs refer to virtual pages generated on the fly by troggle, so the".html" is confusing and redundant. There are also A LOT OF URLS to e.g. /1623/161/l/rl89a.htm which are IMAGES and real html files in cave descriptions. These need to be handled HERE too (accident of history). """ # lack of validation for karea, it could be any 4 digits. # subpath has an initial / kpath = karea + subpath # print(f" ! cavepage:'{kpath}' kataster area:'{karea}' rest of path:'{subpath}'") try: cave = Cave.objects.get(url=kpath) # ideally this will be unique except Cave.DoesNotExist: # probably a link to text or an image e.g. 1623/161/l/rl89a.htm i.e. an expoweb page # cannot assume that this is a simple cave page, for a cave we don't know. # print(f" ! cavepage: url={kpath} A cave of this name does not exist") return expo.expopage(request, kpath) except Cave.MultipleObjectsReturned: caves = Cave.objects.filter(url=kpath) # print(f" ! cavepage: url={kpath} multiple caves exist") # we should have a -several variant for the cave pages, not just the svxcaves: return render(request, "svxcaveseveral.html", {"settings": settings, "caves": caves}) try: r = rendercave(request, cave, cave.slug()) return r except NoReverseMatch: if settings.DEBUG: raise else: message = f"Failed to render cave: {kpath} (it does exist and is unique) because of a Django URL resolution error. Check urls.py." return render(request, "errors/generic.html", {"message": message}) except: # anything else is a new problem. Add in specific error messages here as we discover new types of error raise @login_required_if_public def edit_cave(request, path="", slug=None): """This is the form that edits all the cave data and writes out an XML file in the :expoweb: repo folder The format for the file being saved is in templates/dataformat/cave.xml Warning. This uses Django deep magic in the CaveForm processing. It saves the data into into the database and into the html file, which it then commits to git. """ message = "" if slug is not None: try: cave = Cave.objects.get(caveslug__slug=slug) except: return render(request, "errors/badslug.html", {"badslug": f"{slug} - from edit_cave()"}) else: cave = Cave() if request.POST: form = CaveForm(request.POST, instance=cave) #ceFormSet = CaveAndEntranceFormSet(request.POST) if form.is_valid(): # and ceFormSet.is_valid(): # print(f'! POST is valid. {cave}') cave = form.save(commit=False) if not cave.filename: cave.filename = cave.areacode + "-" + cave.number() + ".html" if not cave.url: cave.url = cave.areacode + "/" + cave.number() cave.save() form.save_m2m() if slug is None: # it is not visible on the form so it always will be None slug = f"{cave.areacode}-{cave.number()}" cs = CaveSlug(cave=cave, slug=slug, primary=True) cs.save() #ceinsts = ceFormSet.save(commit=False) #for ceinst in ceinsts: # ceinst.cave = cave # ceinst.save() try: cave_file = cave.file_output() write_and_commit([cave_file], f"Online edit of cave {cave}") # leave other exceptions unhandled so that they bubble up to user interface except PermissionError: message = f"CANNOT save this file.\nPERMISSIONS incorrectly set on server for this file {cave.filename}. Ask a nerd to fix this." return render(request, "errors/generic.html", {"message": message}) except subprocess.SubprocessError: message = f"CANNOT git on server for this file {cave.filename}. Edits may not be committed.\nAsk a nerd to fix this." return render(request, "errors/generic.html", {"message": message}) if cave.entrances().count() > 0: return HttpResponseRedirect("/" + cave.url) else: return HttpResponseRedirect(reverse("newentrance", args = [cave.url_parent(), cave.slug()])) else: if slug is not None: # re-read cave data from file. if cave.filename: read_cave(cave.filename, cave=cave) form = CaveForm(instance=cave, initial={'cave_slug': cave.slug()}) #ceFormSet = CaveAndEntranceFormSet(queryset=cave.caveandentrance_set.all()) else: form = CaveForm() #ceFormSet = CaveAndEntranceFormSet(queryset=CaveAndEntrance.objects.none()) return render( request, "editcave.html", { "form": form, "cave": cave, "message": message, #"caveAndEntranceFormSet": ceFormSet, "path": path + "/", }, ) @login_required_if_public def edit_entrance(request, path="", caveslug=None, entslug=None): """This is the form that edits the entrance data for a single entrance and writes out an XML file in the :expoweb: repo folder The format for the file being saved is in templates/dataformat/entrance.xml Warning. This uses Django deep magic for multiple forms and the CaveAndEntrance class. It does save the data into into the database directly, not by parsing the file. """ try: cave = Cave.objects.get(caveslug__slug=caveslug) except: return render(request, "errors/badslug.html", {"badslug": f"for cave {caveslug} - from edit_entrance()"}) if entslug: try: entrance = Entrance.objects.get(slug=entslug) except: return render(request, "errors/badslug.html", {"badslug": f"for entrance {entslug} - from edit_entrance()"}) else: # a new entrance on a cave entrance = None if entslug: print(f"{caveslug=} {entslug=} {path=} number of ents:{cave.entrances().count()}") caveAndEntrance = CaveAndEntrance.objects.get(entrance=entrance, cave=cave) entlettereditable = False else: caveAndEntrance = CaveAndEntrance(cave=cave, entrance=Entrance()) entlettereditable = True if caveAndEntrance.entranceletter == "" and cave.entrances().count() > 0 : # this should not be blank on a multiple-entrance cave # but it doesn't trigger the entrnce letter form unless entletter has a value entlettereditable = True print(f"{entlettereditable=}") if request.POST: print(f"POST Online edit of entrance: '{entrance}' where {cave=}") form = EntranceForm(request.POST, instance=entrance) entletterform = EntranceLetterForm(request.POST, instance=caveAndEntrance) if form.is_valid() and entletterform.is_valid(): entrance = form.save(commit=False) ce = entletterform.save(commit=False) print(f"- POST {caveslug=} {entslug=} {ce=} {entletterform.cleaned_data['entranceletter']=} {path=}") if entslug is None: if entletterform.cleaned_data["entranceletter"]: slugname = cave.slug() + entletterform.cleaned_data["entranceletter"] print(f"- POST letter {entletterform.cleaned_data['entranceletter']=}") else: slugname = cave.slug() entrance.slug = slugname entrance.cached_primary_slug = slugname entrance.filename = slugname + ".html" else: entrance.slug = entslug entrance.cached_primary_slug = entslug entrance.filename = entslug + ".html" try: entrance.save() except: # fails with uniqueness constraint failure. Which is on CaveAndEntrance, not just on entrance, which is bizarre. print(f"SAVE EXCEPTION FAIL {entrance=}") print(f"CAVE {cave}") for ce in cave.entrances(): print(f"CAVE:{ce.cave} - ENT:{ce.entrance} - LETTER:'{ce.entranceletter}'") raise ce.entrance = entrance ce.save() entrance_file = entrance.file_output() cave_file = cave.file_output() print(f"- POST WRITE letter: '{ce}' {entrance=}") write_and_commit([entrance_file, cave_file], f"Online edit of entrance {entrance.slug}") return HttpResponseRedirect("/" + cave.url) else: # GET the page, not POST, or if either of the forms were invalid when POSTed entletterform = None entletter = "" print(f"ENTRANCE in db: entranceletter = '{caveAndEntrance.entranceletter}'") if entrance: # re-read entrance data from file. filename = str(entrance.slug +".html") ent = read_entrance(filename, ent=entrance) print(f"ENTRANCE from file: entranceletter = '{caveAndEntrance.entranceletter}'") entform = EntranceForm(instance=entrance) if entslug is None: entletterform = EntranceLetterForm() # print(f" Getting entletter from EntranceLetterForm") else: entletter = caveAndEntrance.entranceletter if entletter == "": entletterform = EntranceLetterForm() print(f" Blank value: getting entletter from EntranceLetterForm") print(f"{entletter=} ") else: entform = EntranceForm() entletterform = EntranceLetterForm() return render( request, "editentrance.html", { "entform": entform, "cave": cave, "entletter": entletter, "entletterform": entletterform, # is unset if not being used "entlettereditable": entlettereditable, "path": path + "/", }, ) def ent(request, cave_id, ent_letter): cave = Cave.objects.filter(kataster_number=cave_id)[0] cave_and_ent = CaveAndEntrance.objects.filter(cave=cave).filter(entranceletter=ent_letter)[0] return render( request, "entrance.html", { "cave": cave, "entrance": cave_and_ent.entrance, "letter": cave_and_ent.entranceletter, }, ) def cave_debug(request): ents = Entrance.objects.all().order_by('id') return render( request, "cave_debug.html", {"ents": ents}, ) def get_entrances(request, caveslug): try: cave = Cave.objects.get(caveslug__slug=caveslug) except: return render(request, "errors/badslug.html", {"badslug": f"{caveslug} - from get_entrances()"}) return render( request, "options.html", {"items": [(e.entrance.slug(), e.entrance.slug()) for e in cave.entrances()]} ) def caveQMs(request, slug, open=False): """Lists all the QMs on a particular cave relies on the template to find all the QMs for the cave specified in the slug, e.g. '1623-161' Now working in July 2022 """ try: cave = Cave.objects.get(caveslug__slug=slug) except: return render(request, "errors/badslug.html", {"badslug": f"{slug} - from caveQMs()"}) if cave.non_public and settings.PUBLIC_SITE and not request.user.is_authenticated: return render(request, "nonpublic.html", {"instance": cave}) elif open: return render(request, "cave_open_qms.html", {"cave": cave}) else: return render(request, "cave_qms.html", {"cave": cave}) def qm(request, cave_id, qm_id, year, grade=None, blockname=None): """Reports on one specific QM Fixed and working July 2022, for both CSV imported QMs Needs refactoring though! Uses extremely baroque way of getting the QMs instead of querying for QM objects directly, presumably as a result of a baroque history. Many caves have several QMS with the same number, grade, year (2018) and first 8 chars of the survexblock. This crashes things, so the terminal char of the survexblock name was added """ year = int(year) if blockname == "" or not blockname: # CSV import QMs, use old technique try: c = getCave(cave_id) manyqms = c.get_open_QMs() | c.get_ticked_QMs() # set union operation qm = manyqms.get(number=qm_id, expoyear=year, grade=grade) return render(request, "qm.html", {"qm": qm}) except QM.DoesNotExist: # raise return render( request, "errors/badslug.html", { "badslug": f"QM.DoesNotExist blockname is empty string: {cave_id=} {year=} {qm_id=} {grade=} {blockname=}" }, ) except QM.MultipleObjectsReturned: # raise qms = manyqms.filter(number=qm_id, expoyear=year) return render( request, "errors/badslug.html", { "badslug": f"QM.MultipleObjectsReturned {cave_id=} {year=} {qm_id=} {grade=} {blockname=} {qms=}" }, ) else: try: qmslug = f"{cave_id}-{year}-{blockname=}{qm_id}{grade}" print(f"{qmslug=}") c = getCave(cave_id) manyqms = c.get_open_QMs() | c.get_ticked_QMs() # set union operation qmqs = manyqms.filter(expoyear=year, blockname=blockname, number=qm_id, grade=grade) if len(qmqs) > 1: for q in qmqs: print(qmqs) message = f"Multiple QMs with the same cave, year, number, grade AND first-several+terminal chars of the survexblock name. (Could be caused by incomplete databasereset). Fix this in the survex file(s). {cave_id=} {year=} {qm_id=} {blockname=}" return render(request, "errors/generic.html", {"message": message}) else: qm = qmqs.get(expoyear=year, blockname=blockname, number=qm_id, grade=grade) if qm: print( qm, f"{qmslug=}:{cave_id=} {year=} {qm_id=} {blockname=} {qm.expoyear=} {qm.completion_description=}", ) return render(request, "qm.html", {"qm": qm}) else: # raise return render( request, "errors/badslug.html", {"badslug": f"Failed get {cave_id=} {year=} {qm_id=} {grade=} {blockname=}"}, ) except MultipleObjectsReturned: message = f"Multiple QMs with the same cave, year, number, grade AND first-several+terminal chars of the survexblock name. (Could be caused by incomplete databasereset). Fix this in the survex file(s). {cave_id=} {year=} {qm_id=} {blockname=}" return render(request, "errors/generic.html", {"message": message}) except QM.DoesNotExist: # raise return render( request, "errors/badslug.html", { "badslug": f"QM.DoesNotExist blockname is not empty string {cave_id=} {year=} {qm_id=} {grade=} {blockname=}" }, ) def expo_kml(request): return render( request, "expo.kml", { "entrances": Entrance.objects.all() }, content_type = "application/vnd.google-earth.kml+xml" ) def expo_kmz(request): notablecaves = set(getnotablecaves()) #Zip file written to a file, to save this function using too much memory with tempfile.TemporaryDirectory() as tmpdirname: zippath = os.path.join(tmpdirname, 'expo.kmz') with zipfile.ZipFile(zippath, 'w', compression=zipfile.ZIP_DEFLATED) as myzip: entrances = [] for e in Entrance.objects.all(): html = loader.get_template("entrance_html.kml").render({"entrance": e}, request) soup=BeautifulSoup(html) for img in soup.find_all("img"): #src_orig = img['src'] src = urllib.parse.urljoin(e.cavelist()[0].url.rpartition("/")[0] + "/", img['src']) img['src'] = src p = os.path.join(settings.EXPOWEB, src) #print(e.cavelist()[0].url, e.cavelist()[0].url.rpartition("/")[0] + "/", src_orig, p) if os.path.isfile(p): myzip.write(p, src) for a in soup.find_all("a"): try: ao = a['href'] aa = urllib.parse.urljoin(e.cavelist()[0].url.rpartition("/")[0] + "/", ao) a['href'] = urllib.parse.urljoin("https://expo.survex.com/", aa) print(e.cavelist()[0].url.rpartition("/")[0] + "/", ao, a['href']) except: pass html = mark_safe(soup.prettify("utf-8").decode("utf-8")) size = {True: "large", False:"small"}[bool(set(e.cavelist()) & notablecaves)] entrances.append(loader.get_template("entrance.kml").render({"entrance": e, "html": html, "size": size}, request)) s = loader.get_template("expo.kml").render({"entrances": entrances}, request) myzip.writestr("expo.kml", s) for f in os.listdir(settings.KMZ_ICONS_PATH): p = os.path.join(settings.KMZ_ICONS_PATH, f) if os.path.isfile(p): myzip.write(p, os.path.join("icons", f)) return FileResponse(open(zippath, 'rb'), content_type="application/vnd.google-earth.kmz .kmz")