server: Black

piket_server/__init__.py

 
 # ---------- Models ----------
 class Person(db.Model):
-    """ Represents a person to be shown on the lists. """
+    """Represents a person to be shown on the lists."""
 
     __tablename__ = "people"
 
 
 
 class Export(db.Model):
-    """ Represents a set of exported Settlements. """
+    """Represents a set of exported Settlements."""
 
     __tablename__ = "exports"
 
 
 
 class Settlement(db.Model):
-    """ Represents a settlement of the list. """
+    """Represents a settlement of the list."""
 
     __tablename__ = "settlements"
 
 
 
 class ConsumptionType(db.Model):
-    """ Represents a type of consumption to be counted. """
+    """Represents a type of consumption to be counted."""
 
     __tablename__ = "consumption_types"
 
 
 
 class Consumption(db.Model):
-    """ Represent one consumption to be counted. """
+    """Represent one consumption to be counted."""
 
     __tablename__ = "consumptions"
 
 
 @app.route("/ping")
 def ping() -> None:
-    """ Return a status ping. """
+    """Return a status ping."""
     return "Pong"
 
 
 @app.route("/status")
 def status() -> None:
-    """ Return a status dict with info about the database. """
+    """Return a status dict with info about the database."""
     unsettled_q = Consumption.query.filter_by(settlement=None).filter_by(reversed=False)
 
     unsettled = unsettled_q.count()
 # Person
 @app.route("/people", methods=["GET"])
 def get_people():
-    """ Return a list of currently known people. """
+    """Return a list of currently known people."""
     q = Person.query.order_by(Person.name)
     if request.args.get("active"):
         active_status = request.args.get("active", type=int)
     people = q.all()
 
     engine = db.get_engine()
-    query = '''
+    query = """
         SELECT
             consumptions.person_id,
             consumptions.consumption_type_id,
             consumptions.settlement_id IS NULL
             AND consumptions.reversed = 0
         GROUP BY consumptions.person_id, consumptions.consumption_type_id;
-    '''
+    """
     raw_counts = engine.execute(query)
 
-    counts: 'Dict[int, Dict[str, int]]' = defaultdict(dict)
+    counts: "Dict[int, Dict[str, int]]" = defaultdict(dict)
     for person_id, consumption_type_id, count in raw_counts:
         counts[person_id][str(consumption_type_id)] = count
 
             "name": person.name,
             "active": person.active,
             "person_id": person.person_id,
-            "consumptions": counts[person.person_id]
+            "consumptions": counts[person.person_id],
         }
         for person in people
     ]
 
 @app.route("/consumptions/<int:consumption_id>", methods=["DELETE"])
 def reverse_consumption(consumption_id: int):
-    """ Reverse a consumption. """
+    """Reverse a consumption."""
     consumption = Consumption.query.get_or_404(consumption_id)
 
     if consumption.reversed:
 # ConsumptionType
 @app.route("/consumption_types", methods=["GET"])
 def get_consumption_types():
-    """ Return a list of currently active consumption types. """
+    """Return a list of currently active consumption types."""
     ctypes = ConsumptionType.query.filter_by(active=True).all()
     result = [ct.as_dict for ct in ctypes]
     return jsonify(consumption_types=result)
 
 @app.route("/consumption_types", methods=["POST"])
 def add_consumption_type():
-    """ Add a new ConsumptionType.  """
+    """Add a new ConsumptionType."""
     json = request.get_json()
 
     if not json:
 # Settlement
 @app.route("/settlements", methods=["GET"])
 def get_settlements():
-    """ Return a list of the active Settlements. """
+    """Return a list of the active Settlements."""
     result = Settlement.query.all()
     return jsonify(settlements=[s.as_dict for s in result])
 
 
 @app.route("/settlements/<int:settlement_id>", methods=["GET"])
 def get_settlement(settlement_id: int):
-    """ Show full details for a single Settlement. """
+    """Show full details for a single Settlement."""
     s = Settlement.query.get_or_404(settlement_id)
 
     per_person = s.per_person
 
 @app.route("/settlements", methods=["POST"])
 def add_settlement():
-    """ Create a Settlement, and link all un-settled Consumptions to it. """
+    """Create a Settlement, and link all un-settled Consumptions to it."""
     json = request.get_json()
 
     if not json:
 # Export
 @app.route("/exports", methods=["GET"])
 def get_exports():
-    """ Return a list of the created Exports. """
+    """Return a list of the created Exports."""
     result = Export.query.all()
     return jsonify(exports=[e.as_dict for e in result])
 
 
 @app.route("/exports/<int:export_id>", methods=["GET"])
 def get_export(export_id: int):
-    """ Return an overview for the given Export. """
+    """Return an overview for the given Export."""
     e = Export.query.get_or_404(export_id)
 
     ss = [s.as_dict for s in e.settlements]
 
 @app.route("/exports", methods=["POST"])
 def add_export():
-    """ Create an Export, and link all un-exported Settlements to it. """
+    """Create an Export, and link all un-exported Settlements to it."""
     # Assert that there are Settlements to be exported.
     s_count = Settlement.query.filter_by(export=None).count()
     if s_count == 0: