Black, server check

piket_client/gui.py

 import sys
 
 import qdarkstyle
+
 # pylint: disable=E0611
 from PySide2.QtWidgets import (
     QAction,
     dbus = None
 
 from piket_client.sound import PLOP_WAVE, UNDO_WAVE
-from piket_client.model import Person, ConsumptionType, Consumption
+from piket_client.model import Person, ConsumptionType, Consumption, ServerStatus
 import piket_client.logger
 
 LOG = logging.getLogger(__name__)
         self.setContextMenuPolicy(Qt.CustomContextMenu)
         self.customContextMenuRequested.connect(self.confirm_hide)
 
-
     @Slot(str)
     def new_active_id(self, new_id: str) -> None:
         """ Change the active ConsumptionType id, update the label. """
     def confirm_hide(self) -> None:
         ok = QMessageBox.warning(
             self.window(),
-            'Persoon verbergen?',
-            f'Wil je {self.person.name} verbergen?',
+            "Persoon verbergen?",
+            f"Wil je {self.person.name} verbergen?",
             QMessageBox.Yes,
             QMessageBox.Cancel,
         )
 
         if ok == QMessageBox.Yes:
-            LOG.warning('Hiding person %s', self.person.name)
+            LOG.warning("Hiding person %s", self.person.name)
             self.person.set_active(False)
             self.parent().init_ui()
 
         self.active_consumption_type_id = new_id
         self.new_id_set.emit(new_id)
 
-
     def init_ui(self) -> None:
         """ Initialize UI: build GridLayout, retrieve People and build a button
         for each. """
                 self.osk = session_bus.get_object(
                     "org.onboard.Onboard", "/org/onboard/Onboard/Keyboard"
                 )
-            except dbus.exceptions.DBusException:
+            except dbus.exceptions.DBusException as exception:
                 # Onboard not present or dbus broken
                 self.osk = None
+                LOG.error("Could not connect to Onboard:")
+                LOG.exception(exception)
+        else:
+            LOG.warning("Onboard disabled due to missing dbus.")
 
         # Go full screen
         self.setWindowState(Qt.WindowActive | Qt.WindowFullScreen)
 
         # Right
         self.toolbar.addAction(
-            self.load_icon("add_consumption_type.svg"), "Nieuw",
-            self.add_consumption_type)
+            self.load_icon("add_consumption_type.svg"),
+            "Nieuw",
+            self.add_consumption_type,
+        )
         self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
         self.toolbar.setFloatable(False)
         self.toolbar.setMovable(False)
                 sys.exit()
 
         for ct in cts:
-            action = QAction(self.load_icon(ct.icon or "beer_bottle.svg"),
-                    ct.name, self.ct_ag)
+            action = QAction(
+                self.load_icon(ct.icon or "beer_bottle.svg"), ct.name, self.ct_ag
+            )
             action.setCheckable(True)
             action.setData(str(ct.consumption_type_id))
 
     def add_consumption_type(self) -> None:
         self.show_keyboard()
         name, ok = QInputDialog.getItem(
-            self,
-            "Lijst toevoegen",
-            "Wat wil je strepen?",
-            ["Wijn", "Radler"]
+            self, "Lijst toevoegen", "Wat wil je strepen?", ["Wijn", "Radler"]
         )
         self.hide_keyboard()
 
             ct = ct.create()
 
             action = QAction(
-                self.load_icon(ct.icon or "beer_bottle.svg"),
-                ct.name,
-                self.ct_ag
+                self.load_icon(ct.icon or "beer_bottle.svg"), ct.name, self.ct_ag
             )
             action.setCheckable(True)
             action.setData(str(ct.consumption_type_id))
         self.undo_queue.append(consumption)
         self.undo_action.setDisabled(False)
 
-
     @staticmethod
     def create_spacer() -> QWidget:
         """ Return an empty QWidget that automatically expands. """
         directory. """
 
         if self.dark_theme:
-            filename = 'white_' + filename
+            filename = "white_" + filename
 
         icon = QIcon(os.path.join(self.icons_dir, filename))
         return icon
 
 def main() -> None:
     """ Main entry point of GUI client. """
+    LOG.info("Loading piket_client")
     app = QApplication(sys.argv)
+
+    # Set dark theme
     app.setStyleSheet(qdarkstyle.load_stylesheet_pyside2())
+
+    # Enlarge font size
     font = app.font()
     size = font.pointSize()
     font.setPointSize(size * 1.5)
     app.setFont(font)
 
+    # Test connectivity
+    server_running, info = ServerStatus.is_server_running()
+
+    if not server_running:
+        LOG.critical("Could not connect to server", extra={"info": info})
+        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),
+        )
+        return 1
+
+    # Load main window
     main_window = PiketMainWindow()
     main_window.show()
 
+    # Let's go
+    LOG.info("Starting QT event loop.")
     app.exec_()
 
 

piket_client/logger.py

 import os.path
 import logging
-from logging import getLogger
+import logging.config
 
-logging.basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s: %(message)s",
-    level=logging.INFO,
-    filename=os.path.expanduser('~/.piket_client.log')
-)
+try:
+    from raven import Client
+    from raven.handlers.logging import SentryHandler
+    from raven.conf import setup_logging
+
+    HAVE_SENTRY = True
+except ImportError:
+    HAVE_SENTRY = False
+
+LOG_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": True,
+    "formatters": {
+        "console": {
+            "format": "[%(asctime)s][%(levelname)s] %(name)s "
+            "%(filename)s:%(funcName)s:%(lineno)d | %(message)s",
+            "datefmt": "%H:%M:%S",
+        }
+    },
+    "handlers": {
+        "console": {
+            "level": "DEBUG",
+            "class": "logging.StreamHandler",
+            "formatter": "console",
+        },
+        "file": {
+            "level": "INFO",
+            "class": "logging.FileHandler",
+            "formatter": "console",
+            "filename": os.path.expanduser("~/.piket_client.log"),
+        },
+    },
+    "loggers": {
+        "": {"handlers": ["console", "file"], "level": "INFO", "propagate": False},
+        "piket_client": {"level": "INFO", "propagate": True},
+    },
+}
+
+if HAVE_SENTRY and os.environ.get("SENTRY_DSN"):
+    LOG_CONFIG["handlers"]["sentry"] = {
+        "level": "ERROR",
+        "class": "raven.handlers.logging.SentryHandler",
+        "dsn": os.environ.get("SENTRY_DSN"),
+    }
+
+    LOG_CONFIG["loggers"][""]["handlers"].append("sentry")
+
+logging.config.dictConfig(LOG_CONFIG)

piket_client/model.py

 Provides access to the models stored in the database, via the server.
 """
 import datetime
+import logging
 from typing import NamedTuple
 from urllib.parse import urljoin
 
 import requests
 
-from . import logger
 
-LOG = logger.getLogger("model")
+LOG = logging.getLogger(__name__)
 
 SERVER_URL = "http://127.0.0.1:5000"
 
 
+class ServerStatus:
+    """ Provides helper classes to check whether the server is up. """
+
+    @classmethod
+    def is_server_running(cls) -> bool:
+        try:
+            req = requests.get(urljoin(SERVER_URL, "ping"))
+
+            if req.status_code == 200:
+                return True, req.content
+            return False, req.content
+
+        except requests.ConnectionError as ex:
+            return False, ex
+
+
 class Person(NamedTuple):
     """ Represents a Person, as retrieved from the database. """
 
         return Person.from_dict(data["person"])
 
     def set_active(self, new_state=True) -> "Person":
-        req = requests.patch(urljoin(SERVER_URL, f"people/{self.person_id}"),
-                json={'person': {'active':new_state}})
+        req = requests.patch(
+            urljoin(SERVER_URL, f"people/{self.person_id}"),
+            json={"person": {"active": new_state}},
+        )
 
         try:
             data = req.json()
 
         return Person.from_dict(data["person"])
 
-
-
     @classmethod
     def get(cls, person_id: int) -> "Person":
         """ Retrieve a Person by id. """
     def get_all(cls, active=None) -> ["Person"]:
         """ Get all active People. """
         active = int(active)
-        req = requests.get(urljoin(SERVER_URL, "/people"),
-                params={'active':active})
+        req = requests.get(urljoin(SERVER_URL, "/people"), params={"active": active})
 
         try:
             data = req.json()
     @classmethod
     def from_dict(cls, data: dict) -> "Consumption":
         """ Reconstruct a Consumption from a dict. """
-        datetime_format = '%Y-%m-%dT%H:%M:%S.%f'
+        datetime_format = "%Y-%m-%dT%H:%M:%S.%f"
         # 2018-08-31T17:30:47.871521
         return cls(
             consumption_id=data["consumption_id"],
             person_id=data["person_id"],
             consumption_type_id=data["consumption_type_id"],
             settlement_id=data["settlement_id"],
-            created_at=datetime.datetime.strptime(data["created_at"],
-                datetime_format),
+            created_at=datetime.datetime.strptime(data["created_at"], datetime_format),
             reversed=data["reversed"],
         )
 

piket_server/__init__.py

     """ Return a list of currently known people. """
     people = Person.query.order_by(Person.name).all()
     q = Person.query.order_by(Person.name)
-    if request.args.get('active'):
-        active_status = request.args.get('active', type=int)
+    if request.args.get("active"):
+        active_status = request.args.get("active", type=int)
         q = q.filter_by(active=active_status)
     people = q.all()
     result = [person.as_dict for person in people]
 
     return jsonify(person=person.as_dict, consumption=consumption.as_dict), 201
 
+
 @app.route("/people/<int:person_id>", methods=["PATCH"])
 def update_person(person_id: int):
     person = Person.query.get_or_404(person_id)
 
-    data = request.json['person']
+    data = request.json["person"]
 
-    if 'active' in data:
-        person.active = data['active']
+    if "active" in data:
+        person.active = data["active"]
 
         db.session.add(person)
         db.session.commit()

piket_server/seed.py

     parser_clear.add_argument("--removemydata", action="store_true")
 
     # Parser load_seeds
-    parser_load_persons = subparsers.add_parser("load_persons",
-            help="Load Person data.")
+    parser_load_persons = subparsers.add_parser(
+        "load_persons", help="Load Person data."
+    )
     parser_load_persons.set_defaults(func=cmd_load_persons)
-    parser_load_persons.add_argument('datafile')
+    parser_load_persons.add_argument("datafile")
 
     args = parser.parse_args()
     args.func(args)
 
     print("Aborting.")
 
+
 def cmd_load_persons(args) -> None:
     """ Entrypoint for 'load_persons" subcommand. """
 
         reader = csv.DictReader(csvfile)
 
         for row in reader:
-            p = Person(
-                name=row['name'],
-                active=bool(int(row['active']))
-            )
+            p = Person(name=row["name"], active=bool(int(row["active"])))
             db.session.add(p)
 
     db.session.commit()

setup.py

             'osk': [
                 'dbus-python',
             ],
+            'sentry': [
+                'raven',
+            ],
         },
 
         include_package_data=True,