Begin work on new CLI

piket_client/cli.py

+import click
+from piket_client.model import ServerStatus, NetworkError
+
+
+@click.group()
+def cli():
+    """Poke coco from the command line."""
+    pass
+
+
+@cli.command()
+def status():
+    """Show the current status of the server."""
+
+    status = ServerStatus.is_server_running()
+
+    if isinstance(status, NetworkError):
+        print_error(f"Failed to get data from server, error {status.value}")
+        return
+
+    print_ok("Server is available.")
+
+    open_consumptions = ServerStatus.unsettled_consumptions()
+
+    if isinstance(open_consumptions, NetworkError):
+        print_error(f"Failed to get unsettled consumptions, error {open_consumptions.value}")
+        return
+
+    click.echo(f"There are {open_consumptions.amount} unsettled consumptions.")
+
+    if open_consumptions.amount > 0:
+        click.echo(f"First at: {open_consumptions.first_timestamp.strftime('%c')}")
+        click.echo(f"Most recent at: {open_consumptions.last_timestamp.strftime('%c')}")
+
+
+@cli.group()
+def people():
+    pass
+
+
+@cli.group()
+def settlements():
+    pass
+
+
+def print_ok(msg: str) -> None:
+    click.echo(click.style(msg, fg="green"))
+
+
+def print_error(msg: str) -> None:
+    click.echo(click.style(msg, fg="red", bold=True), err=True)
+
+
+if __name__ == "__main__":
+    cli()

piket_client/gui.py

     ConsumptionType,
     Consumption,
     ServerStatus,
+    NetworkError,
     Settlement,
 )
 import piket_client.logger
     app.setFont(font)
 
     # Test connectivity
-    server_running, info = ServerStatus.is_server_running()
+    server_running = ServerStatus.is_server_running()
 
-    if not server_running:
-        LOG.critical("Could not connect to server", extra={"info": info})
+    if isinstance(server_running, NetworkError):
+        LOG.critical("Could not connect to server, error %s", server_running.value)
         QMessageBox.critical(
             None,
             "Help er is iets kapot",
             "Kan niet starten omdat de server niet reageert, stuur een foto van "
-            "dit naar Maarten: " + repr(info),
+            "dit naar Maarten: " + repr(server_running.value),
         )
-        return 1
+        return
 
     # Load main window
     main_window = PiketMainWindow()
 
     # Test unsettled consumptions
     status = ServerStatus.unsettled_consumptions()
+    assert not isinstance(status, NetworkError)
 
-    unsettled = status["unsettled"]["amount"]
+    unsettled = status.amount
 
     if unsettled > 0:
-        first = status["unsettled"]["first"]
+        assert status.first_timestamp is not None
+
+        first = status.first_timestamp
         first_date = first.strftime("%c")
         ok = QMessageBox.information(
             None,
             name, ok = QInputDialog.getText(
                 None,
                 "Lijst afsluiten",
-                "Voer een naam in voor de lijst of druk op OK. Laat de datum " "staan.",
+                "Voer een naam in voor de lijst of druk op OK. Laat de datum staan.",
                 QLineEdit.Normal,
                 f"{first.strftime('%Y-%m-%d')}",
             )

piket_client/model.py

 from __future__ import annotations
 
 import datetime
+import enum
 import logging
-from typing import Any, List, NamedTuple, Optional, Sequence, Tuple
+from dataclasses import dataclass
+from typing import Any, List, NamedTuple, Optional, Sequence, Tuple, Union
 from urllib.parse import urljoin
 
 import requests
 DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%f"
 
 
+class NetworkError(enum.Enum):
+    """Represents errors that might occur when communicating with the server."""
+
+    HttpFailure = "http_failure"
+    """Returned when the server returns a non-successful status code."""
+
+    ConnectionFailure = "connection_failure"
+    """Returned when we can't connect to the server at all."""
+
+    InvalidData = "invalid_data"
+
+
 class ServerStatus:
     """ Provides helper classes to check whether the server is up. """
 
     @classmethod
-    def is_server_running(cls) -> Tuple[bool, Any]:
+    def is_server_running(cls) -> Union[bool, NetworkError]:
         try:
             req = requests.get(urljoin(SERVER_URL, "ping"))
-
-            if req.status_code == 200:
-                return True, req.content
-            return False, req.content
+            req.raise_for_status()
 
         except requests.ConnectionError as ex:
-            return False, ex
+            LOG.exception(ex)
+            return NetworkError.ConnectionFailure
+
+        except requests.HTTPError as ex:
+            LOG.exception(ex)
+            return NetworkError.HttpFailure
+
+        return True
+
+    @dataclass(frozen=True)
+    class OpenConsumptions:
+        amount: int
+        first_timestamp: Optional[datetime.datetime]
+        last_timestamp: Optional[datetime.datetime]
 
     @classmethod
-    def unsettled_consumptions(cls) -> dict:
-        req = requests.get(urljoin(SERVER_URL, "status"))
+    def unsettled_consumptions(cls) -> Union[OpenConsumptions, NetworkError]:
+        try:
+            req = requests.get(urljoin(SERVER_URL, "status"))
+            req.raise_for_status()
+            data = req.json()
 
-        data = req.json()
+        except requests.ConnectionError as e:
+            LOG.exception(e)
+            return NetworkError.ConnectionFailure
 
-        if data["unsettled"]["amount"]:
-            data["unsettled"]["first"] = datetime.datetime.strptime(
-                data["unsettled"]["first"], DATETIME_FORMAT
-            )
-            data["unsettled"]["last"] = datetime.datetime.strptime(
-                data["unsettled"]["last"], DATETIME_FORMAT
+        except requests.HTTPError as e:
+            LOG.exception(e)
+            return NetworkError.HttpFailure
+
+        except ValueError as e:
+            LOG.exception(e)
+            return NetworkError.InvalidData
+
+        amount: int = data["unsettled"]["amount"]
+
+        if amount == 0:
+            return cls.OpenConsumptions(
+                amount=0, first_timestamp=None, last_timestamp=None
             )
 
-        return data
+        first = datetime.datetime.fromisoformat(data["unsettled"]["first"])
+        last = datetime.datetime.fromisoformat(data["unsettled"]["last"])
+
+        return cls.OpenConsumptions(
+            amount=amount, first_timestamp=first, last_timestamp=last
+        )
 
 
 class Person(NamedTuple):

setup.py

     extras_require={
         "dev": ["black", "pylint", "mypy", "isort"],
         "server": ["Flask", "SQLAlchemy", "Flask-SQLAlchemy", "alembic", "uwsgi"],
-        "client": ["PySide2", "qdarkstyle>=2.6.0", "requests", "simpleaudio"],
+        "client": ["PySide2", "qdarkstyle>=2.6.0", "requests", "simpleaudio", "click"],
         "osk": ["dbus-python"],
         "sentry": ["raven"],
     },