style: formatted with black

Author: ErikBjare

aw_server/__about__.py

@@ -21,7 +21,16 @@ def detect_version_ci() -> Optional[str]:
 
 def detect_version_git() -> Optional[str]:
     try:
-        return basever + ".dev+" + str(subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD']).strip(), "utf8")
+        return (
+            basever
+            + ".dev+"
+            + str(
+                subprocess.check_output(
+                    ["git", "rev-parse", "--short", "HEAD"]
+                ).strip(),
+                "utf8",
+            )
+        )
     except Exception as e:
         # Unable to get current commit with git
         return None
@@ -43,7 +52,7 @@ def detect_version():
     return basever + ".dev+unknown"
 
 
-__version__ = 'v0.8.dev+c6433ea'
+__version__ = "v0.8.dev+c6433ea"
 
 
 def assign_static_version():

aw_server/api.py

@@ -26,11 +26,11 @@
 def get_device_id() -> str:
     path = Path(get_data_dir("aw-server")) / "device_id"
     if path.exists():
-        with open(path, 'r') as f:
+        with open(path, "r") as f:
             return f.read()
     else:
         uuid = str(uuid4())
-        with open(path, 'w') as f:
+        with open(path, "w") as f:
             f.write(uuid)
         return uuid
 
@@ -39,8 +39,11 @@ def check_bucket_exists(f):
     @functools.wraps(f)
     def g(self, bucket_id, *args, **kwargs):
         if bucket_id not in self.db.buckets():
-            raise NotFound("NoSuchBucket", "There's no bucket named {}".format(bucket_id))
+            raise NotFound(
+                "NoSuchBucket", "There's no bucket named {}".format(bucket_id)
+            )
         return f(self, bucket_id, *args, **kwargs)
+
     return g
 
 
@@ -53,10 +56,10 @@ def __init__(self, db, testing) -> None:
     def get_info(self) -> Dict[str, Dict]:
         """Get server info"""
         payload = {
-            'hostname': gethostname(),
-            'version': __version__,
-            'testing': self.testing,
-            'device_id': get_device_id(),
+            "hostname": gethostname(),
+            "version": __version__,
+            "testing": self.testing,
+            "device_id": get_device_id(),
         }
         return payload
 
@@ -106,18 +109,29 @@ def import_bucket(self, bucket_data: Any):
             type=bucket_data["type"],
             client=bucket_data["client"],
             hostname=bucket_data["hostname"],
-            created=(bucket_data["created"]
-                     if isinstance(bucket_data["created"], datetime)
-                     else iso8601.parse_date(bucket_data["created"])),
+            created=(
+                bucket_data["created"]
+                if isinstance(bucket_data["created"], datetime)
+                else iso8601.parse_date(bucket_data["created"])
+            ),
+        )
+        self.create_events(
+            bucket_id,
+            [Event(**e) if isinstance(e, dict) else e for e in bucket_data["events"]],
         )
-        self.create_events(bucket_id, [Event(**e) if isinstance(e, dict) else e for e in bucket_data["events"]])
 
     def import_all(self, buckets: Dict[str, Any]):
         for bid, bucket in buckets.items():
             self.import_bucket(bucket)
 
-    def create_bucket(self, bucket_id: str, event_type: str, client: str,
-                      hostname: str, created: Optional[datetime] = None)-> bool:
+    def create_bucket(
+        self,
+        bucket_id: str,
+        event_type: str,
+        client: str,
+        hostname: str,
+        created: Optional[datetime] = None,
+    ) -> bool:
         """
         Create bucket.
         Returns True if successful, otherwise false if a bucket with the given ID already existed.
@@ -131,7 +145,7 @@ def create_bucket(self, bucket_id: str, event_type: str, client: str,
             type=event_type,
             client=client,
             hostname=hostname,
-            created=created
+            created=created,
         )
         return True
 
@@ -143,14 +157,20 @@ def delete_bucket(self, bucket_id: str) -> None:
         return None
 
     @check_bucket_exists
-    def get_events(self, bucket_id: str, limit: int = -1,
-                   start: datetime = None, end: datetime = None) -> List[Event]:
+    def get_events(
+        self,
+        bucket_id: str,
+        limit: int = -1,
+        start: datetime = None,
+        end: datetime = None,
+    ) -> List[Event]:
         """Get events from a bucket"""
         logger.debug("Received get request for events in bucket '{}'".format(bucket_id))
         if limit is None:  # Let limit = None also mean "no limit"
             limit = -1
-        events = [event.to_json_dict() for event in
-                  self.db[bucket_id].get(limit, start, end)]
+        events = [
+            event.to_json_dict() for event in self.db[bucket_id].get(limit, start, end)
+        ]
         return events
 
     @check_bucket_exists
@@ -161,10 +181,13 @@ def create_events(self, bucket_id: str, events: List[Event]) -> Optional[Event]:
         return self.db[bucket_id].insert(events[0] if len(events) == 1 else events)
 
     @check_bucket_exists
-    def get_eventcount(self, bucket_id: str,
-                       start: datetime = None, end: datetime = None) -> int:
+    def get_eventcount(
+        self, bucket_id: str, start: datetime = None, end: datetime = None
+    ) -> int:
         """Get eventcount from a bucket"""
-        logger.debug("Received get request for eventcount in bucket '{}'".format(bucket_id))
+        logger.debug(
+            "Received get request for eventcount in bucket '{}'".format(bucket_id)
+        )
         return self.db[bucket_id].get_eventcount(start, end)
 
     @check_bucket_exists
@@ -195,8 +218,15 @@ def heartbeat(self, bucket_id: str, heartbeat: Event, pulsetime: float) -> Event
 
         Inspired by: https://wakatime.com/developers#heartbeats
         """
-        logger.debug("Received heartbeat in bucket '{}'\n\ttimestamp: {}, duration: {}, pulsetime: {}\n\tdata: {}".format(
-                     bucket_id, heartbeat.timestamp, heartbeat.duration, pulsetime, heartbeat.data))
+        logger.debug(
+            "Received heartbeat in bucket '{}'\n\ttimestamp: {}, duration: {}, pulsetime: {}\n\tdata: {}".format(
+                bucket_id,
+                heartbeat.timestamp,
+                heartbeat.duration,
+                pulsetime,
+                heartbeat.data,
+            )
+        )
 
         # The endtime here is set such that in the event that the heartbeat is older than an
         # existing event we should try to merge it with the last event before the heartbeat instead.
@@ -220,16 +250,32 @@ def heartbeat(self, bucket_id: str, heartbeat: Event, pulsetime: float) -> Event
                 merged = heartbeat_merge(last_event, heartbeat, pulsetime)
                 if merged is not None:
                     # Heartbeat was merged into last_event
-                    logger.debug("Received valid heartbeat, merging. (bucket: {})".format(bucket_id))
+                    logger.debug(
+                        "Received valid heartbeat, merging. (bucket: {})".format(
+                            bucket_id
+                        )
+                    )
                     self.last_event[bucket_id] = merged
                     self.db[bucket_id].replace_last(merged)
                     return merged
                 else:
-                    logger.info("Received heartbeat after pulse window, inserting as new event. (bucket: {})".format(bucket_id))
+                    logger.info(
+                        "Received heartbeat after pulse window, inserting as new event. (bucket: {})".format(
+                            bucket_id
+                        )
+                    )
             else:
-                logger.debug("Received heartbeat with differing data, inserting as new event. (bucket: {})".format(bucket_id))
+                logger.debug(
+                    "Received heartbeat with differing data, inserting as new event. (bucket: {})".format(
+                        bucket_id
+                    )
+                )
         else:
-            logger.info("Received heartbeat, but bucket was previously empty, inserting as new event. (bucket: {})".format(bucket_id))
+            logger.info(
+                "Received heartbeat, but bucket was previously empty, inserting as new event. (bucket: {})".format(
+                    bucket_id
+                )
+            )
 
         self.db[bucket_id].insert(heartbeat)
         self.last_event[bucket_id] = heartbeat
@@ -238,7 +284,9 @@ def heartbeat(self, bucket_id: str, heartbeat: Event, pulsetime: float) -> Event
     def query2(self, name, query, timeperiods, cache):
         result = []
         for timeperiod in timeperiods:
-            period = timeperiod.split("/")[:2]  # iso8601 timeperiods are separated by a slash
+            period = timeperiod.split("/")[
+                :2
+            ]  # iso8601 timeperiods are separated by a slash
             starttime = iso8601.parse_date(period[0])
             endtime = iso8601.parse_date(period[1])
             query = str().join(query)
@@ -249,7 +297,7 @@ def query2(self, name, query, timeperiods, cache):
     def get_log(self):
         """Get the server log in json format"""
         payload = []
-        with open(get_log_file_path(), 'r') as log_file:
+        with open(get_log_file_path(), "r") as log_file:
             for line in log_file.readlines()[::-1]:
                 payload.append(json.loads(line))
         return payload, 200

aw_server/config.py

@@ -7,13 +7,13 @@
     "host": "localhost",
     "port": "5600",
     "storage": "peewee",
-    "cors_origins": ""
+    "cors_origins": "",
 }
 default_config["server-testing"] = {
     "host": "localhost",
     "port": "5666",
     "storage": "peewee",
-    "cors_origins": ""
+    "cors_origins": "",
 }
 
 config = load_config("aw-server", default_config)

aw_server/exceptions.py

@@ -6,11 +6,13 @@ def __init__(self, type: str, message: str) -> None:
         super().__init__(message)
         self.type = type
 
+
 class NotFound(werkzeug.exceptions.NotFound):
     def __init__(self, type: str, message: str) -> None:
         super().__init__(message)
         self.type = type
 
+
 class Unauthorized(werkzeug.exceptions.Unauthorized):
     def __init__(self, type: str, message: str) -> None:
         super().__init__(message)

aw_server/log.py

@@ -22,4 +22,4 @@ def log(self, levelname, message, *args):
             levelno = logging.DEBUG
         else:
             raise Exception("Unknown level " + type)
-        self.logger.log(levelno, '{} ({}): {}'.format(code, self.address_string(), msg))
+        self.logger.log(levelno, "{} ({}): {}".format(code, self.address_string(), msg))

aw_server/main.py

@@ -20,45 +20,60 @@ def main():
     # but instead add a logging handler that it can use privately.
     # That is why log_file_json=True currently.
     # UPDATE: The LogResource API is no longer available so log_file_json is now False.
-    setup_logging("aw-server", testing=settings.testing, verbose=settings.verbose,
-                  log_stderr=True, log_file=True, log_file_json=False)
+    setup_logging(
+        "aw-server",
+        testing=settings.testing,
+        verbose=settings.verbose,
+        log_stderr=True,
+        log_file=True,
+        log_file_json=False,
+    )
 
     logger.info("Using storage method: {}".format(settings.storage))
 
     if settings.testing:
         logger.info("Will run in testing mode")
 
     logger.info("Starting up...")
-    _start(host=settings.host, port=settings.port,
-           testing=settings.testing, storage_method=storage_method, cors_origins=settings.cors_origins)
+    _start(
+        host=settings.host,
+        port=settings.port,
+        testing=settings.testing,
+        storage_method=storage_method,
+        cors_origins=settings.cors_origins,
+    )
 
 
 def parse_settings():
     import argparse
 
     """ CLI Arguments """
-    parser = argparse.ArgumentParser(description='Starts an ActivityWatch server')
-    parser.add_argument('--testing',
-                        action='store_true',
-                        help='Run aw-server in testing mode using different ports and database')
-    parser.add_argument('--verbose',
-                        action='store_true',
-                        help='Be chatty.')
-    parser.add_argument('--log-json',
-                        action='store_true',
-                        help='Output the logs in JSON format')
-    parser.add_argument('--host',
-                        dest='host',
-                        help='Which host address to bind the server to')
-    parser.add_argument('--port',
-                        dest='port',
-                        type=int,
-                        help='Which port to run the server on')
-    parser.add_argument('--storage', dest='storage',
-                        help='The method to use for storing data. Some methods (such as MongoDB) require specific Python packages to be available (in the MongoDB case: pymongo)')
-    parser.add_argument('--cors-origins',
-                        dest='cors_origins',
-                        help='CORS origins to allow (as a comma separated list)')
+    parser = argparse.ArgumentParser(description="Starts an ActivityWatch server")
+    parser.add_argument(
+        "--testing",
+        action="store_true",
+        help="Run aw-server in testing mode using different ports and database",
+    )
+    parser.add_argument("--verbose", action="store_true", help="Be chatty.")
+    parser.add_argument(
+        "--log-json", action="store_true", help="Output the logs in JSON format"
+    )
+    parser.add_argument(
+        "--host", dest="host", help="Which host address to bind the server to"
+    )
+    parser.add_argument(
+        "--port", dest="port", type=int, help="Which port to run the server on"
+    )
+    parser.add_argument(
+        "--storage",
+        dest="storage",
+        help="The method to use for storing data. Some methods (such as MongoDB) require specific Python packages to be available (in the MongoDB case: pymongo)",
+    )
+    parser.add_argument(
+        "--cors-origins",
+        dest="cors_origins",
+        help="CORS origins to allow (as a comma separated list)",
+    )
     args = parser.parse_args()
 
     """ Parse config file """
@@ -74,7 +89,7 @@ def parse_settings():
         if value is not None:
             vars(settings)[key] = value
 
-    settings.cors_origins = [o for o in settings.cors_origins.split(',') if o]
+    settings.cors_origins = [o for o in settings.cors_origins.split(",") if o]
 
     storage_methods = get_storage_methods()
     storage_method = storage_methods[settings.storage]