ran 'black' to reformat all the core files

1 files changed, 288 insertions, 225 deletions

diff --git a/core/views/caves.py b/core/views/caves.py
index df85579..3ffbbbb 100644
--- a/core/views/caves.py
+++ b/core/views/caves.py
@@ -8,18 +8,14 @@ from pathlib import Path
 from django import forms
 from django.conf import settings
 from django.core.exceptions import MultipleObjectsReturned, ObjectDoesNotExist
-from django.http import (HttpResponse, HttpResponseNotFound,
-                         HttpResponseRedirect)
+from django.http import HttpResponse, HttpResponseNotFound, HttpResponseRedirect
 from django.shortcuts import get_object_or_404, render
 from django.urls import NoReverseMatch, reverse
 
 import settings
 import troggle.settings as settings
-from troggle.core.forms import (CaveAndEntranceFormSet, CaveForm, EntranceForm,
-                                EntranceLetterForm)
-from troggle.core.models.caves import (Area, Cave, CaveAndEntrance,
-                                       Entrance, EntranceSlug,
-                                       GetCaveLookup, SurvexStation)
+from troggle.core.forms import CaveAndEntranceFormSet, CaveForm, EntranceForm, EntranceLetterForm
+from troggle.core.models.caves import Area, Cave, CaveAndEntrance, Entrance, EntranceSlug, GetCaveLookup, SurvexStation
 from troggle.core.models.logbooks import CaveSlug, QM
 from troggle.core.models.troggle import DataIssue, Expedition
 from troggle.core.utils import write_and_commit, writetrogglefile
@@ -27,24 +23,25 @@ from troggle.core.views import expo
 
 from .auth import login_required_if_public
 
-'''Manages the complex procedures to assemble a cave description out of the compnoents
+"""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 = '''- Fix rendercave() so that CaveView works
+todo = """- Fix rendercave() so that CaveView works
 - in getCaves() search GCavelookup first, which should raise a MultpleObjectsReturned exception if no duplicates
-'''
+"""
+
 
 def getCaves(cave_id):
-    '''Only gets called if a call to getCave() raises a MultipleObjects exception
-    
+    """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'''
+    are duplicates"""
     try:
         caves = Cave.objects.filter(kataster_number=cave_id)
         caveset = set(caves)
-        
-        Gcavelookup = GetCaveLookup() # dictionary makes strings to Cave objects
+
+        Gcavelookup = GetCaveLookup()  # dictionary makes strings to Cave objects
         if cave_id in Gcavelookup:
             caveset.add(Gcavelookup[cave_id])
         return list(caveset)
@@ -53,45 +50,52 @@ def getCaves(cave_id):
 
 
 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.
-    
+    """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'''
+    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
+        raise MultipleObjectsReturned("Duplicate kataster number") from ex  # propagate this up
 
     except Cave.DoesNotExist as ex:
-        Gcavelookup = GetCaveLookup() # dictionary makes strings to Cave objects
+        Gcavelookup = GetCaveLookup()  # dictionary makes strings to Cave objects
         if cave_id in Gcavelookup:
-            return Gcavelookup[cave_id] 
+            return Gcavelookup[cave_id]
         else:
-            raise ObjectDoesNotExist("No cave found with this identifier in any id field") from ex # propagate this up           
+            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) 
+    return "0" * (5 - len(x.group(0))) + x.group(0)
+
+
 def padnumber(x):
-   return re.sub("\d+", pad5, x)
+    return re.sub("\d+", pad5, x)
+
+
 def numericalcmp(x, y):
-   return cmp(padnumber(x), padnumber(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 "9." + c.kataster_number
         return c.kataster_number
 
+
 def getnotablecaves():
     notablecaves = []
     for kataster_number in settings.NOTABLECAVESHREFS:
@@ -99,137 +103,146 @@ def getnotablecaves():
             cave = Cave.objects.get(kataster_number=kataster_number)
             notablecaves.append(cave)
         except:
-            #print(" ! FAILED to get only one cave per kataster_number OR invalid number for: "+kataster_number)
+            # print(" ! FAILED to get only one cave per kataster_number OR invalid number for: "+kataster_number)
             caves = Cave.objects.all().filter(kataster_number=kataster_number)
             for c in caves:
-                #print(c.kataster_number, c.slug())
+                # print(c.kataster_number, c.slug())
                 if c.slug() != None:
                     notablecaves.append(c)
     return notablecaves
 
+
 def caveindex(request):
     caves = Cave.objects.all()
-    caves1623 = list(Cave.objects.filter(area__short_name = "1623"))
-    caves1626 = list(Cave.objects.filter(area__short_name = "1626"))
+    caves1623 = list(Cave.objects.filter(area__short_name="1623"))
+    caves1626 = list(Cave.objects.filter(area__short_name="1626"))
     caves1623.sort(key=caveKey)
     caves1626.sort(key=caveKey)
-    return render(request,'caveindex.html', {'caves1623': caves1623, 'caves1626': caves1626, 'notablecaves':getnotablecaves(), 'cavepage': True})
+    return render(
+        request,
+        "caveindex.html",
+        {"caves1623": caves1623, "caves1626": caves1626, "notablecaves": getnotablecaves(), "cavepage": True},
+    )
 
-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 
+
+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
-    
+
     But the template file cave.html has its own ideas about the name of the file and thus the href. Ouch.
     /cave/3d/<cave_id>
-    '''
+    """
     try:
-        cave = getCave(cave_id) 
+        cave = getCave(cave_id)
     except ObjectDoesNotExist:
         return HttpResponseNotFound
-    except Cave.MultipleObjectsReturned: 
-        # But only one might have survex data? So scan and return the first that works. 
-        caves = getCaves(cave_id) 
-        for c in caves: 
-            if c.survex_file: 
+    except Cave.MultipleObjectsReturned:
+        # But only one might have survex data? So scan and return the first that works.
+        caves = getCaves(cave_id)
+        for c in caves:
+            if c.survex_file:
                 # exists, but may not be a valid file path to a valid .svx file in the Loser repo
                 return file3d(request, c, c.slug)
     else:
         return file3d(request, cave, cave_id)
 
+
 def file3d(request, cave, cave_id):
-    '''Produces a .3d file directly for download.
+    """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: 
+    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 ?)   
-    '''
+    - (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 
+        """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))
+        """
+        # print(" -  Regenerating cavern .log and .3d for '{}'".format(survexpath))
         if not survexpath.is_file():
-            #print(" -  - Regeneration ABORT\n -  - from '{}'".format(survexpath))
+            # print(" -  - Regeneration ABORT\n -  - from '{}'".format(survexpath))
             pass
         try:
-            completed_process = subprocess.run([settings.CAVERN, "--log", f"--output={settings.SURVEX_DATA}", f"{survexpath}"])
+            completed_process = subprocess.run(
+                [settings.CAVERN, "--log", f"--output={settings.SURVEX_DATA}", f"{survexpath}"]
+            )
         except OSError as ex:
-            # propagate this to caller. 
+            # 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'))
+        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}'
+            response = HttpResponse(content=open(threedpath, "rb"), content_type="application/3d")
+            response["Content-Disposition"] = f"attachment; filename={threedpath.name}"
             return response
         else:
             message = f'<h1>Path provided  does not correspond to any actual 3d file.</h1><p>path: "{threedpath}"'
-            #print(message)
-            return HttpResponseNotFound(message) 
-    
-    survexname = Path(cave.survex_file).name # removes directories
+            # 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) 
+    threedname = Path(survexname).with_suffix(".3d")  # removes .svx, replaces with .3d
+    threedpath = Path(settings.SURVEX_DATA, threedname)
     threedcachedir = Path(settings.SURVEX_DATA)
-    
+
     # These if statements need refactoring more cleanly
     if cave.survex_file:
-        #print(" -  cave.survex_file '{}'".format(cave.survex_file))
+        # print(" -  cave.survex_file '{}'".format(cave.survex_file))
         if threedpath.is_file():
-            #print(" -  threedpath '{}'".format(threedpath))
+            # 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))
+            # print(" -  - survexpath '{}'".format(survexpath))
             if survexpath.is_file():
-                #print(" -  -  - survexpath '{}'".format(survexpath))
+                # 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'<h1>File is not valid .svx format.</h1><p>Could not generate 3d file from "{survexpath}"'
+        message = f'<h1>File is not valid .svx format.</h1><p>Could not generate 3d file from "{survexpath}"'
     else:
         # we could try to guess that 'caves-1623/' is missing,... nah.
         message = f'<h1>Path provided  does not correspond to any actual file.</h1><p>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.
+    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})
+        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 
+            svx3d = Path(cave.survex_file).stem
             svxstem = Path(settings.SURVEX_DATA) / Path(cave.survex_file)
             # print(f" ! rendercave: slug:'{slug}' '' ++ '{svxstem}'")
         except:
@@ -239,45 +252,55 @@ def rendercave(request, cave, slug, cave_id=''):
         # 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'
-            
+        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}
+            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
+        r = render(
+            request, templatefile, context
+        )  # crashes here with NoReverseMatch if url not set up for 'edit_cave' in urls.py
         return r
- 
+
+
 def cavepage(request, karea, subpath):
-    '''Displays a cave description page
+    """Displays a cave description page
     accessed by kataster area number specifically
     OR
-    accessed by cave.url specifically set in data, e.g. 
+    accessed by cave.url specifically set in data, e.g.
     "1623/000/000.html" <= cave-data/1623-000.html
-    "1623/41/115.htm" <= cave-data/1623-115.html 
+    "1623/41/115.htm" <= cave-data/1623-115.html
     so we have to query the database to fine the URL as we cannot rely on the url actually telling us the cave by inspection.
-    
+
     There are A LOT OF URLS to e.g. /1623/161/l/rl89a.htm which are IMAGES and html files
     in cave descriptions. These need to be handled HERE
-    '''
+    """
     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
+        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) 
+        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 })
-       
+        return render(request, "svxcaveseveral.html", {"settings": settings, "caves": caves})
+
     try:
         r = rendercave(request, cave, cave.slug())
         return r
@@ -285,64 +308,66 @@ def cavepage(request, karea, subpath):
         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})
+            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 
+        # anything else is a new problem. Add in specific error messages here as we discover new types of error
         raise
- 
+
+
 def caveEntrance(request, slug):
     try:
-        cave = Cave.objects.get(caveslug__slug = slug)
+        cave = Cave.objects.get(caveslug__slug=slug)
     except:
-        return render(request,'errors/badslug.html', {'badslug': slug})
+        return render(request, "errors/badslug.html", {"badslug": slug})
 
     if cave.non_public and settings.PUBLIC_SITE and not request.user.is_authenticated:
-        return render(request,'nonpublic.html', {'instance': cave})
+        return render(request, "nonpublic.html", {"instance": cave})
     else:
-        return render(request,'cave_entrances.html', {'cave': cave})
+        return render(request, "cave_entrances.html", {"cave": cave})
+
 
 @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
+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.
-    
+
     It does save the data into into the database directly, not by parsing the file.
-    '''
+    """
     message = ""
-    if  slug is not None:
+    if slug is not None:
         try:
-            cave = Cave.objects.get(caveslug__slug = slug)
+            cave = Cave.objects.get(caveslug__slug=slug)
         except:
-            return render(request,'errors/badslug.html', {'badslug': slug})
+            return render(request, "errors/badslug.html", {"badslug": slug})
     else:
         cave = Cave()
     if request.POST:
         form = CaveForm(request.POST, instance=cave)
         ceFormSet = CaveAndEntranceFormSet(request.POST)
-        #versionControlForm = VersionControlCommentForm(request.POST)
+        # versionControlForm = VersionControlCommentForm(request.POST)
         if form.is_valid() and ceFormSet.is_valid():
-            #print(f'! POST is valid. {cave}')
-            cave = form.save(commit = False)
+            # print(f'! POST is valid. {cave}')
+            cave = form.save(commit=False)
             if slug is None:
                 for a in form.cleaned_data["area"]:
                     if a.kat_area():
                         myArea = a.kat_area()
                 if form.cleaned_data["kataster_number"]:
-                    myslug =  f"{myArea}-{form.cleaned_data['kataster_number']}"
+                    myslug = f"{myArea}-{form.cleaned_data['kataster_number']}"
                 else:
-                    myslug =  f"{myArea}-{form.cleaned_data['unofficial_number']}"
+                    myslug = f"{myArea}-{form.cleaned_data['unofficial_number']}"
             else:
                 myslug = slug
             # Converting a PENDING cave to a real cave by saving this form
-            myslug = myslug.replace('-PENDING-', '-')
+            myslug = myslug.replace("-PENDING-", "-")
             cave.filename = myslug + ".html"
             cave.save()
             form.save_m2m()
             if slug is None:
-              cs = CaveSlug(cave = cave, slug = myslug, primary = True)
-              cs.save()
+                cs = CaveSlug(cave=cave, slug=myslug, primary=True)
+                cs.save()
             ceinsts = ceFormSet.save(commit=False)
             for ceinst in ceinsts:
                 ceinst.cave = cave
@@ -353,59 +378,65 @@ def edit_cave(request, path = "", slug=None):
                 write_and_commit([cave_file], f"Online edit of {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})
+                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})
+                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})
 
-            return HttpResponseRedirect("/" + cave.url)   
+            return HttpResponseRedirect("/" + cave.url)
         else:
-            message = f'! POST data is INVALID {cave}'
+            message = f"! POST data is INVALID {cave}"
             print(message)
     else:
         form = CaveForm(instance=cave)
         ceFormSet = CaveAndEntranceFormSet(queryset=cave.caveandentrance_set.all())
-        #versionControlForm = VersionControlCommentForm()
-        
-    return render(request, 
-                               'editcave.html', 
-                               {'form': form, 'cave': cave, 'message': message,
-                                'caveAndEntranceFormSet': ceFormSet,
-                                #'versionControlForm': versionControlForm
-                                })
+        # versionControlForm = VersionControlCommentForm()
+
+    return render(
+        request,
+        "editcave.html",
+        {
+            "form": form,
+            "cave": cave,
+            "message": message,
+            "caveAndEntranceFormSet": ceFormSet,
+            #'versionControlForm': versionControlForm
+        },
+    )
+
 
 @login_required_if_public
-def edit_entrance(request, path = "", caveslug=None, slug=None):
-    '''This is the form that edits the entrance data for a single entrance and writes out 
+def edit_entrance(request, path="", caveslug=None, slug=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.
-    
+
     It does save the data into into the database directly, not by parsing the file.
-    '''
-    
+    """
+
     try:
-        cave = Cave.objects.get(caveslug__slug = caveslug)
+        cave = Cave.objects.get(caveslug__slug=caveslug)
     except:
-        return render(request,'errors/badslug.html', {'badslug': caveslug})
+        return render(request, "errors/badslug.html", {"badslug": caveslug})
 
     if slug:
-        entrance = Entrance.objects.get(entranceslug__slug = slug)
-        caveAndEntrance = CaveAndEntrance.objects.get(entrance = entrance, cave = cave)
+        entrance = Entrance.objects.get(entranceslug__slug=slug)
+        caveAndEntrance = CaveAndEntrance.objects.get(entrance=entrance, cave=cave)
         entlettereditable = False
     else:
         entrance = Entrance()
-        caveAndEntrance = CaveAndEntrance(cave = cave, entrance = entrance)
+        caveAndEntrance = CaveAndEntrance(cave=cave, entrance=entrance)
         entlettereditable = True
-    
+
     if request.POST:
-        form = EntranceForm(request.POST, instance = entrance)
-        entletter = EntranceLetterForm(request.POST, instance = caveAndEntrance)
-        #versionControlForm = VersionControlCommentForm(request.POST)
+        form = EntranceForm(request.POST, instance=entrance)
+        entletter = EntranceLetterForm(request.POST, instance=caveAndEntrance)
+        # versionControlForm = VersionControlCommentForm(request.POST)
         if form.is_valid() and entletter.is_valid():
-            entrance = form.save(commit = False)
-            entrance_letter = entletter.save(commit = False)
+            entrance = form.save(commit=False)
+            entrance_letter = entletter.save(commit=False)
             if slug is None:
                 if entletter.cleaned_data["entrance_letter"]:
                     slugname = cave.slug() + entletter.cleaned_data["entrance_letter"]
@@ -415,7 +446,7 @@ def edit_entrance(request, path = "", caveslug=None, slug=None):
                 entrance.filename = slugname + ".html"
             entrance.save()
             if slug is None:
-                es = EntranceSlug(entrance = entrance, slug = slugname, primary = True)
+                es = EntranceSlug(entrance=entrance, slug=slugname, primary=True)
                 es.save()
             entrance_file = entrance.file_output()
             cave_file = cave.file_output()
@@ -423,116 +454,148 @@ def edit_entrance(request, path = "", caveslug=None, slug=None):
             entrance.save()
             if slug is None:
                 entrance_letter.save()
-            return HttpResponseRedirect("/" + cave.url) 
+            return HttpResponseRedirect("/" + cave.url)
     else:
-        form = EntranceForm(instance = entrance)
-        #versionControlForm = VersionControlCommentForm()
+        form = EntranceForm(instance=entrance)
+        # versionControlForm = VersionControlCommentForm()
         if slug is None:
             entletter = EntranceLetterForm()
         else:
             entletter = caveAndEntrance.entrance_letter
 
-    return render(request, 
-                               'editentrance.html', 
-                               {'form': form, 
-                               	
-                               'cave': cave,
-                                #'versionControlForm': versionControlForm,
-                                'entletter': entletter,
-                                'entlettereditable': entlettereditable
-                                })
+    return render(
+        request,
+        "editentrance.html",
+        {
+            "form": form,
+            "cave": cave,
+            #'versionControlForm': versionControlForm,
+            "entletter": entletter,
+            "entlettereditable": entlettereditable,
+        },
+    )
+
 
 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(entrance_letter = ent_letter)[0]
-    return render(request,'entrance.html', {'cave': cave,
-                                                'entrance': cave_and_ent.entrance,
-                                                'letter': cave_and_ent.entrance_letter,})
+    cave = Cave.objects.filter(kataster_number=cave_id)[0]
+    cave_and_ent = CaveAndEntrance.objects.filter(cave=cave).filter(entrance_letter=ent_letter)[0]
+    return render(
+        request,
+        "entrance.html",
+        {
+            "cave": cave,
+            "entrance": cave_and_ent.entrance,
+            "letter": cave_and_ent.entrance_letter,
+        },
+    )
+
 
 # def entranceSlug(request, slug):
-    # '''This seems to be a fossil, but I am not sure...
-    # '''
-    # entrance = Entrance.objects.get(entranceslug__slug = slug)
-    # if entrance.non_public and not request.user.is_authenticated:
-        # return render(request,'nonpublic.html', {'instance': entrance})
-    # else:
-        # return render(request,'entranceslug.html', {'entrance': entrance})
+# '''This seems to be a fossil, but I am not sure...
+# '''
+# entrance = Entrance.objects.get(entranceslug__slug = slug)
+# if entrance.non_public and not request.user.is_authenticated:
+# return render(request,'nonpublic.html', {'instance': entrance})
+# else:
+# return render(request,'entranceslug.html', {'entrance': entrance})
 
 # def surveyindex(request):
-    # '''The template does not exist, there is no URL which calls this, so it is a fossil
-    # '''
-    # surveys=Survey.objects.all()
-    # expeditions=Expedition.objects.order_by("-year")
-    # return render(request,'survey.html',locals())
+# '''The template does not exist, there is no URL which calls this, so it is a fossil
+# '''
+# surveys=Survey.objects.all()
+# expeditions=Expedition.objects.order_by("-year")
+# return render(request,'survey.html',locals())
+
 
 def get_entrances(request, caveslug):
     try:
-        cave = Cave.objects.get(caveslug__slug = caveslug)
+        cave = Cave.objects.get(caveslug__slug=caveslug)
     except:
-        return render(request,'errors/badslug.html', {'badslug': caveslug})
-    return render(request,'options.html', {"items": [(e.entrance.slug(), e.entrance.slug()) for e in cave.entrances()]})
+        return render(request, "errors/badslug.html", {"badslug": caveslug})
+    return render(
+        request, "options.html", {"items": [(e.entrance.slug(), e.entrance.slug()) for e in cave.entrances()]}
+    )
+
 
 def caveQMs(request, slug):
-    '''Lists all the QMs on a particular cave
+    """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)
+        cave = Cave.objects.get(caveslug__slug=slug)
     except:
-        return render(request,'errors/badslug.html', {'badslug': slug})
-        
+        return render(request, "errors/badslug.html", {"badslug": slug})
+
     if cave.non_public and settings.PUBLIC_SITE and not request.user.is_authenticated:
-        return render(request,'nonpublic.html', {'instance': cave})
+        return render(request, "nonpublic.html", {"instance": cave})
     else:
-        return render(request,'cave_qms.html', {'cave': cave})
+        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 
+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.
-    
+
     290 has several QMS with the same number, grade, year (2108) and first 8 chars of the survexblock. This crashes things.
-    '''
-    
-    year=int(year)
-    
-    if blockname == '' or not blockname:
+    """
+
+    year = int(year)
+
+    if blockname == "" or not blockname:
         # CSV import QMs, use old technique
         try:
-            c=getCave(cave_id)
-            manyqms=c.get_QMs()
-            qm=manyqms.get(number=qm_id,expoyear=year) 
-            return render(request,'qm.html', {'qm': qm})
+            c = getCave(cave_id)
+            manyqms = c.get_QMs()
+            qm = manyqms.get(number=qm_id, expoyear=year)
+            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=}'})
+            # raise
+            return render(
+                request,
+                "errors/badslug.html",
+                {
+                    "badslug": f"QM.DoesNotExist blockname is empty string: {cave_id=} {year=} {qm_id=} {grade=} {blockname=}"
+                },
+            )
 
     else:
         try:
-            qmslug = f'{cave_id}-{year}-{blockname=}{qm_id}{grade}'
-            print(f'{qmslug=}')
-            c=getCave(cave_id)
-            manyqms=c.get_QMs()
-            qmqs=manyqms.filter(expoyear=year, blockname=blockname, number=qm_id, grade=grade) 
-            if len(qmqs) > 1:           
+            qmslug = f"{cave_id}-{year}-{blockname=}{qm_id}{grade}"
+            print(f"{qmslug=}")
+            c = getCave(cave_id)
+            manyqms = c.get_QMs()
+            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 8 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})
+                message = f"Multiple QMs with the same cave, year, number, grade AND first 8 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) 
+                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})
+                    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=}'})
+                    # 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 8 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})
+            message = f"Multiple QMs with the same cave, year, number, grade AND first 8 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=}'})
-
- 
+            # raise
+            return render(
+                request,
+                "errors/badslug.html",
+                {
+                    "badslug": f"QM.DoesNotExist blockname is not empty string {cave_id=} {year=} {qm_id=} {grade=} {blockname=}"
+                },
+            )