Set Persons created by client to active

Adds active attribute to api, also ran black

piket_client/model.py

             return False, ex
 
     datetime_format = "%Y-%m-%dT%H:%M:%S.%f"
+
     @classmethod
     def unsettled_consumptions(cls) -> dict:
-        req = requests.get(urljoin(SERVER_URL, 'status'))
+        req = requests.get(urljoin(SERVER_URL, "status"))
 
         data = req.json()
 
-        if data['unsettled']['amount']:
-            data['unsettled']['first'] = datetime.datetime\
-                    .strptime(data['unsettled']['first'],
-                            cls.datetime_format)
-            data['unsettled']['last'] = datetime.datetime\
-                    .strptime(data['unsettled']['last'],
-                            cls.datetime_format)
+        if data["unsettled"]["amount"]:
+            data["unsettled"]["first"] = datetime.datetime.strptime(
+                data["unsettled"]["first"], cls.datetime_format
+            )
+            data["unsettled"]["last"] = datetime.datetime.strptime(
+                data["unsettled"]["last"], cls.datetime_format
+            )
 
         return data
 
 
-
 class Person(NamedTuple):
     """ Represents a Person, as retrieved from the database. """
 
         """ Create a new Person from the current attributes. As tuples are
         immutable, a new Person with the correct id is returned. """
         req = requests.post(
-            urljoin(SERVER_URL, "people"), json={"person": {"name": self.name}}
+            urljoin(SERVER_URL, "people"),
+            json={"person": {"name": self.name, "active": True}},
         )
 
         try:
             )
             return False
 
+
 class Settlement(NamedTuple):
     """ Represents a stored Settlement. """
+
     settlement_id: int
     name: str
     consumption_summary: dict
     @classmethod
     def from_dict(cls, data: dict) -> "Settlement":
         return Settlement(
-            settlement_id=data['settlement_id'],
-            name=data['name'],
-            consumption_summary=data['consumption_summary']
+            settlement_id=data["settlement_id"],
+            name=data["name"],
+            consumption_summary=data["consumption_summary"],
         )
 
     @classmethod
     def create(cls, name: str) -> "Settlement":
         req = requests.post(
-            urljoin(SERVER_URL, '/settlements'),
-            json={'settlement': {'name': name}}
+            urljoin(SERVER_URL, "/settlements"), json={"settlement": {"name": name}}
         )
 
-        return cls.from_dict(req.json()['settlement'])
+        return cls.from_dict(req.json()["settlement"])

piket_server/__init__.py

     @property
     def as_dict(self) -> dict:
         return {
-            'settlement_id': self.settlement_id,
-            'name': self.name,
-            'consumption_summary': self.consumption_summary
+            "settlement_id": self.settlement_id,
+            "name": self.name,
+            "consumption_summary": self.consumption_summary,
         }
 
     @property
     def consumption_summary(self) -> dict:
-        q = Consumption.\
-                query.\
-                filter_by(settlement=self).\
-                group_by(Consumption.consumption_type_id).\
-                outerjoin(ConsumptionType).\
-                with_entities(
-                    Consumption.consumption_type_id,
-                    ConsumptionType.name,
-                    func.count(Consumption.consumption_id),
-                ).\
-                all()
+        q = (
+            Consumption.query.filter_by(settlement=self)
+            .group_by(Consumption.consumption_type_id)
+            .outerjoin(ConsumptionType)
+            .with_entities(
+                Consumption.consumption_type_id,
+                ConsumptionType.name,
+                func.count(Consumption.consumption_id),
+            )
+            .all()
+        )
 
-        return {r[0]: {'name': r[1], 'count': r[2]} for r in q}
+        return {r[0]: {"name": r[1], "count": r[2]} for r in q}
 
 
 class ConsumptionType(db.Model):
     """ Return a status ping. """
     return "Pong"
 
+
 @app.route("/status")
 def status() -> None:
     """ Return a status dict with info about the database. """
-    unsettled_q = Consumption.query.\
-            filter_by(settlement=None).\
-            filter_by(reversed=False)
+    unsettled_q = Consumption.query.filter_by(settlement=None).filter_by(reversed=False)
 
     unsettled = unsettled_q.count()
 
     first = None
     last = None
     if unsettled:
-        last = unsettled_q.\
-                order_by(Consumption.created_at.desc()).\
-                first().\
-                created_at.isoformat()
-        first = unsettled_q.\
-                order_by(Consumption.created_at.asc())\
-                .first()\
-                .created_at.isoformat()
-
-    return jsonify({
-        'unsettled': {
-            'amount': unsettled,
-            'first': first,
-            'last': last,
-        },
-    })
+        last = (
+            unsettled_q.order_by(Consumption.created_at.desc())
+            .first()
+            .created_at.isoformat()
+        )
+        first = (
+            unsettled_q.order_by(Consumption.created_at.asc())
+            .first()
+            .created_at.isoformat()
+        )
+
+    return jsonify({"unsettled": {"amount": unsettled, "first": first, "last": last}})
 
 
 # Person
         return jsonify({"error": "Could not parse JSON."}), 400
 
     data = json.get("person") or {}
-    person = Person(name=data.get("name"))
+    person = Person(name=data.get("name"), active=data.get("active", False))
+
     try:
         db.session.add(person)
         db.session.commit()
 
     return jsonify(consumption_type=ct.as_dict), 201
 
+
 # Settlement
 @app.route("/settlements", methods=["GET"])
 def get_settlements():
     result = Settlement.query.all()
     return jsonify(settlements=[s.as_dict for s in result])
 
+
 @app.route("/settlements", methods=["POST"])
 def add_settlement():
     """ Create a Settlement, and link all un-settled Consumptions to it. """
     if not json:
         return jsonify({"error": "Could not parse JSON."}), 400
 
-    data = json.get('settlement') or {}
-    s = Settlement(name=data['name'])
+    data = json.get("settlement") or {}
+    s = Settlement(name=data["name"])
 
     db.session.add(s)
     db.session.commit()
 
-    Consumption.query.filter_by(settlement=None).update({'settlement_id':
-        s.settlement_id})
+    Consumption.query.filter_by(settlement=None).update(
+        {"settlement_id": s.settlement_id}
+    )
 
     db.session.commit()