timedctl 5.2.0__tar.gz → 5.3.0__tar.gz

{timedctl-5.2.0 → timedctl-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: timedctl
-Version: 5.2.0
+Version: 5.3.0
 Summary: CLI for timed
 License: AGPL-3.0-only
 Author: Arthur Deierlein
@@ -35,12 +35,31 @@ People on other distributions can use pip to install the package from pypi:
 $ pip install timedctl
 ```
 
+### Shell completion
+`timedctl` support shell completion for the unaliased commands:
+
+**bash**
+```bash
+_TIMEDCTL_COMPLETE=bash_source timedctl >> ~/.bashrc`
+```
+
+**zsh**
+```bash
+_TIMEDCTL_COMPLETE=zsh_source timedctl >> ~/.zshrc`
+```
+
+**fish**
+```bash
+_TIMEDCTL_COMPLETE=fish_source timedctl >  ~/.config/fish/completions/timedctl.fish`
+```
+
 ## Local development
 Clone the repository and install the dependencies with `poetry install`. You can now run the project with `poetry run timedctl`. For building wheels, you can use `poetry build`.
+Run tests with `poetry run pytest --cov --cov-fail-under 100`.
 
 ## Known issues
 * Make sure to have a polkit-agent running, otherwise the poetry installation during the installation on arch might fail.
-* You need a keyring installed in order for timedctl to store the SSO token, for example `gnome-keyring`. 
+* You need a keyring installed in order for timedctl to store the SSO token, for example `gnome-keyring`.
 
 ## Feature roadmap
 - [x] SSO auth

{timedctl-5.2.0 → timedctl-5.3.0}/README.md

@@ -14,12 +14,31 @@ People on other distributions can use pip to install the package from pypi:
 $ pip install timedctl
 ```
 
+### Shell completion
+`timedctl` support shell completion for the unaliased commands:
+
+**bash**
+```bash
+_TIMEDCTL_COMPLETE=bash_source timedctl >> ~/.bashrc`
+```
+
+**zsh**
+```bash
+_TIMEDCTL_COMPLETE=zsh_source timedctl >> ~/.zshrc`
+```
+
+**fish**
+```bash
+_TIMEDCTL_COMPLETE=fish_source timedctl >  ~/.config/fish/completions/timedctl.fish`
+```
+
 ## Local development
 Clone the repository and install the dependencies with `poetry install`. You can now run the project with `poetry run timedctl`. For building wheels, you can use `poetry build`.
+Run tests with `poetry run pytest --cov --cov-fail-under 100`.
 
 ## Known issues
 * Make sure to have a polkit-agent running, otherwise the poetry installation during the installation on arch might fail.
-* You need a keyring installed in order for timedctl to store the SSO token, for example `gnome-keyring`. 
+* You need a keyring installed in order for timedctl to store the SSO token, for example `gnome-keyring`.
 
 ## Feature roadmap
 - [x] SSO auth

{timedctl-5.2.0 → timedctl-5.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "timedctl"
-version = "5.2.0"
+version = "5.3.0"
 description = "CLI for timed"
 authors = ["Arthur Deierlein <arthur.deierlein@adfinis.com>", "Gian Klug <gian.klug@adfinis.com>"]
 readme = "README.md"
@@ -22,6 +22,8 @@ black = "^23.3.0"
 pytest = "^7.3.2"
 isort = "^5.12.0"
 flake8 = "^6.0.0"
+ruff = "^0.0.282"
+pytest-cov = "^4.1.0"
 
 [build-system]
 requires = ["poetry-core"]
@@ -37,3 +39,16 @@ version_toml = [
 major_on_zero = false
 branch = "main"
 build_command = "pip install poetry && poetry build"
+
+[tool.ruff]
+# TODO: add "ANN" again in the future
+select = ["E", "F", "C4", "PL", "C90", "I", "N", "UP", "B", "S", "A",  "COM", "PT", "Q", "T20", "SLF", "TD", "FIX",  "PIE"]
+# same as black
+line-length = 88
+format = "github"
+fixable = ["ALL"]
+# ignore these for now
+ignore = ["PLR0913"]
+
+[tool.ruff.per-file-ignores]
+"tests/*" = ["S101"]

{timedctl-5.2.0 → timedctl-5.3.0}/timedctl/helpers.py

@@ -1,14 +1,14 @@
+"""
+API unrelated helper functions.
+"""
+import datetime
 import json
-import rich
 import re
-import pyfzf
-import click
-import datetime
 import sys
 
-"""
-API unrelated helper functions.
-"""
+import click
+import pyfzf
+import rich
 
 
 def msg(message, nonl=False):
@@ -70,21 +70,21 @@ def time_sum(arr):
     return str(total)
 
 
-def output_formatted(data, format):
+def output_formatted(data, output_format):
     """Output data in a specified format."""
-    match format:
+    match output_format:
         case "json":
-            print(json.dumps(data, indent=4))
+            rich.print(json.dumps(data, indent=4))
         case "csv":
             keys = data[0].keys()
             output = ",".join(keys) + "\n"
             for obj in data:
                 output += ",".join(obj.values()) + "\n"
-            print(output)
+            rich.print(output)
         case "text":
             for obj in data:
                 for key, val in obj.items():
-                    print(f"[{key}]: {val}, ", end="")
-                print("")
+                    rich.print(f"[{key}]: {val}, ", end="")
+                rich.print("")
         case _:
-            print("Invalid format")
+            rich.print("Invalid format")

{timedctl-5.2.0 → timedctl-5.3.0}/timedctl/timedctl.py

@@ -7,6 +7,7 @@ import re
 
 import click
 import pyfzf
+import requests
 import terminaltables
 import tomllib
 from click_aliases import ClickAliasedGroup
@@ -15,12 +16,12 @@ from libtimed.oidc import OIDCClient
 from tomlkit import dump
 
 from timedctl.helpers import (
-    msg,
     error_handler,
     fzf_wrapper,
+    msg,
+    output_formatted,
     time_picker,
     time_sum,
-    output_formatted,
 )
 
 
@@ -36,17 +37,18 @@ def load_config():
 
     # Get the path to the config file based on the $XDG_config_HOME environment variable
     if not os.getenv("HOME"):
-        raise EnvironmentError("$HOME is not set")
+        raise OSError("$HOME is not set")
 
     xdg_config_home = os.getenv(
-        "XDG_CONFIG_HOME", os.path.join(os.getenv("HOME"), ".config")
+        "XDG_CONFIG_HOME",
+        os.path.join(os.getenv("HOME"), ".config"),
     )
     config_dir = os.path.join(xdg_config_home, "timedctl")
     config_file = os.path.join(config_dir, "config.toml")
 
     if not os.path.isfile(config_file):
         os.makedirs(config_dir, exist_ok=True)
-        print("No config file found. Please enter the following infos.")
+        click.echo("No config file found. Please enter the following infos.")
         for key in cfg:
             cfg[key] = input(f"{key} ({cfg[key]}): ")
         with open(config_file, "w", encoding="utf-8") as file:
@@ -81,7 +83,8 @@ def client_setup():
 def select_report(date):
     """FZF prompt to select a report."""
     reports = timed.reports.get(
-        filters={"date": date}, include="task,task.project,task.project.customer"
+        filters={"date": date},
+        include="task,task.project,task.project.customer",
     )
     report_view = []
     for report in reports:
@@ -93,10 +96,10 @@ def select_report(date):
                 str(report["attributes"]["duration"]),
                 task["id"],
                 report["id"],
-            ]
+            ],
         )
     # get longest key per value
-    max_key_lengths = [max(map(len, col)) for col in zip(*report_view)]
+    max_key_lengths = [max(map(len, col)) for col in zip(*report_view, strict=False)]
     # pad all the values
     report_view = [
         [
@@ -109,7 +112,7 @@ def select_report(date):
     fzf_obj = []
     for row in report_view:
         fzf_obj.append(
-            [" | ".join([row[0], row[1], row[2]]), row[1], row[2], row[3], row[4]]
+            [" | ".join([row[0], row[1], row[2]]), row[1], row[2], row[3], row[4]],
         )
 
     report = fzf_wrapper(fzf_obj, [0], "Select a report: ")
@@ -121,9 +124,9 @@ def select_activity(date):
     activities = timed.activities.get(filters={"date": date})
     activity_view = []
     # loop through all activities
-    for activity in activities:
+    for activity_obj in activities:
         # check if there is an actual task, else use an unknown task
-        task_data = activity["relationships"]["task"]["data"]
+        task_data = activity_obj["relationships"]["task"]["data"]
         if task_data:
             task = timed.tasks.get(id=task_data["id"], cached=True)
         else:
@@ -131,16 +134,16 @@ def select_activity(date):
         activity_view.append(
             [
                 task["attributes"]["name"],
-                activity["attributes"]["comment"],
-                activity["attributes"]["from-time"].strftime("%H:%M:%S")
+                activity_obj["attributes"]["comment"],
+                activity_obj["attributes"]["from-time"].strftime("%H:%M:%S")
                 + " - "
-                + activity["attributes"]["to-time"].strftime("%H:%M:%S"),
+                + activity_obj["attributes"]["to-time"].strftime("%H:%M:%S"),
                 task["id"],
-                activity["id"],
-            ]
+                activity_obj["id"],
+            ],
         )
     # get longest key per value
-    max_key_lengths = [max(map(len, col)) for col in zip(*activity_view)]
+    max_key_lengths = [max(map(len, col)) for col in zip(*activity_view, strict=False)]
     # pad all the values
     activity_view = [
         [
@@ -153,92 +156,190 @@ def select_activity(date):
     fzf_obj = []
     for row in activity_view:
         fzf_obj.append(
-            [" | ".join([row[0], row[1], row[2]]), row[1], row[2], row[3], row[4]]
+            [" | ".join([row[0], row[1], row[2]]), row[1], row[2], row[3], row[4]],
         )
 
-    activity = fzf_wrapper(fzf_obj, [0], "Select an activity: ")
-    return activity
+    activity_obj = fzf_wrapper(fzf_obj, [0], "Select an activity: ")
+    return activity_obj
 
 
-def format_activity(activity):
+def format_activity(activity_obj):
     """Format an activity for display."""
-    task_obj = activity["relationships"]["task"]
+    task_obj = activity_obj["relationships"]["task"]
 
     task = task_obj["attributes"]["name"]
 
     project_obj = timed.projects.get(
-        id=task_obj["relationships"]["project"]["id"], cached=True
+        id=task_obj["relationships"]["project"]["id"],
+        cached=True,
     )
     project = project_obj["attributes"]["name"]
 
     customer_obj = timed.customers.get(
-        id=project_obj["relationships"]["customer"]["data"]["id"], cached=True
+        id=project_obj["relationships"]["customer"]["data"]["id"],
+        cached=True,
     )
     customer = customer_obj["attributes"]["name"]
     return f"{customer} > {project} > {task}"
 
 
+def get_customer_by_name(customers, name, archived):
+    """Get customer by name."""
+    customers = timed.customers.get(cached=True, filters={"archived": archived})
+    customer = [c for c in customers if c["attributes"]["name"] == name]
+    if len(customer) == 0:
+        error_handler("ERR_CUSTOMER_NOT_FOUND")
+    customer_id = customer[0]["id"]
+    return customer_id
+
+
+def get_project_by_name(projects, name, customer_id, archived):
+    """Get project by name."""
+    projects = timed.projects.get(
+        cached=True,
+        filters={"customer": customer_id, "archived": archived},
+    )
+    project = [c for c in projects if c["attributes"]["name"] == name]
+    if len(project) == 0:
+        error_handler("ERR_PROJECT_NOT_FOUND")
+    project_id = project[0]["id"]
+    return project_id
+
+
+def get_task_by_name(tasks, name, project_id, archived):
+    """Get task by name."""
+    tasks = timed.tasks.get(
+        cached=True,
+        filters={"project": project_id, "archived": archived},
+    )
+    task = [c for c in tasks if c["attributes"]["name"] == name]
+    if len(task) == 0:
+        error_handler("ERR_TASK_NOT_FOUND")
+    task_id = task[0]["id"]
+    return task_id
+
+
+def select_task(customer, project, task, show_archived):
+    """Select a task ID with fzf."""
+    # select a customer
+    customers = timed.customers.get(filters={"archived": show_archived}, cached=True)
+    if customer:
+        customer_id = get_customer_by_name(customers, customer, show_archived)
+    else:
+        customer_id = fzf_wrapper(
+            customers,
+            ["attributes", "name"],
+            "Select a customer: ",
+        )["id"]
+    # get projects
+    projects = timed.projects.get(
+        filters={"customer": customer_id, "archived": show_archived},
+        cached=True,
+    )
+    # select a project
+    if project:
+        project_id = get_project_by_name(projects, project, customer_id, show_archived)
+    else:
+        project_id = fzf_wrapper(
+            projects,
+            ["attributes", "name"],
+            "Select a project: ",
+        )["id"]
+    # get tasks
+    tasks = timed.tasks.get(
+        filters={"project": project_id, "archived": show_archived},
+        cached=True,
+    )
+    # select a task
+    if task:
+        task_id = get_task_by_name(tasks, task, project_id, show_archived)
+    else:
+        task_id = fzf_wrapper(tasks, ["attributes", "name"], "Select a task: ")["id"]
+    return task_id
+
+
 timed = client_setup()
 
 
 @click.group(cls=ClickAliasedGroup)
 def timedctl():
     """Use timedctl."""
-    pass  # pylint: disable=W0107
+    # pylint: disable=W0107
 
 
 @timedctl.group(cls=ClickAliasedGroup, aliases=["g", "show", "describe"])
 def get():
     """Get different things."""
-    pass  # pylint: disable=W0107
+    # pylint: disable=W0107
 
 
 @get.group(cls=ClickAliasedGroup)
 def data():
     """Get raw data for building custom scripts."""
-    pass  # pylint: disable=W0107
+    # pylint: disable=W0107
 
 
 @data.command("customers")
-@click.option("--format", default="json", type=click.Choice(["json", "csv", "text"]))
-def get_customers(format):
+@click.option(
+    "--format",
+    "output_format",
+    default="json",
+    type=click.Choice(["json", "csv", "text"]),
+)
+def get_customers(output_format):
     """Get customers."""
     customers = timed.customers.get(cached=True)
-    data = []
+    output = []
     for customer in customers:
-        data.append({"id": customer["id"], "name": customer["attributes"]["name"]})
-    output_formatted(data, format)
+        output.append({"id": customer["id"], "name": customer["attributes"]["name"]})
+    output_formatted(output, output_format)
 
 
 @data.command("projects")
-@click.option("--format", default="json", type=click.Choice(["json", "csv", "text"]))
+@click.option(
+    "--format",
+    "output_format",
+    default="json",
+    type=click.Choice(["json", "csv", "text"]),
+)
 @click.option("--customer-id", default=None, type=int)
 @click.option("--customer-name", default=None, type=str)
-def get_projects(format, customer_id, customer_name):
+@click.option("--archived", default=False, is_flag=True)
+def get_projects(output_format, customer_id, customer_name, archived):
     """Get projects."""
     if not (customer_id or customer_name):
         error_handler("ERR_MISSING_ARGUMENTS")
     # Get customer ID if name is specified
     if not customer_id:
         customers = timed.customers.get(cached=True)
-        customer = [c for c in customers if c["attributes"]["name"] == customer_name]
-        if len(customer) == 0:
-            error_handler("ERR_CUSTOMER_NOT_FOUND")
-        customer_id = customer[0]["id"]
+        customer_id = get_customer_by_name(customers, customer_name, archived)
     projects = timed.projects.get(cached=True, filters={"customer": customer_id})
-    data = []
+    output = []
     for project in projects:
-        data.append({"id": project["id"], "name": project["attributes"]["name"]})
-    output_formatted(data, format)
+        output.append({"id": project["id"], "name": project["attributes"]["name"]})
+    output_formatted(output, output_format)
 
 
 @data.command("tasks")
-@click.option("--format", default="json", type=click.Choice(["json", "csv", "text"]))
+@click.option(
+    "--format",
+    "output_format",
+    default="json",
+    type=click.Choice(["json", "csv", "text"]),
+)
 @click.option("--customer-id", default=None, type=int)
 @click.option("--customer-name", default=None, type=str)
 @click.option("--project-id", default=None, type=int)
 @click.option("--project-name", default=None, type=str)
-def get_tasks(format, customer_id, customer_name, project_id, project_name):
+@click.option("--archived", default=False, is_flag=True)
+def get_tasks(
+    output_format,
+    customer_id,
+    customer_name,
+    project_id,
+    project_name,
+    archived,
+):
     """Get tasks."""
     if project_name and not (customer_id or customer_name):
         error_handler("ERR_CUSTOMER_INFO_MISSING")
@@ -249,24 +350,16 @@ def get_tasks(format, customer_id, customer_name, project_id, project_name):
         # we need an id for the customer
         if not customer_id:
             customers = timed.customers.get(cached=True)
-            customer = [
-                c for c in customers if c["attributes"]["name"] == customer_name
-            ]
-            if len(customer) == 0:
-                error_handler("ERR_CUSTOMER_NOT_FOUND")
-            customer_id = customer[0]["id"]
+            customer_id = get_customer_by_name(customers, customer_name, archived)
         # get the project id
         projects = timed.projects.get(cached=True, filters={"customer": customer_id})
-        project = [c for c in projects if c["attributes"]["name"] == project_name]
-        if len(project) == 0:
-            error_handler("ERR_PROJECT_NOT_FOUND")
-        project_id = project[0]["id"]
+        project_id = get_project_by_name(projects, project_name, customer_id, archived)
     # get the tasks for the specified project
     tasks = timed.tasks.get(cached=True, filters={"project": project_id})
-    data = []
+    output = []
     for task in tasks:
-        data.append({"id": task["id"], "name": task["attributes"]["name"]})
-    output_formatted(data, format)
+        output.append({"id": task["id"], "name": task["attributes"]["name"]})
+    output_formatted(output, output_format)
 
 
 @get.command("overtime", aliases=["t", "ot", "undertime"])
@@ -275,7 +368,7 @@ def get_overtime(date):
     """Get overtime of user."""
     user = timed.users.me["id"]
     overtime = timed.overtime.get({"user": user, "date": date})
-    msg(f"Currrent overtime is: {overtime}")
+    msg(f"Current overtime is: {overtime}")
 
 
 @get.command("reports", aliases=["report", "r"])
@@ -283,32 +376,23 @@ def get_overtime(date):
 def get_reports(date):
     """Get reports."""
     reports = timed.reports.get(
-        filters={"date": date}, include="task,task.project,task.project.customer"
+        filters={"date": date},
+        include="task,task.project,task.project.customer",
     )
     table = [["Customer", "Project", "Task", "Comment", "Duration"]]
     for report in reports:
         task_obj = report["relationships"]["task"]
-        task = task_obj["attributes"]["name"]
-
-        project_obj = timed.projects.get(
-            id=task_obj["relationships"]["project"]["id"], cached=True
+        project_obj = task_obj["relationships"]["project"]
+        customer_obj = project_obj["relationships"]["customer"]
+        # get name attributes
+        task, project, customer = (
+            x["attributes"]["name"] for x in [task_obj, project_obj, customer_obj]
         )
-        project = project_obj["attributes"]["name"]
+        comment = report["attributes"]["comment"]
+        duration = report["attributes"]["duration"]
 
-        customer_obj = timed.customers.get(
-            id=project_obj["relationships"]["customer"]["data"]["id"], cached=True
-        )
-        customer = customer_obj["attributes"]["name"]
-
-        table.append(
-            [
-                customer,
-                project,
-                task,
-                report["attributes"]["comment"],
-                report["attributes"]["duration"],
-            ]
-        )
+        table.append([customer, project, task, comment, duration])
+    # create the output
     output = terminaltables.SingleTable(table)
     msg(f"Reports for {date if date is not None else 'today'}:")
     click.echo(output.table)
@@ -333,7 +417,7 @@ def get_activities(date):
                 activity_obj["attributes"]["to-time"].strftime("%H:%M:%S")
                 if activity_obj["attributes"]["to-time"] is not None
                 else "active",
-            ]
+            ],
         )
     output = terminaltables.SingleTable(table)
     msg(f"Activities for {date if date is not None else 'today'}:")
@@ -343,12 +427,13 @@ def get_activities(date):
 @get.command("absences", aliases=["abs"])
 def get_absences():
     """Get absences."""
+    error_handler("ERR_NOT_IMPLEMENTED")
 
 
 @timedctl.group(cls=ClickAliasedGroup, aliases=["rm", "d", "remove", "del"])
 def delete():
     """Delete different things."""
-    pass  # pylint: disable=W0107
+    # pylint: disable=W0107
 
 
 @delete.command("report", aliases=["r"])
@@ -357,11 +442,12 @@ def delete_report(date):
     """Delete report(s)."""
     report = select_report(date)
     res = pyfzf.FzfPrompt().prompt(
-        ["Yes", "No"], f"--prompt 'Are you sure? Delete \"{report[1]}\"?'"
+        ["Yes", "No"],
+        f"--prompt 'Are you sure? Delete \"{report[1]}\"?'",
     )
     if res[0] == "Yes":
         req = timed.reports.delete(report[-1])
-        if req.status_code == 204:
+        if req.status_code == requests.codes["no_content"]:
             msg(f'Deleted report "{report[1]}"')
         else:
             error_handler("ERR_DELETION_FAILED")
@@ -384,7 +470,7 @@ def delete_absence():
 @timedctl.group(cls=ClickAliasedGroup, aliases=["a", "create"])
 def add():
     """Add different things."""
-    pass  # pylint: disable=W0107
+    # pylint: disable=W0107
 
 
 @add.command("report", aliases=["r"])
@@ -395,44 +481,16 @@ def add():
 @click.option("--duration", default=None)
 @click.option("--show-archived", default=False, is_flag=True)
 def add_report(
-    customer, project, task, description, duration, show_archived
-):  # pylint: disable=R0912
+    customer,
+    project,
+    task,
+    description,
+    duration,
+    show_archived,
+):  # ruff: noqa: PLR0913
     """Add report(s)."""
-    # ask the user to select a customer
-    msg("Select a customer")
-    # select a customer
-    customers = timed.customers.get(filters={"archived": show_archived}, cached=True)
-    if customer:
-        customer = [c for c in customers if c["attributes"]["name"] == customer]
-        if len(customer) == 0:
-            error_handler("ERR_CUSTOMER_NOT_FOUND")
-        customer = customer[0]
-    else:
-        customer = fzf_wrapper(customers, ["attributes", "name"], "Select a customer: ")
-    # get projects
-    projects = timed.projects.get(
-        filters={"customer": customer["id"], "archived": show_archived}, cached=True
-    )
-    # select a project
-    if project:
-        project = [p for p in projects if p["attributes"]["name"] == project]
-        if len(project) == 0:
-            error_handler("ERR_PROJECT_NOT_FOUND")
-        project = project[0]
-    else:
-        project = fzf_wrapper(projects, ["attributes", "name"], "Select a project: ")
-    # get tasks
-    tasks = timed.tasks.get(
-        filters={"project": project["id"], "archived": show_archived}, cached=True
-    )
     # select a task
-    if task:
-        task = [t for t in tasks if t["attributes"]["name"] == task]
-        if len(task) == 0:
-            error_handler("ERR_TASK_NOT_FOUND")
-        task = task[0]
-    else:
-        task = fzf_wrapper(tasks, ["attributes", "name"], "Select a task: ")
+    task_id = select_task(customer, project, task, show_archived)
     # ask the user to enter a description
     if not description:
         msg("Enter a description")
@@ -448,10 +506,10 @@ def add_report(
     res = timed.reports.post(
         {"duration": duration, "comment": description},
         {
-            "task": task["id"],
+            "task": task_id,
         },
     )
-    if res.status_code == 201:
+    if res.status_code == requests.codes["created"]:
         msg("Report created successfully")
         return
     # handle exception
@@ -473,7 +531,7 @@ def add_absence():
 @timedctl.group(cls=ClickAliasedGroup, aliases=["e", "edit", "update"])
 def edit():
     """Edit different things."""
-    pass  # pylint: disable=W0107
+    # pylint: disable=W0107
 
 
 @edit.command("report", aliases=["r"])
@@ -488,9 +546,11 @@ def edit_report(date):
     res = pyfzf.FzfPrompt().prompt(["No", "Yes"], "--prompt 'Are you sure?'")
     if res == ["Yes"]:
         res = timed.reports.patch(
-            report[-1], {"comment": comment, "duration": duration}, {"task": report[-2]}
+            report[-1],
+            {"comment": comment, "duration": duration},
+            {"task": report[-2]},
         )
-        if res.status_code == 200:
+        if res.status_code == requests.codes["ok"]:
             msg("Report updated successfully")
             return
         # handle exception
@@ -514,7 +574,7 @@ def edit_absence():
 @timedctl.group(cls=ClickAliasedGroup, aliases=["ac"])
 def activity():
     """Do stuff with activities."""
-    pass  # pylint: disable=W0107
+    # pylint: disable=W0107
 
 
 @activity.command("start", aliases=["add", "a"])
@@ -525,47 +585,14 @@ def activity():
 @click.option("--show-archived", default=False, is_flag=True)
 def start_activity(comment, customer, project, task, show_archived):
     """Start recording activity."""
-    customers = timed.customers.get(filters={"archived": show_archived}, cached=True)
-    # ask the user to select a customer
-    msg("Select a customer")
-    # select a customer
-    if customer:
-        customer = [c for c in customers if c["attributes"]["name"] == customer]
-        if len(customer) == 0:
-            error_handler("ERR_CUSTOMER_NOT_FOUND")
-        customer = customer[0]
-    else:
-        customer = fzf_wrapper(customers, ["attributes", "name"], "Select a customer: ")
-    # get projects
-    projects = timed.projects.get(
-        filters={"customer": customer["id"], "archived": show_archived}, cached=True
-    )
-    # select a project
-    if project:
-        project = [p for p in projects if p["attributes"]["name"] == project]
-        if len(project) == 0:
-            error_handler("ERR_PROJECT_NOT_FOUND")
-        project = project[0]
-    else:
-        project = fzf_wrapper(projects, ["attributes", "name"], "Select a project: ")
-    # get tasks
-    tasks = timed.tasks.get(
-        filters={"project": project["id"], "archived": show_archived}, cached=True
-    )
-    # select a task
-    if task:
-        task = [t for t in tasks if t["attributes"]["name"] == task]
-        if len(task) == 0:
-            error_handler("ERR_TASK_NOT_FOUND")
-        task = task[0]
-    else:
-        task = fzf_wrapper(tasks, ["attributes", "name"], "Select a task: ")
+    task_id = select_task(customer, project, task, show_archived)
     # create the activity
     res = timed.activities.start(
-        attributes={"comment": comment}, relationships={"task": task["id"]}
+        attributes={"comment": comment},
+        relationships={"task": task_id},
     )
 
-    if res.status_code == 201:
+    if res.status_code == requests.codes["created"]:
         msg(f"Activity {comment} started successfully.")
         return
     # handle exception
@@ -586,17 +613,17 @@ def stop_activity():
 @click.option("--short", default=False, is_flag=True)
 def show_activity(short):
     """Show current activity."""
-    # TODO: Fix in libtimed so the full object gets returned
-    current_activity = timed.activities.get(
-        filters={"id": timed.activities.current["id"]},
-        include="task,task.project,task.project.customer",
-    )[0]
-    comment = " > " + current_activity["attributes"]["comment"] if not short else ""
-    start = current_activity["attributes"]["from-time"].strftime("%H:%M:%S")
+    current_activity = timed.activities.current
     if current_activity:
+        activity_obj = timed.activities.get(
+            filters={"id": current_activity["id"]},
+            include="task,task.project,task.project.customer",
+        )[0]
+        comment = " > " + activity_obj["attributes"]["comment"] if not short else ""
+        start = activity_obj["attributes"]["from-time"].strftime("%H:%M:%S")
         msg(
-            f"Current activity: {format_activity(current_activity)}{comment} (Since "
-            + f"{start})"
+            f"Current activity: {format_activity(activity_obj)}{comment} (Since "
+            + f"{start})",
         )
     else:
         error_handler("ERR_NO_CURRENT_ACTIVITY")
@@ -611,14 +638,15 @@ def restart_activity(date):
         timed.activities.stop()
         msg("Stopped current activity.")
     # select an activity
-    activity = select_activity(date)
+    activity_obj = select_activity(date)
     # grab attributes
-    comment = activity[1]
-    task_id = activity[3]
+    comment = activity_obj[1]
+    task_id = activity_obj[3]
     res = timed.activities.start(
-        attributes={"comment": comment}, relationships={"task": task_id}
+        attributes={"comment": comment},
+        relationships={"task": task_id},
     )
-    if res.status_code == 201:
+    if res.status_code == requests.codes["created"]:
         msg(f'Activity "{comment}" restarted successfully.')
         return
     # handle exception
@@ -630,9 +658,9 @@ def restart_activity(date):
 def delete_activity(date):
     """Delete an activity."""
     # select an activity
-    activity = select_activity(date)
-    if timed.activities.delete(activity[-1]):
-        msg(f"Activity {activity[1]} deleted successfully.")
+    activity_obj = select_activity(date)
+    if timed.activities.delete(activity_obj[-1]):
+        msg(f"Activity {activity_obj[1]} deleted successfully.")
         return
     error_handler("ERR_ACTIVITY_DELETE_FAILED")
 
@@ -665,10 +693,12 @@ def activity_generate_timesheet():
                     report = report[0]
                     # deserialize the timedelta
                     hours, minutes, seconds = report["attributes"]["duration"].split(
-                        ":"
+                        ":",
                     )
                     old_duration = datetime.timedelta(
-                        hours=int(hours), minutes=int(minutes), seconds=int(seconds)
+                        hours=int(hours),
+                        minutes=int(minutes),
+                        seconds=int(seconds),
                     )
                     # calculate the new duration
                     report["attributes"]["duration"] = old_duration + duration
@@ -680,7 +710,7 @@ def activity_generate_timesheet():
                     )
                 else:
                     # create report
-                    r = timed.reports.post(
+                    res = timed.reports.post(
                         {
                             "duration": duration,
                             "comment": attr["comment"],
@@ -688,7 +718,7 @@ def activity_generate_timesheet():
                         {"task": task},
                     )
                     # append the report to the known reports
-                    reports.append(r.json()["data"])
+                    reports.append(res.json()["data"])
                 # update activity to be transferred
                 attr["transferred"] = True
                 timed.activities.patch(activity_obj["id"], attr, {"task": task})