client.model: Fix type annotations

piket_client/model.py

 """
 Provides access to the models stored in the database, via the server.
 """
+from __future__ import annotations
+
 import datetime
 import logging
-from typing import NamedTuple, Sequence, Tuple, Any, Optional
+from typing import Any, List, NamedTuple, Optional, Sequence, Tuple
 from urllib.parse import urljoin
 
 import requests
 
-
 LOG = logging.getLogger(__name__)
 
 SERVER_URL = "http://127.0.0.1:5000"
     def name(self) -> str:
         return self.display_name or self.full_name
 
-    def add_consumption(self, type_id: str) -> bool:
+    def add_consumption(self, type_id: str) -> Optional[Consumption]:
         """ Register a consumption for this Person. """
         req = requests.post(
             urljoin(SERVER_URL, f"people/{self.person_id}/add_consumption/{type_id}")
                     req.status_code,
                     data,
                 )
-                return False
+                return None
 
             self.consumptions.update(data["person"]["consumptions"])
 
                 req.status_code,
                 req.content,
             )
-            return False
+            return None
 
-    def create(self) -> "Person":
+    def create(self) -> Optional[Person]:
         """ Create a new Person from the current attributes. As tuples are
         immutable, a new Person with the correct id is returned. """
         req = requests.post(
 
         return Person.from_dict(data["person"])
 
-    def set_active(self, new_state=True) -> "Person":
+    def set_active(self, new_state=True) -> Optional[Person]:
         req = requests.patch(
             urljoin(SERVER_URL, f"people/{self.person_id}"),
             json={"person": {"active": new_state}},
         return Person.from_dict(data["person"])
 
     @classmethod
-    def get(cls, person_id: int) -> "Person":
+    def get(cls, person_id: int) -> Optional[Person]:
         """ Retrieve a Person by id. """
         req = requests.get(urljoin(SERVER_URL, f"/people/{person_id}"))
 
             return None
 
     @classmethod
-    def get_all(cls, active=None) -> ["Person"]:
+    def get_all(cls, active=None) -> Optional[List[Person]]:
         """ Get all active People. """
         params = {}
         if active is not None:
         )
 
     @classmethod
-    def get_all(cls) -> ["Export"]:
+    def get_all(cls) -> Optional[List[Export]]:
         """ Get a list of all existing Exports. """
         req = requests.get(urljoin(SERVER_URL, "exports"))
 
         return [cls.from_dict(e) for e in data["exports"]]
 
     @classmethod
-    def get(cls, export_id: int) -> "Export":
+    def get(cls, export_id: int) -> Optional[Export]:
         """ Retrieve one Export. """
         req = requests.get(urljoin(SERVER_URL, f"exports/{export_id}"))
 
         return cls.from_dict(data["export"])
 
     @classmethod
-    def create(cls) -> "Export":
+    def create(cls) -> Optional[Export]:
         """ Create a new Export, containing all un-exported Settlements. """
         req = requests.post(urljoin(SERVER_URL, "exports"))
 
     """ Represents a stored ConsumptionType. """
 
     name: str
-    consumption_type_id: int = None
-    icon: str = None
+    consumption_type_id: Optional[int] = None
+    icon: Optional[str] = None
 
-    def create(self) -> "ConsumptionType":
+    def create(self) -> Optional[ConsumptionType]:
         """ Create a new ConsumptionType from the current attributes. As tuples
         are immutable, a new ConsumptionType with the correct id is returned.
         """
         return ConsumptionType.from_dict(data["consumption_type"])
 
     @classmethod
-    def get(cls, consumption_type_id: int) -> "ConsumptionType":
+    def get(cls, consumption_type_id: int) -> Optional[ConsumptionType]:
         """ Retrieve a ConsumptionType by id. """
         req = requests.get(
             urljoin(SERVER_URL, f"/consumption_types/{consumption_type_id}")
             return None
 
     @classmethod
-    def get_all(cls) -> ["ConsumptionType"]:
+    def get_all(cls) -> Optional[List[ConsumptionType]]:
         """ Get all active ConsumptionTypes. """
         req = requests.get(urljoin(SERVER_URL, "/consumption_types"))
 
     consumption_type_id: int
     created_at: datetime.datetime
     reversed: bool = False
-    settlement_id: int = None
+    settlement_id: Optional[int] = None
 
     @classmethod
     def from_dict(cls, data: dict) -> "Consumption":
             reversed=data["reversed"],
         )
 
-    def reverse(self) -> "Consumption":
+    def reverse(self) -> Optional[Consumption]:
         """ Reverse this consumption. """
         req = requests.delete(
             urljoin(SERVER_URL, f"/consumptions/{self.consumption_id}")
                     req.status_code,
                     data,
                 )
-                return False
+                return None
 
             return Consumption.from_dict(data["consumption"])
 
                 req.status_code,
                 req.content,
             )
-            return False
+            return None
 
 
 class Settlement(NamedTuple):
         return cls.from_dict(req.json()["settlement"])
 
     @classmethod
-    def get(cls, settlement_id: int) -> "Settlement":
+    def get(cls, settlement_id: int) -> Optional[Settlement]:
         req = requests.get(urljoin(SERVER_URL, f"/settlements/{settlement_id}"))
 
         try: