Linting & formatting & python3 in shebang

Author: Fabrice Benhamouda

bibyml.py

@@ -12,30 +12,33 @@
     2015: bb
 
 corresponds to the dictionnary:
+
 {
   "eurocrypt": {
     "": test,
     "2013": aa,
     "2015": bb
   }
 }
-
-
 """
 
 import re
 import io
 from collections import OrderedDict
+import typing
 
 _parser_re = re.compile(r'^(\s*)([^:]+):(.*)$')
 _spaces_re = re.compile(r'^ *$')
 
+
 class ParserError(Exception):
     def __init__(self, line, msg=""):
-        message = """BibYml parsing error:\n    line: "{}"\n    message: {}""".format(line[:-1], msg)
-        super(ParserError,self).__init__(message)
+        message = """BibYml parsing error:\n    line: "{}"\n    message: {}""".format(
+            line[:-1], msg)
+        super(ParserError, self).__init__(message)
+
 
-def dict_get_path(d, p, make=False):
+def dict_get_path(d: dict, p: list, make=False):
     """ get the element of path p in dictionnary d,
         make the path if it does not exists and make=True """
     cur = d
@@ -46,22 +49,26 @@ def dict_get_path(d, p, make=False):
 
     return cur
 
-def parse(f):
+
+def parse(f: typing.TextIO) -> dict:
     """ Parse a bibyml file f intro a dictionnary """
     res = OrderedDict()
-    path = []            # path of the current element
-    path_indent = [0]    # indentation of all elements along the path + indentation of the children of the path
-                         # can end by -1 if the indentation of the children is not yet known (i.e., before the first children)
+    # `path` is the path of the current element
+    path = []
+    # `path_indent` stores the indentation of all the elements along the path
+    #   + the indentation of the children in the path
+    # it can end by -1 if the indentation of the children is not yet known (i.e., before the first children)
+    path_indent = [0]
 
     for line in f:
         if line.strip() == "":
             continue
         r = _parser_re.match(line)
-        if r == None:
+        if r is None:
             raise ParserError(line)
 
         (spaces_indent, key, value) = r.groups()
-        if _spaces_re.match(spaces_indent) == None:
+        if _spaces_re.match(spaces_indent) is None:
             raise ParserError(line, "only spaces are accepted")
         value = value.strip()
         key = key.strip()
@@ -80,38 +87,39 @@ def parse(f):
         while len(path_indent) > 1 and path_indent[-1] > indent:
             path_indent.pop()
             path.pop()
-        
+
         if indent != path_indent[-1]:
             raise ParserError(line, "indentation problem")
 
         d = dict_get_path(res, path)
-    
+
         d[key] = OrderedDict([("", value)]) if value != "" else OrderedDict()
-        path_indent.append(-1) # we do not know the next indentation level
+        path_indent.append(-1)  # we do not know the next indentation level
         path.append(key)
 
     return res
 
-def write(out, d, indent_key=4, indent_value=24, cur_indent=0):
-    for (k,v) in d.items():
-        if k=="":
+
+def write(out: typing.TextIO, d: dict, indent_key=4, indent_value=24, cur_indent=0) -> None:
+    for (k, v) in d.items():
+        if k == "":
             continue
         if "" in v and v[""] != "":
             out.write("{}{}: {}{}\n".format(
-                " "*indent_key*cur_indent, 
-                k, 
+                " "*indent_key*cur_indent,
+                k,
                 " "*(max(0, indent_value-(len(k)+2+indent_key*cur_indent))),
                 v[""]
             ))
         else:
             out.write("{}{}: \n".format(
-                " "*indent_key*cur_indent, 
+                " "*indent_key*cur_indent,
                 k
             ))
         write(out, v, cur_indent=cur_indent+1)
 
-def write_str(d, *args, **kwargs):
+
+def write_str(d: dict, *args, **kwargs) -> str:
     out = io.StringIO()
     write(out, d, *args, **kwargs)
     return out.getvalue()
-            

confs_years.py

@@ -6,21 +6,24 @@
 
 import logging
 
-def get_confs_years(db):
+
+def get_confs_years(db) -> dict:
     """ Return a dict associating a conference key to the set of years present in db """
     confs = {}
     for (key, entry) in db.entries.items():
-        if key.auth == None:
-            continue # we are only interested in papers !
+        if key.auth is None:
+            continue  # we are only interested in papers !
         conf = key.confkey
         if conf not in confs:
             confs[conf] = set()
         confs[conf].add(tools.short_to_full_year(key.year))
-    
+
     return confs
 
-def get_confs_years_inter_from_set(confs, missing_years):
-    """ Convert a dictionnary of conferences (keys) with set of years to a dictionnary of conferences with intervals, i.e., tuples (start year, end year)
+
+def get_confs_years_inter_from_set(confs: dict, missing_years) -> dict:
+    """ Convert a dictionnary of conferences (keys) with set of years
+    to a dictionnary of conferences with intervals, i.e., tuples (start year, end year)
     If some years are missing, log it except if missing_years[conf] contain this year """
 
     def get_missing_years(conf):
@@ -33,22 +36,24 @@ def set_to_tuple(conf, years):
         min_year = min(years)
         max_year = max(years)
         years = years | get_missing_years(conf)
-        if not (set(range(min_year, max_year+1)) <= years):
-            mis_years = set(range(min_year, max_year+1)) - years
-            min_year = max(mis_years)+1
-            logging.warning("For conference \"{}\", years {} are missing - so min year={} - to add an exception please modify db/config.py - variable missing_years".format(
-                conf,
-                ", ".join([str(y) for y in sorted(list(mis_years))]),
-                min_year
-            ))
-        return (min_year, max_year)
+        if not (set(range(min_year, max_year + 1)) <= years):
+            mis_years = set(range(min_year, max_year + 1)) - years
+            min_year = max(mis_years) + 1
+            logging.warning(
+                "For conference \"{}\", years {} are missing - so min year={} "
+                "- to add an exception please modify db/config.py - variable missing_years".format(
+                    conf,
+                    ", ".join([str(y) for y in sorted(list(mis_years))]),
+                    min_year
+                ))
+        return min_year, max_year
 
     confs_inter = {
-        conf: set_to_tuple(conf, confs[conf]) 
+        conf: set_to_tuple(conf, confs[conf])
         for conf in sorted(confs.keys())
     }
     return confs_inter
 
+
 def get_confs_years_inter(db, confs_missing_years):
     return get_confs_years_inter_from_set(get_confs_years(db), confs_missing_years)
-    

header.py

@@ -1,7 +1,7 @@
 import datetime
 from string import Template
 
-header_template="""% File generated by "$script"
+header_template = """% File generated by "$script"
 % DO NOT MODIFY MANUALLY
 
 %------------------------------------------------------------------
@@ -90,15 +90,15 @@
 def get_header(config, script, conf_years=None):
     timestamp = datetime.date.today().isoformat()
 
-    if conf_years!=None:
+    if conf_years is not None:
         conf_years_complete = """%------------------------------------------------------------------
 %  List of complete conferences:
 %""".split("\n")
-        
+
         for conf in sorted(iter(conf_years.keys()), key=lambda x: config.get_conf_name(x)):
             (start, end) = conf_years[conf]
             name = config.get_conf_name(conf)
-            conf_years_complete.append("%    {}:{}{} - {}".format(name, " "*(16-len(conf)-1), start, end))
+            conf_years_complete.append("%    {}:{}{} - {}".format(name, " " * (16 - len(conf) - 1), start, end))
 
         conf_years_complete = "\n".join(conf_years_complete)
         conf_years_complete += """\n%
@@ -109,16 +109,16 @@ def get_header(config, script, conf_years=None):
 
     conf_labels = []
     for conf_key in sorted(
-            iter(config.confs.keys()), 
-            key = lambda x:config.get_conf_name(x)
+            iter(config.confs.keys()),
+            key=lambda x: config.get_conf_name(x)
     ):
         conf_name = config.get_conf_name(conf_key)
-        conf_labels.append("%    {}:{}{}\n".format(conf_name, " "*(16-len(conf_name)-1), conf_key))
+        conf_labels.append("%    {}:{}{}\n".format(conf_name, " " * (16 - len(conf_name) - 1), conf_key))
     conf_labels = ''.join(conf_labels)
 
     return Template(header_template).substitute(
-        script = script,
-        timestamp = timestamp,
-        conf_years_complete = conf_years_complete,
-        conf_labels = conf_labels
-        )
+        script=script,
+        timestamp=timestamp,
+        conf_years_complete=conf_years_complete,
+        conf_labels=conf_labels
+    )

web2py_ctrl_default.py

@@ -4,28 +4,29 @@
 
 re_years = re.compile(r"^\s*(\d*)\s*(-\s*(\d*)\s*)?$")
 
-def get_years(confs, vars):
+
+def get_years(confs: iter, vars: dict) -> tuple[dict, dict, int]:
     errors = {}
     years = {}
     nb = 0
 
     for conf in confs:
-        years_conf = vars["years"+conf["key"]]
+        years_conf = vars["years" + conf["key"]]
         r = re_years.match(years_conf)
-        if r != None:
+        if r is not None:
             a = r.group(1)
             b = r.group(2)
             c = r.group(3)
 
-            a = None if a=="" else a
-            b = None if b=="" else b
-            c = None if c=="" else c
+            a = None if a == "" else a
+            b = None if b == "" else b
+            c = None if c == "" else c
 
-            start_year = int(a) if a!=None else a
-            end_year   = int(c) if c!=None else c
-            end_year   = start_year if b == None else end_year
+            start_year = int(a) if a is not None else a
+            end_year = int(c) if c is not None else c
+            end_year = start_year if b is not None else end_year
 
-            if a != None or b != None:
+            if a is not None or b is not None:
                 start_year = max(start_year, conf["start_year"]) if start_year != None else conf["start_year"]
                 end_year = min(end_year, conf["end_year"]) if end_year != None else conf["end_year"]
 
@@ -38,4 +39,4 @@ def get_years(confs, vars):
         else:
             errors[conf["key"]] = True
 
-    return (errors, years, nb)
+    return errors, years, nb