Repository: potassco/clinguin (language: python)

Issue:
Linted Code Base
- Linted the code base according to the suggestions from [python-project-template (potassco)](https://github.com/krr-up/python-project-template)
- In more detail with: autoflake, isort and black
- Added relevant sections in the `noxfile.py`
- Tiny improvement of basic test documentation


Discussion / hints:
Should we add sesions in nox like:

```
@nox.session
def lint_flake8(session):
    session.install("-e", ".[lint_flake8]")
    session.run("flake8", "src", "tests")


@nox.session
def lint_pylint(session):
    session.install("-e", ".[lint_pylint]")
    session.run("pylint", "clingexplaid", "tests")    
```

to get the linting checked with nox?

Fix patch:
diff --git a/.flake8 b/.flake8
new file mode 100644
index 00000000..8445db0a
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,6 @@
+[flake8]
+max-line-length = 120
+exclude =
+    .git
+    .github
+ignore = E741 W503 E203 E126 E121
diff --git a/.github/workflows/pip_installation_check.yml b/.github/workflows/pip_installation_check.yml
index 3fc857b1..306befc3 100644
--- a/.github/workflows/pip_installation_check.yml
+++ b/.github/workflows/pip_installation_check.yml
@@ -72,7 +72,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: ['ubuntu-latest','windows-latest','macos-latest']
+        os: ['ubuntu-latest']
 
     steps:
     - name: "checkout repository"
@@ -89,5 +89,54 @@ jobs:
         python -m pip install ./[test]
 
     - name: run tests
-      run: nox
+      run: nox -e test
+
+
+  lint_flake8:
+    name: lint flake8 on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ['ubuntu-latest']
+
+    steps:
+    - name: "checkout repository"
+      uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+    - name: Install Clinguin
+      run: |
+        python -m pip install ./[lint_flake8]
+
+    - name: run flake8
+      run: nox -e lint_flake8
+
+  lint_pylint:
+    name: lint pylint on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ['ubuntu-latest']
 
+    steps:
+    - name: "checkout repository"
+      uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+    - name: Install Clinguin
+      run: |
+        python -m pip install ./[lint_pylint]
+    - name: run pylint
+      run: nox -e lint_pylint
diff --git a/.pylintrc b/.pylintrc
new file mode 100644
index 00000000..ddf87f5a
--- /dev/null
+++ b/.pylintrc
@@ -0,0 +1,34 @@
+[FORMAT]
+
+max-line-length=120
+
+[DESIGN]
+
+max-args=10
+max-attributes=7
+max-bool-expr=5
+max-branches=12
+max-locals=30
+max-parents=7
+max-public-methods=20
+max-returns=10
+max-statements=50
+min-public-methods=1
+
+[SIMILARITIES]
+
+ignore-comments=yes
+ignore-docstrings=yes
+ignore-imports=yes
+ignore-signatures=yes
+
+[BASIC]
+
+argument-rgx=^[a-z][a-z0-9]*((_[a-z0-9]+)*_?)?$
+variable-rgx=^[a-z][a-z0-9]*((_[a-z0-9]+)*_?)?$
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=_,M,N,B,A,Nn,Bn,An
+
+[MESSAGE CONTROL]
+disable=W0719,W0122,C0206,C0201,W0718,R0902
diff --git a/clinguin/__init__.py b/clinguin/__init__.py
index 5e754c5e..1bef32e1 100644
--- a/clinguin/__init__.py
+++ b/clinguin/__init__.py
@@ -5,17 +5,13 @@
 import sys
 import threading
 from datetime import datetime
-from re import X
-from subprocess import Popen
-
-from clinguin.utils import Logger
 
 from .client_helper import start as client_start
 from .parse_input import ArgumentParser
 from .server_helper import start as server_start
 
 
-def argsToDictConvert(args_dict, timestamp, name_prefix=""):
+def args_to_dict_converter(args_dict, timestamp, name_prefix=""):
     """
     Converts the ''external-logger-config'' representation into an internal one
     """
@@ -50,7 +46,7 @@ def main():
     timestamp = datetime.now().strftime("%Y-%m-%d::%H:%M:%S")
 
     if args.process == "server":
-        log_dict = argsToDictConvert(args_dict, timestamp)
+        log_dict = args_to_dict_converter(args_dict, timestamp)
 
         args_copy = copy.deepcopy(args)
         args_copy.log_args = log_dict
@@ -58,7 +54,7 @@ def main():
         server.start()
 
     elif args.process == "client":
-        log_dict = argsToDictConvert(args_dict, timestamp)
+        log_dict = args_to_dict_converter(args_dict, timestamp)
 
         args_copy = copy.deepcopy(args)
         args_copy.log_args = log_dict
@@ -66,14 +62,18 @@ def main():
         client_start(args_copy)
 
     elif args.process == "client-server":
-        server_log_dict = argsToDictConvert(args_dict, timestamp, name_prefix="server_")
+        server_log_dict = args_to_dict_converter(
+            args_dict, timestamp, name_prefix="server_"
+        )
         args_copy = copy.deepcopy(args)
         args_copy.log_args = server_log_dict
 
         server = threading.Thread(target=server_start, args=[args_copy])
         server.start()
 
-        client_log_dict = argsToDictConvert(args_dict, timestamp, name_prefix="client_")
+        client_log_dict = args_to_dict_converter(
+            args_dict, timestamp, name_prefix="client_"
+        )
 
         args_copy = copy.deepcopy(args)
         args_copy.log_args = client_log_dict
diff --git a/clinguin/client/api/api.py b/clinguin/client/api/api.py
index 64ca32ff..f106e11a 100644
--- a/clinguin/client/api/api.py
+++ b/clinguin/client/api/api.py
@@ -24,6 +24,9 @@ def __init__(self, base_url="http://127.0.0.1:8000/"):
         self.base_url = base_url
 
     def get(self, endpoint):
+        """
+        Used for get requests.
+        """
         try:
             self._logger.info("<-- GET to %s%s", str(self.base_url), str(endpoint))
             r = httpx.get(self.base_url + endpoint, timeout=10000)
@@ -39,6 +42,9 @@ def get(self, endpoint):
             return (-2, "")
 
     def post(self, endpoint, body: FrontendPolicyDto):
+        """
+        Used for post requests.
+        """
         try:
             self._logger.info(
                 "<-- POST to %s%s   %s",
diff --git a/clinguin/client/api/frontend_policy_dto.py b/clinguin/client/api/frontend_policy_dto.py
index 8d7f08bf..71b45d80 100644
--- a/clinguin/client/api/frontend_policy_dto.py
+++ b/clinguin/client/api/frontend_policy_dto.py
@@ -12,5 +12,8 @@ class FrontendPolicyDto:
     def __init__(self, function):
         self.function = function
 
-    def to_JSON(self):
+    def to_JSON(self):  # pylint: disable=C0103
+        """
+        Converts DTO (self) to JSON.
+        """
         return json.dumps(self, default=lambda o: o.__dict__)
diff --git a/clinguin/client/application/client_base.py b/clinguin/client/application/client_base.py
index 3247041f..fead2a92 100644
--- a/clinguin/client/application/client_base.py
+++ b/clinguin/client/application/client_base.py
@@ -11,7 +11,9 @@
 
 class ClientBase:
     """
-    ClientBase is the ''base'' of the client. It contains the logic which is responsible for connecting to the server, what to do in case of errors, forward the Json to the correct GUI, etc.
+    ClientBase is the ''base'' of the client.
+    It contains the logic which is responsible for connecting to the server,
+    what to do in case of errors, forward the Json to the correct GUI, etc.
     """
 
     endpoint_health = "health"
@@ -27,6 +29,9 @@ def __init__(self, args):
         self.frontend_generator = args.frontend(self, args)
 
     def start_up(self):
+        """
+        Code executed on first startup.
+        """
         self.connect()
         (status_code, response) = self.api.get("")
         if status_code == 200:
@@ -39,6 +44,9 @@ def start_up(self):
             self.connect()
 
     def connect(self):
+        """
+        Connect/reconnect to server.
+        """
         while not self.connected:
             (status_code, _) = self.api.get(self.endpoint_health)
 
@@ -49,12 +57,17 @@ def connect(self):
                 time.sleep(1)
 
     def draw(self, response):
+        """
+        Draws the GUI.
+        """
         self.base_engine(response)
         self.frontend_generator.draw_postprocessing(response["children"][0]["id"])
 
     def base_engine(self, response):
         """
-        Handles the response of the server to draw the GUI. For this it iterates through the received Json/Dict in a top-down preorder fashion.
+        Handles the response of the server to draw the GUI.
+        For this it iterates through the received Json/Dict
+        in a top-down preorder fashion.
 
         Parameters:
             response (dict): Json from which one can draw the GUI.
@@ -85,6 +98,9 @@ def base_engine(self, response):
                 self._logger.error("Could not find element type: %s", child["type"])
 
     def post_with_policy(self, click_policy):
+        """
+        Prepare post request for API.
+        """
         (status_code, json) = self.api.post("backend", FrontendPolicyDto(click_policy))
         if status_code == 200:
             self.draw(json)
diff --git a/clinguin/client/presentation/abstract_frontend.py b/clinguin/client/presentation/abstract_frontend.py
index 3ad40727..6e4d0990 100644
--- a/clinguin/client/presentation/abstract_frontend.py
+++ b/clinguin/client/presentation/abstract_frontend.py
@@ -1,3 +1,4 @@
+# pylint: disable=R0801
 """
 Module that contains the class AbstractFrontend.
 """
@@ -8,7 +9,8 @@
 
 class AbstractFrontend(CustomArgs):
     """
-    Superclass from where every specialized gui class inherits from (e.g. TkinterFrontend). Defines the available elements.
+    Superclass from where every specialized gui class inherits from (e.g. TkinterFrontend).
+    Defines the available elements.
     """
 
     def __init__(self, base_engine, args):
@@ -18,13 +20,19 @@ def __init__(self, base_engine, args):
 
     @classmethod
     def available_syntax(cls, show_level):
+        """
+        Shows the available syntax for the chosen frontend.
+        """
         print(show_level)
         return ""
 
-    def window(self, id, parent, attributes, callbacks):
+    def window(self, cid, parent, attributes, callbacks):
+        """
+        Window placeholder.
+        """
         print(
             "WINDOW: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -33,10 +41,13 @@ def window(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def container(self, id, parent, attributes, callbacks):
+    def container(self, cid, parent, attributes, callbacks):
+        """
+        Container placeholder.
+        """
         print(
             "CONTAINER: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -45,10 +56,13 @@ def container(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def dropdown_menu(self, id, parent, attributes, callbacks):
+    def dropdown_menu(self, cid, parent, attributes, callbacks):
+        """
+        Dropdown-Menu placeholder.
+        """
         print(
             "DROPDOWNMENU: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -57,10 +71,13 @@ def dropdown_menu(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def dropdown_menu_item(self, id, parent, attributes, callbacks):
+    def dropdown_menu_item(self, cid, parent, attributes, callbacks):
+        """
+        Dropdown-menu-item placeholder.
+        """
         print(
             "DROPDOWNMENUITEM: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -69,10 +86,13 @@ def dropdown_menu_item(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def label(self, id, parent, attributes, callbacks):
+    def label(self, cid, parent, attributes, callbacks):
+        """
+        Label placeholder.
+        """
         print(
             "LABEL: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -81,10 +101,13 @@ def label(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def button(self, id, parent, attributes, callbacks):
+    def button(self, cid, parent, attributes, callbacks):
+        """
+        Button placeholder.
+        """
         print(
             "BUTTON: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -93,10 +116,13 @@ def button(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def menu_bar(self, id, parent, attributes, callbacks):
+    def menu_bar(self, cid, parent, attributes, callbacks):
+        """
+        Menu-Bar placeholder.
+        """
         print(
             "MENUBAR: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -105,10 +131,13 @@ def menu_bar(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def menu_bar_section(self, id, parent, attributes, callbacks):
+    def menu_bar_section(self, cid, parent, attributes, callbacks):
+        """
+        Menu-Bar-Section placeholder.
+        """
         print(
             "MENUBARSECTION: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -117,10 +146,13 @@ def menu_bar_section(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def menu_bar_section_item(self, id, parent, attributes, callbacks):
+    def menu_bar_section_item(self, cid, parent, attributes, callbacks):
+        """
+        Menu-Bar-Section-item placeholder.
+        """
         print(
             "MENUBARSECTIONITEM: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -129,10 +161,13 @@ def menu_bar_section_item(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def message(self, id, parent, attributes, callbacks):
+    def message(self, cid, parent, attributes, callbacks):
+        """
+        Message placeholder.
+        """
         print(
             "MESSAGE: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -141,10 +176,13 @@ def message(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def canvas(self, id, parent, attributes, callbacks):
+    def canvas(self, cid, parent, attributes, callbacks):
+        """
+        Canvas placeholder.
+        """
         print(
             "CANVAS: "
-            + str(id)
+            + str(cid)
             + "::"
             + str(parent)
             + "::"
@@ -153,8 +191,14 @@ def canvas(self, id, parent, attributes, callbacks):
             + str(callbacks)
         )
 
-    def draw_postprocessing(self, id):
-        print("DRAW POSTPROCESSING")
-
-    def draw(self, id):
-        print("DRAW" + "::" + str(id))
+    def draw_postprocessing(self, cid):
+        """
+        Draw postprocessing placeholder.
+        """
+        print("DRAW POSTPROCESSING" + "::" + str(cid))
+
+    def draw(self, cid):
+        """
+        Draw placeholder.
+        """
+        print("DRAW" + "::" + str(cid))
diff --git a/clinguin/client/presentation/frontends/ipython_frontend/ipython_frontend.py b/clinguin/client/presentation/frontends/ipython_frontend/ipython_frontend.py
index b540634c..9424599b 100644
--- a/clinguin/client/presentation/frontends/ipython_frontend/ipython_frontend.py
+++ b/clinguin/client/presentation/frontends/ipython_frontend/ipython_frontend.py
@@ -1,3 +1,4 @@
+# pylint: disable=R0801
 """
 Module that contains the IPythonFrontendClass
 """
@@ -17,32 +18,113 @@ def __init__(self, base_engine, args):
     def register_options(cls, parser):
         parser.description = "This GUI is based on the ipython library."
 
-    def window(self, id, parent, attributes, callbacks):
-        print("IPython - WINDOW: " + str(id) + "::" + str(parent))
+    def window(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - WINDOW: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def container(self, id, parent, attributes, callbacks):
-        print("IPython - CONTAINER: " + str(id) + "::" + str(parent))
+    def container(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - CONTAINER: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def dropdown_menu(self, id, parent, attributes, callbacks):
-        print("IPython - DROPDOWNMENU: " + str(id) + "::" + str(parent))
+    def dropdown_menu(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - DROPDOWNMENU: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def dropdown_menu_item(self, id, parent, attributes, callbacks):
-        print("IPython - DROPDOWNMENUITEM: " + str(id) + "::" + str(parent))
+    def dropdown_menu_item(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - DROPDOWNMENUITEM: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def label(self, id, parent, attributes, callbacks):
-        print("IPython - LABEL: " + str(id) + "::" + str(parent))
+    def label(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - LABEL: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def button(self, id, parent, attributes, callbacks):
-        print("IPython - BUTTON: " + str(id) + "::" + str(parent))
+    def button(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - BUTTON: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def menu_bar(self, id, parent, attributes, callbacks):
-        print("IPython - MENUBAR: " + str(id) + "::" + str(parent))
+    def menu_bar(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - MENUBAR: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def menu_bar_section(self, id, parent, attributes, callbacks):
-        print("IPython - MENUBARSECTION: " + str(id) + "::" + str(parent))
+    def menu_bar_section(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - MENUBARSECTION: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def menu_bar_section_item(self, id, parent, attributes, callbacks):
-        print("IPython - MENUBARSECTIONITEM: " + str(id) + "::" + str(parent))
+    def menu_bar_section_item(self, cid, parent, attributes, callbacks):
+        print(
+            "IPython - MENUBARSECTIONITEM: "
+            + str(cid)
+            + "::"
+            + str(parent)
+            + "::"
+            + str(attributes)
+            + "::"
+            + str(callbacks)
+        )
 
-    def draw(self, id):
-        print("IPython - DRAW: " + str(id))
+    def draw(self, cid):
+        print("IPython - DRAW: " + str(cid))
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/button.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/button.py
index 3b1386d4..f0f602df 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/button.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/button.py
@@ -1,20 +1,40 @@
+# pylint: disable=R0801
 """
 This module contains the button class.
 """
 import tkinter as tk
 
-from .root_cmp import *
+from clinguin.utils.attribute_types import (
+    BooleanType,
+    ColorType,
+    StringType,
+    SymbolType,
+)
+
+from ..tkinter_utils import (
+    AttributeNames,
+    CallbackNames,
+    ConfigureFont,
+    ConfigureSize,
+    ConfigureTextElementSize,
+    LayoutFollower,
+)
+from .root_cmp import RootCmp
 
 
 class Button(
     RootCmp, LayoutFollower, ConfigureSize, ConfigureFont, ConfigureTextElementSize
 ):
     """
-    A button is a element, which is generally regarded as an active element, so actions are executed. For available attributes see syntax definition. Implementation wise it is similarly implemented as the Label and Dropdownmenu - to make it work for layouting, the actual button is hidden the the element is actually a tkinter frame (therefore self._element is a frame, whereas self._button is the button).
+    A button is a element, which is generally regarded as an active element,
+    so actions are executed. For available attributes see syntax definition.
+    Implementation wise it is similarly implemented as the Label and Dropdownmenu -
+    to make it work for layouting, the actual button is hidden the the element is actually
+    a tkinter frame (therefore self._element is a frame, whereas self._button is the button).
     """
 
-    def __init__(self, args, id, parent, attributes, callbacks, base_engine):
-        super().__init__(args, id, parent, attributes, callbacks, base_engine)
+    def __init__(self, args, cid, parent, attributes, callbacks, base_engine):
+        super().__init__(args, cid, parent, attributes, callbacks, base_engine)
 
         self._button = None
 
@@ -70,14 +90,17 @@ def _get_callbacks(cls, callbacks=None):
     # ----------------------------------------------------------------------------------------------
 
     def _set_label_text(self, elements):
+        self._logger.debug(str(elements))
         text = self._attributes[AttributeNames.label]["value"]
         self._button.configure(text=text)
 
     def _set_background_color(self, elements, key=AttributeNames.backgroundcolor):
+        self._logger.debug(str(elements))
         value = self._attributes[key]["value"]
         self._button.configure(background=value)
 
     def _set_foreground_color(self, elements, key=AttributeNames.foregroundcolor):
+        self._logger.debug(str(elements))
         value = self._attributes[key]["value"]
         self._button.configure(foreground=value)
 
@@ -94,6 +117,7 @@ def _set_on_hover(self, elements):
         if on_hover:
 
             def enter(event):
+                self._logger.debug(str(event))
                 if on_hover_background_color != "":
                     self._set_background_color(
                         elements, key=AttributeNames.onhover_background_color
@@ -104,6 +128,7 @@ def enter(event):
                     )
 
             def leave(event):
+                self._logger.debug(str(event))
                 self._set_background_color(elements)
                 self._set_foreground_color(elements)
 
@@ -115,13 +140,15 @@ def leave(event):
     # ----------------------------------------------------------------------------------------------
 
     def _define_click_event(self, elements):
+        self._logger.debug(str(elements))
         key = CallbackNames.click
         if self._callbacks[key] and self._callbacks[key]["policy"]:
 
-            def clickEvent(event):
+            def click_event(event):
+                self._logger.debug(str(event))
                 self._base_engine.post_with_policy(self._callbacks[key]["policy"])
 
-            self._button.bind("<Button-1>", clickEvent)
+            self._button.bind("<Button-1>", click_event)
 
     def _add_component_to_elements(self, elements):
         self._button.pack(expand=True, fill="both")
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/canvas.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/canvas.py
index 13fa4bc2..71c98926 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/canvas.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/canvas.py
@@ -8,16 +8,23 @@
 import PIL.Image as TImage
 from PIL import ImageTk
 
-from .root_cmp import *
+from clinguin.utils.attribute_types import BooleanType, ImageType, PathType
+
+from ..tkinter_utils import AttributeNames, ConfigureSize, LayoutFollower
+from .root_cmp import RootCmp
 
 
 class Canvas(RootCmp, LayoutFollower, ConfigureSize):
     """
-    The canvas class resembles a element, which is generally regarded as an ''empty sheet of paper'', so there is an area, where one can display images, draw something or does something similar. One can look up what actual options are available through the syntax-definition. Implementation wise it is similarly implemented to the label, button and dropdownmenu.
+    The canvas class resembles a element,
+    which is generally regarded as an ''empty sheet of paper'',
+    so there is an area, where one can display images, draw something or does something similar.
+    One can look up what actual options are available through the syntax-definition.
+    Implementation wise it is similarly implemented to the label, button and dropdownmenu.
     """
 
-    def __init__(self, args, id, parent, attributes, callbacks, base_engine):
-        super().__init__(args, id, parent, attributes, callbacks, base_engine)
+    def __init__(self, args, cid, parent, attributes, callbacks, base_engine):
+        super().__init__(args, cid, parent, attributes, callbacks, base_engine)
 
         self._canvas = None
         self._image = None
@@ -40,6 +47,8 @@ def _get_attributes(cls, attributes=None):
         return attributes
 
     def _set_image(self, elements):
+        self._logger.debug(str(elements))
+
         image_base64 = self._attributes[AttributeNames.image]["value"]
         image_file = self._attributes[AttributeNames.image_path]["value"]
 
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/container.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/container.py
index eff21106..ac94186d 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/container.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/container.py
@@ -1,16 +1,29 @@
+# pylint: disable=R0801
 """
 Module contains the Container class.
 """
 import tkinter as tk
 
-from .root_cmp import *
+from clinguin.utils.attribute_types import BooleanType, ColorType, SymbolType
+
+from ..tkinter_utils import (
+    AttributeNames,
+    CallbackNames,
+    ConfigureBorder,
+    ConfigureSize,
+    LayoutController,
+    LayoutFollower,
+)
+from .root_cmp import RootCmp
 
 
 class Container(
     RootCmp, LayoutFollower, LayoutController, ConfigureSize, ConfigureBorder
 ):
     """
-    The container is a generic element which can be used for layouting, hovering effects or even callbacks. Generally it is recommended to use it as a ''container'' for multiple other elements, e.g. labels, buttons, etc.
+    The container is a generic element which can be used for layouting,
+    hovering effects or even callbacks. Generally it is recommended to use
+    it as a ''container'' for multiple other elements, e.g. labels, buttons, etc.
     """
 
     def _init_element(self, elements):
@@ -55,6 +68,7 @@ def _get_callbacks(cls, callbacks=None):
     # ----------------------------------------------------------------------------------------------
 
     def _set_background_color(self, elements, key=AttributeNames.backgroundcolor):
+        self._logger.debug(str(elements))
         value = self._attributes[key]["value"]
         self._element.configure(background=value)
 
@@ -70,6 +84,7 @@ def _set_on_hover(self, elements):
         if on_hover:
 
             def enter(event):
+                self._logger.debug(str(event))
                 if on_hover_color != "":
                     self._set_background_color(
                         elements, key=AttributeNames.onhover_background_color
@@ -80,6 +95,7 @@ def enter(event):
                     )
 
             def leave(event):
+                self._logger.debug(str(event))
                 self._set_background_color(elements, key=AttributeNames.backgroundcolor)
                 self._set_border_background_color(
                     elements, key=AttributeNames.border_color
@@ -93,9 +109,11 @@ def leave(event):
     # ----------------------------------------------------------------------------------------------
 
     def _define_click_event(self, elements, key=CallbackNames.click):
+        self._logger.debug(str(elements))
         if self._callbacks[key] and self._callbacks[key]["policy"]:
 
-            def dropdownmenuitemClick(event):
+            def dropdown_menu_item_click(event):
+                self._logger.debug(str(event))
                 self._base_engine.assume(self._callbacks[key]["policy"])
 
-            self._element.bind("<Button-1>", dropdownmenuitemClick)
+            self._element.bind("<Button-1>", dropdown_menu_item_click)
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/dropdownmenu.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/dropdownmenu.py
index 871a6131..ee0f0cc2 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/dropdownmenu.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/dropdownmenu.py
@@ -1,18 +1,32 @@
+# pylint: disable=R0801
 """
 This module contains the Dropdownmenu class.
 """
 import tkinter as tk
 
-from .root_cmp import *
+from clinguin.utils.attribute_types import (
+    BooleanType,
+    ColorType,
+    StringType,
+    SymbolType,
+)
+
+from ..tkinter_utils import AttributeNames, CallbackNames, ConfigureSize, LayoutFollower
+from .root_cmp import RootCmp
 
 
 class Dropdownmenu(RootCmp, LayoutFollower, ConfigureSize):
     """
-    The dropdownmenu is the master component for a dropdownmenu, i.e. dropdownmenu-items must be children of it. For available attributes see syntax definition. Implementation wise it is similarly implemented as the Label and Button - to make it work for layouting, the actual dropdownmenu is hidden and the element is actually a tkinter frame (therefore self._element is a frame, whereas self._menu is the dropdownmenu).
+    The dropdownmenu is the master component for a dropdownmenu,
+    i.e. dropdownmenu-items must be children of it.
+    For available attributes see syntax definition.
+    Implementation wise it is similarly implemented as the Label and Button -
+    to make it work for layouting, the actual dropdownmenu is hidden and the element
+    is actually a tkinter frame (therefore self._element is a frame, whereas self._menu is the dropdownmenu).
     """
 
-    def __init__(self, args, id, parent, attributes, callbacks, base_engine):
-        super().__init__(args, id, parent, attributes, callbacks, base_engine)
+    def __init__(self, args, cid, parent, attributes, callbacks, base_engine):
+        super().__init__(args, cid, parent, attributes, callbacks, base_engine)
 
         self._menu = None
         self._variable = None
@@ -29,6 +43,9 @@ def _init_element(self, elements):
         return option_menu_frame
 
     def get_variable(self):
+        """
+        Gets the variable associated with the value.
+        """
         return self._variable
 
     @classmethod
@@ -68,11 +85,11 @@ def _get_callbacks(cls, callbacks=None):
 
         return callbacks
 
-    def _clear_select(self, id, parent_id, click_policy, elements):
+    def _clear_select(self, cid, parent_id, click_policy, elements):
         parent = elements[str(parent_id)]
         if hasattr(parent, "get_variable"):
             variable = getattr(parent, "get_variable")()
-            variable.set(id)
+            variable.set(cid)
             if click_policy is not None:
                 self._base_engine.post_with_policy(click_policy)
         else:
@@ -87,30 +104,36 @@ def _dropdown_clear(self, click_policy):
         variable.set("")
         self._base_engine.post_with_policy(click_policy)
 
-    def _define_clear_event(self, elements, key=CallbackNames.clear):
+    def _define_clear_event(
+        self, elements, key=CallbackNames.clear
+    ):  # pylint: disable=W0613
         if self._callbacks[key]["policy"] is None:
             return
 
-        def change(*args):
+        def change(*args):  # pylint: disable=W0613
             if self._variable.get() == "":
                 self._logger.info("Will remove previous selections")
                 self._dropdown_clear(self._callbacks[key]["policy"])
 
         self._variable.trace("w", change)
 
-    def _set_background_color(self, elements, key=AttributeNames.backgroundcolor):
+    def _set_background_color(
+        self, elements, key=AttributeNames.backgroundcolor
+    ):  # pylint: disable=W0613
         value = self._attributes[key]["value"]
 
         self._menu.config(bg=value, activebackground=value)
         self._menu["menu"].config(bg=value, activebackground=value)
 
-    def _set_foreground_color(self, elements, key=AttributeNames.foregroundcolor):
+    def _set_foreground_color(
+        self, elements, key=AttributeNames.foregroundcolor
+    ):  # pylint: disable=W0613
         value = self._attributes[key]["value"]
 
         self._menu.config(fg=value, activeforeground=value)
         self._menu["menu"].config(fg=value, activeforeground=value)
 
-    def _set_on_hover(self, elements):
+    def _set_on_hover(self, elements):  # pylint: disable=W0613
         on_hover = self._attributes[AttributeNames.onhover]["value"]
 
         on_hover_background_color = self._attributes[
@@ -131,10 +154,13 @@ def _set_on_hover(self, elements):
                 activeforeground=on_hover_foreground_color,
             )
 
-    def _set_selected(self, elements):
+    def _set_selected(self, elements):  # pylint: disable=W0613
         self._variable.set(self._attributes[AttributeNames.selected]["value"])
 
     def get_menu(self):
+        """
+        Returns the actual tkinter menu of this element.
+        """
         return self._menu
 
     def _add_component_to_elements(self, elements):
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/dropdownmenu_item.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/dropdownmenu_item.py
index 4d614075..9034182f 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/dropdownmenu_item.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/dropdownmenu_item.py
@@ -1,8 +1,12 @@
+# pylint: disable=R0801
 """
 Contains the DropdownmenuItem class.
 """
 
-from .root_cmp import *
+from clinguin.utils.attribute_types import StringType, SymbolType
+
+from ..tkinter_utils import AttributeNames, CallBackDefinition, CallbackNames
+from .root_cmp import RootCmp
 
 
 class DropdownmenuItem(RootCmp):
@@ -14,7 +18,6 @@ def _init_element(self, elements):
         parent = elements[str(self._parent)]
         if hasattr(parent, "get_menu"):
             menu = parent.get_menu()
-            return menu
         else:
             error_string = (
                 "Parent of dropdown menu item " + self._id + " is not a dropdown menu."
@@ -22,6 +25,8 @@ def _init_element(self, elements):
             self._logger.error(error_string)
             raise Exception(error_string)
 
+        return menu
+
     @classmethod
     def _get_attributes(cls, attributes=None):
         if attributes is None:
@@ -53,19 +58,19 @@ def _define_click_event(self, elements, key=CallbackNames.click):
                 ),
             )
 
-    def _dropdownmenuitem_click(self, id, parent_id, click_policy, elements):
+    def _dropdownmenuitem_click(self, cid, parent_id, click_policy, elements):
         parent = elements[str(parent_id)]
         if hasattr(parent, "get_variable"):
             variable = getattr(parent, "get_variable")()
-            variable.set(id)
+            variable.set(cid)
             if click_policy is not None:
                 self._base_engine.post_with_policy(click_policy)
         else:
             self._logger.warning(
                 "Could not set variable for dropdownmenu. Item id: %s, dropdown-menu-id: %s",
-                str(id),
+                str(cid),
                 str(parent_id),
             )
 
     def forget_children(self, elements):
-        pass
+        pass  # pylint: disable=W0107
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/label.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/label.py
index dbfc071c..5aea0abe 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/label.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/label.py
@@ -1,18 +1,37 @@
+# pylint: disable=R0801
 """
 This module contains the Label class.
 """
 import tkinter as tk
 
-from .root_cmp import *
+from clinguin.utils.attribute_types import (
+    BooleanType,
+    ColorType,
+    StringType,
+    SymbolType,
+)
+
+from ..tkinter_utils import (
+    AttributeNames,
+    CallbackNames,
+    ConfigureFont,
+    ConfigureTextElementSize,
+    LayoutFollower,
+)
+from .root_cmp import RootCmp
 
 
 class Label(RootCmp, LayoutFollower, ConfigureFont, ConfigureTextElementSize):
     """
-    The label can be used for positiion text. For available attributes see syntax definition. Implementation wise it is similarly implemented as the Dropdowmenu and Button - to make it work for layouting, the actual label is hidden and the element is actually a tkinter frame (therefore self._element is a frame, whereas self._label is the label).
+    The label can be used for positiion text.
+    For available attributes see syntax definition.
+    Implementation wise it is similarly implemented as the Dropdowmenu and Button -
+    to make it work for layouting, the actual label is hidden and the element is actually
+    a tkinter frame (therefore self._element is a frame, whereas self._label is the label).
     """
 
-    def __init__(self, args, id, parent, attributes, callbacks, base_engine):
-        super().__init__(args, id, parent, attributes, callbacks, base_engine)
+    def __init__(self, args, cid, parent, attributes, callbacks, base_engine):
+        super().__init__(args, cid, parent, attributes, callbacks, base_engine)
         self._configure_font_element = None
         self._label = None
 
@@ -64,15 +83,21 @@ def _get_callbacks(cls, callbacks=None):
     # -----Standard-Attributes----
     # ----------------------------------------------------------------------------------------------
 
-    def _set_label_text(self, elements, key=AttributeNames.label):
+    def _set_label_text(
+        self, elements, key=AttributeNames.label
+    ):  # pylint: disable=W0613
         text = self._attributes[key]["value"]
         self._label.configure(text=text)
 
-    def _set_background_color(self, elements, key=AttributeNames.backgroundcolor):
+    def _set_background_color(
+        self, elements, key=AttributeNames.backgroundcolor
+    ):  # pylint: disable=W0613
         value = self._attributes[key]["value"]
         self._label.configure(background=value)
 
-    def _set_foreground_color(self, elements, key=AttributeNames.foregroundcolor):
+    def _set_foreground_color(
+        self, elements, key=AttributeNames.foregroundcolor
+    ):  # pylint: disable=W0613
         value = self._attributes[key]["value"]
         self._label.configure(foreground=value)
 
@@ -92,7 +117,7 @@ def _set_on_hover(self, elements):
 
         if on_hover:
 
-            def enter(event):
+            def enter(event):  # pylint: disable=W0613
                 if on_hover_background_color != "":
                     self._set_background_color(
                         elements, key=AttributeNames.onhover_background_color
@@ -102,7 +127,7 @@ def enter(event):
                         elements, key=AttributeNames.onhover_foreground_color
                     )
 
-            def leave(event):
+            def leave(event):  # pylint: disable=W0613
                 self._set_background_color(elements, key=AttributeNames.backgroundcolor)
                 self._set_foreground_color(elements, key=AttributeNames.foregroundcolor)
 
@@ -113,11 +138,11 @@ def leave(event):
     # -----Actions----
     # ----------------------------------------------------------------------------------------------
 
-    def _define_click_event(self, elements):
+    def _define_click_event(self, elements):  # pylint: disable=W0613
         key = CallbackNames.click
         if self._callbacks[key] and self._callbacks[key]["policy"]:
 
-            def click_event(event):
+            def click_event(event):  # pylint: disable=W0613
                 self._base_engine.post_with_policy(self._callbacks[key]["policy"])
 
             self._label.bind("<Button-1>", click_event)
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar.py
index ae15dfc5..137df60b 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar.py
@@ -3,7 +3,7 @@
 """
 import tkinter as tk
 
-from .root_cmp import *
+from .root_cmp import RootCmp
 
 
 class MenuBar(RootCmp):
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar_section.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar_section.py
index 9b388fd2..8d82f550 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar_section.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar_section.py
@@ -3,12 +3,20 @@
 """
 import tkinter as tk
 
-from .root_cmp import *
+from clinguin.utils.attribute_types import StringType
+
+from ..tkinter_utils import AttributeNames
+from .root_cmp import RootCmp
 
 
 class MenuBarSection(RootCmp):
     """
-    The menu bar section is a section of a menu bar (e.g. in the menu \|main\|contact\|, where if one clicks on \|contact\| further the options \|location\|team\| appear, a menu-bar-section would be \|contact\|, whereas \|location\| and \|team\| would be menu-bar-section-items.
+    The menu bar section is a section of a menu bar
+    (e.g. in the menu |main|contact|,
+    where if one clicks on |contact|
+    further the options |location|team|
+    appear, a menu-bar-section would be |contact|,
+    whereas |location| and |team| would be menu-bar-section-items.
     """
 
     def _init_element(self, elements):
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar_section_item.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar_section_item.py
index ecab2c24..b7fd016d 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar_section_item.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/menu_bar_section_item.py
@@ -1,9 +1,14 @@
+# pylint: disable=R0801
 """
 Contains the menu bar section item class.
 """
-from .root_cmp import *
 
-map = {
+from clinguin.utils.attribute_types import StringType, SymbolType
+
+from ..tkinter_utils import AttributeNames, CallBackDefinition, CallbackNames
+from .root_cmp import RootCmp
+
+key_map = {
     "Ctrl": "Control",
     "Opt": "Option",
     "Cmd": "Command",
@@ -15,11 +20,14 @@
 
 
 def accelerator_to_bind(a):
+    """
+    Getting key bindings as string.
+    """
     args = a.split("+")
     formatted = []
     for e in args:
-        if e in map:
-            formatted.append(map[e])
+        if e in key_map:
+            formatted.append(key_map[e])
         else:
             formatted.append(e.lower())
     return "<" + "-".join(formatted) + ">"
@@ -27,7 +35,9 @@ def accelerator_to_bind(a):
 
 class MenuBarSectionItem(RootCmp):
     """
-    The menu bar section is a section of a menu bar (e.g. in the menu \|main\|contact\|, where if one clicks on \|contact\| further the options \|location\|team\| appear, a menu-bar-section would be \|contact\|, whereas \|location\| and \|team\| would be menu-bar-section-items.
+    The menu bar section is a section of a menu bar (e.g. in the menu |main|contact|,
+    where if one clicks on |contact| further the options |location|team| appear,
+    a menu-bar-section would be |contact|, whereas |location| and |team| would be menu-bar-section-items.
     """
 
     def _init_element(self, elements):
@@ -74,14 +84,18 @@ def _define_click_event(self, elements):
             )
             self._element.add_command(label=text, command=cb, accelerator=accelerator)
             menu = elements[self._parent]
-            window = elements[menu._parent]
-            root = elements[window._parent]
+            window = elements[menu.get_parent()]
+            root = elements[window.get_parent()]
             if accelerator:
                 root.get_element().bind(accelerator_to_bind(accelerator), cb)
         else:
             self._element.add_command(label=text)
 
-    def _menubar_item_click(self, id, parent, click_policy, elements):
+    def _menubar_item_click(self, cid, parent, click_policy, elements):
+        self._logger.debug(str(cid))
+        self._logger.debug(str(parent))
+        self._logger.debug(str(elements))
+
         if click_policy is not None:
             self._base_engine.post_with_policy(click_policy)
 
@@ -89,4 +103,6 @@ def _add_component_to_elements(self, elements):
         elements[str(self._id)] = self
 
     def forget_children(self, elements):
-        pass
+        self._logger.debug(str(elements))
+        # pylint: disable=W0107
+        # pylint: enable=W0107
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/message.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/message.py
index b08b199e..0d3795f3 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/message.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/message.py
@@ -2,11 +2,13 @@
 Contains the Message class.
 """
 import tkinter as tk
+from tkinter import messagebox
 
 # This import is used implicitly
-import tkinter.messagebox
+from clinguin.utils.attribute_types import PopupTypesType, StringType
 
-from .root_cmp import *
+from ..tkinter_utils import AttributeNames
+from .root_cmp import RootCmp
 
 
 class Message(RootCmp):
@@ -33,14 +35,15 @@ def _get_attributes(cls, attributes=None):
         return attributes
 
     def _set_values(self, elements):
-        type = self._attributes[AttributeNames.type]["value"]
+        self._logger.debug(str(elements))
+        attr_type = self._attributes[AttributeNames.type]["value"]
         title = self._attributes[AttributeNames.title]["value"]
         message = self._attributes[AttributeNames.message]["value"]
-        if PopupTypesType.INFO == type:
-            tk.messagebox.showinfo(title=title, message=message)
-        elif PopupTypesType.WARNING == type:
-            tk.messagebox.showwarning(title=title, message=message)
-        elif PopupTypesType.ERROR == type:
-            tk.messagebox.showerror(title=title, message=message)
+        if PopupTypesType.INFO == attr_type:
+            messagebox.showinfo(title=title, message=message)
+        elif PopupTypesType.WARNING == attr_type:
+            messagebox.showwarning(title=title, message=message)
+        elif PopupTypesType.ERROR == attr_type:
+            messagebox.showerror(title=title, message=message)
         else:
-            self._logger.warning("Cannot display popup-type %s", type)
+            self._logger.warning("Cannot display popup-type %s", attr_type)
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/root_cmp.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/root_cmp.py
index d7c05dc1..6f986b60 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/root_cmp.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/root_cmp.py
@@ -1,25 +1,30 @@
+# pylint: disable=R1711
 """
 Contains the RootCmp class.
 """
 import logging
 
-from clinguin.utils.attribute_types import *
+from clinguin.utils.attribute_types import ChildLayoutType, StringType, SymbolType
 
-from ..tkinter_utils import *
+from ..tkinter_utils import ExtensionClass
 
 
 class RootCmp:
     """
-    Every tkinter element must be a subtype of the RootCmp. It further features standard implementations of various methods, therefore one must just implement a handful of methods if one implements a new element, these are (see e.g. the button.py for a sample implementation):
+    Every tkinter element must be a subtype of the RootCmp.
+    It further features standard implementations of various methods,
+    therefore one must just implement a handful of methods if one implements a new element,
+    these are (see e.g. the button.py for a sample implementation):
     - _get_attributes(attributes = None)
     - _get_callbacks(callbacks = None)
-    - Every method, which name starts with ''_set'' will be executed and are designed to be used for setting the attributes.
+    - Every method, which name starts with ''_set'' will be executed and are designed to be used
+    for setting the attributes.
     - Every method, which name starts with ''_define'' will be executed and are designet to specify callbacks.
     """
 
-    def __init__(self, args, id, parent, attributes, callbacks, base_engine):
+    def __init__(self, args, cid, parent, attributes, callbacks, base_engine):
         self._logger = logging.getLogger(args.log_args["name"])
-        self._id = id
+        self._id = cid
         self._parent = parent
         self._json_attributes = attributes
         self._json_callbacks = callbacks
@@ -29,8 +34,35 @@ def __init__(self, args, id, parent, attributes, callbacks, base_engine):
         self._attributes = None
         self._callbacks = None
 
+    def get_id(self):
+        """
+        Get the id of the element.
+        """
+        return self._id
+
+    def get_parent(self):
+        """
+        Get the parent of the element.
+        """
+        return self._parent
+
+    def get_element(self):
+        """
+        Get the tkinter object of the element.
+        """
+        return self._element
+
+    def get_attributes_list(self):
+        """
+        Get the attributes list of instance.
+        """
+        return self._attributes
+
     @classmethod
     def get_attributes(cls):
+        """
+        Get attributes list of class (which attributes has this class in general).
+        """
         attributes = {}
         for base in cls.__bases__:
             if issubclass(base, ExtensionClass):
@@ -39,11 +71,14 @@ def get_attributes(cls):
         return cls._get_attributes(attributes)
 
     @classmethod
-    def _get_attributes(cls, attributes=None):
+    def _get_attributes(cls, attributes=None):  # pylint: disable=W0613
         return {}
 
     @classmethod
     def get_callbacks(cls):
+        """
+        Get callbacks list of class (which callbacks has this class in general).
+        """
         callbacks = {}
         for base in cls.__bases__:
             if issubclass(base, ExtensionClass):
@@ -52,14 +87,14 @@ def get_callbacks(cls):
         return cls._get_callbacks(callbacks)
 
     @classmethod
-    def _get_callbacks(cls, callbacks=None):
+    def _get_callbacks(cls, callbacks=None):  # pylint: disable=W0613
         return {}
 
-    def get_element(self):
-        return self._element
-
     def add_component(self, elements):
-        self._element = self._init_element(elements)
+        """
+        Add the current (self) component to elements.
+        """
+        self._element = self._init_element(elements)  # pylint: disable=E1128
         self._attributes = self.__class__.get_attributes()
         self._callbacks = self.__class__.get_callbacks()
 
@@ -72,6 +107,7 @@ def add_component(self, elements):
         self._add_component_to_elements(elements)
 
     def _init_element(self, elements):
+        self._logger.debug(str(elements))
         return None
 
     def _fill_attributes(self):
@@ -130,6 +166,9 @@ def _add_component_to_elements(self, elements):
         elements[str(self._id)] = self
 
     def forget_children(self, elements):
+        """
+        The current element drops all relations to its children (thereby 'forgetting' them).
+        """
         if str(self._parent) in elements:
             if hasattr(elements[self._parent], "get_child_org"):
                 parent_org = getattr(elements[self._parent], "get_child_org")()
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/window.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/window.py
index fd229bb8..ba735759 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/window.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_elements/window.py
@@ -1,14 +1,19 @@
+# pylint: disable=R0801,R1716
 """
 Contains the window class.
 """
 import tkinter as tk
 
-from .root_cmp import *
+from clinguin.utils.attribute_types import ChildLayoutType, ColorType, IntegerType
+
+from ..tkinter_utils import AttributeNames, LayoutController
+from .root_cmp import RootCmp
 
 
 class Window(RootCmp, LayoutController):
     """
-    The window class is the top-lvl. component, therefore it MUST be used in every clinguin application! For available attributes see syntax definition.
+    The window class is the top-lvl. component, therefore it MUST be used in every clinguin application!
+    For available attributes see syntax definition.
     """
 
     def _init_element(self, elements):
@@ -35,11 +40,13 @@ def _get_attributes(cls, attributes=None):
 
         return attributes
 
-    def _set_background_color(self, elements, key=AttributeNames.backgroundcolor):
+    def _set_background_color(
+        self, elements, key=AttributeNames.backgroundcolor
+    ):  # pylint: disable=W0613
         value = self._attributes[key]["value"]
         self._element.configure(background=value)
 
-    def _set_dimensions(self, elements):
+    def _set_dimensions(self, elements):  # pylint: disable=W0613
         width = self._attributes[AttributeNames.width]["value"]
         height = self._attributes[AttributeNames.height]["value"]
 
@@ -72,7 +79,7 @@ def _set_dimensions(self, elements):
                 "For the tkinter window one must set both height and width to positive values (not just one)."
             )
 
-    def _set_resizable(self, elements):
+    def _set_resizable(self, elements):  # pylint: disable=W0613
         self._element.resizable(
             self._attributes[AttributeNames.resizable_x]["value"],
             self._attributes[AttributeNames.resizable_y]["value"],
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_frontend.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_frontend.py
index f82b14c9..f955c896 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_frontend.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_frontend.py
@@ -7,13 +7,27 @@
 from clinguin.show_frontend_syntax_enum import ShowFrontendSyntaxEnum
 from clinguin.utils.attribute_types.child_layout import ChildLayoutType
 
-from .tkinter_elements import *
-from .tkinter_utils import *
+from .tkinter_elements import (
+    Button,
+    Canvas,
+    Container,
+    Dropdownmenu,
+    DropdownmenuItem,
+    Label,
+    MenuBar,
+    MenuBarSection,
+    MenuBarSectionItem,
+    Message,
+    RootCmp,
+    Window,
+)
+from .tkinter_utils import AttributeNames, CallbackNames
 
 
 class TkinterFrontend(AbstractFrontend):
     """
-    Class that inherits from AbstractFrontend and is therefore a dynamically loaded class, if it shall be used to render the Frontend. It defines what to do for each element.
+    Class that inherits from AbstractFrontend and is therefore a dynamically loaded class,
+    if it shall be used to render the Frontend. It defines what to do for each element.
     """
 
     def __init__(self, base_engine, args):
@@ -30,14 +44,14 @@ def register_options(cls, parser):
 
     @classmethod
     def available_syntax(cls, show_level):
-        def append_dict(description, _dict, type_name):
-            for key in _dict.keys():
+        def append_dict(description, d, type_name):
+            for key in d.keys():
                 description = description + "    |- " + key + "\n"
                 if show_level == ShowFrontendSyntaxEnum.FULL:
-                    if "description" in _dict[key]:
+                    if "description" in d[key]:
                         # Specific has higher priority
                         description = description + "      |- Description: "
-                        description = description + ": " + _dict[key]["description"]
+                        description = description + ": " + d[key]["description"]
                         description = description + "\n"
                     elif key in AttributeNames.descriptions:
                         # General lesser priority
@@ -53,20 +67,23 @@ def append_dict(description, _dict, type_name):
                         )
                         description = description + "\n"
 
-                    if type_name in _dict[key]:
+                    if type_name in d[key]:
                         description = description + "      |- Possible-Values: "
                         description = (
-                            description + _dict[key][type_name].description() + "\n"
+                            description + d[key][type_name].description() + "\n"
                         )
 
             return description
 
         description = (
-            "Here one finds the supported attributes and callbacks of the TkinterFrontend and further a definition of the syntax:\n"
+            "Here one finds the supported attributes and callbacks of the TkinterFrontend and further a definition"
+            + "of the syntax:\n"
             + "There are three syntax elements:\n\n"
             + "element(<ID>, <TYPE>, <PARENT>) : To define an element\n"
-            + "attribute(<ID>, <KEY>, <VALUE>) : To define an attribute for an element (the ID is the ID of the corresponding element)\n"
-            + "callback(<ID>, <ACTION>, <POLICY>) : To define a callback for an element (the ID is the ID of the corresponding element)\n\n"
+            + "attribute(<ID>, <KEY>, <VALUE>) : To define an attribute for an element (the ID is the ID of the"
+            + "corresponding element)\n"
+            + "callback(<ID>, <ACTION>, <POLICY>) : To define a callback for an element (the ID is the ID of the"
+            + "corresponding element)\n\n"
             + "The following list shows for each <TYPE> the possible attributes and callbacks:\n"
         )
 
@@ -89,96 +106,96 @@ def append_dict(description, _dict, type_name):
 
         return description
 
-    def window(self, id, parent, attributes, callbacks):
+    def window(self, cid, parent, attributes, callbacks):
         if self.first:
             window = Window(
-                self._args, id, parent, attributes, callbacks, self._base_engine
+                self._args, cid, parent, attributes, callbacks, self._base_engine
             )
             window.add_component(self.elements)
         else:
             keys = list(self.elements.keys()).copy()
             for key in keys:
-                if str(key) == str(id):
+                if str(key) == str(cid):
                     continue
 
                 if str(key) in self.elements:
                     self.elements[str(key)].forget_children(self.elements)
                     del self.elements[str(key)]
 
-    def container(self, id, parent, attributes, callbacks):
+    def container(self, cid, parent, attributes, callbacks):
         container = Container(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         container.add_component(self.elements)
 
-    def dropdown_menu(self, id, parent, attributes, callbacks):
+    def dropdown_menu(self, cid, parent, attributes, callbacks):
         menu = Dropdownmenu(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         menu.add_component(self.elements)
 
-    def dropdown_menu_item(self, id, parent, attributes, callbacks):
+    def dropdown_menu_item(self, cid, parent, attributes, callbacks):
         menu = DropdownmenuItem(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         menu.add_component(self.elements)
 
-    def label(self, id, parent, attributes, callbacks):
-        label = Label(self._args, id, parent, attributes, callbacks, self._base_engine)
+    def label(self, cid, parent, attributes, callbacks):
+        label = Label(self._args, cid, parent, attributes, callbacks, self._base_engine)
         label.add_component(self.elements)
 
-    def button(self, id, parent, attributes, callbacks):
+    def button(self, cid, parent, attributes, callbacks):
         button = Button(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         button.add_component(self.elements)
 
-    def menu_bar(self, id, parent, attributes, callbacks):
+    def menu_bar(self, cid, parent, attributes, callbacks):
         menubar = MenuBar(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         menubar.add_component(self.elements)
 
-    def menu_bar_section(self, id, parent, attributes, callbacks):
+    def menu_bar_section(self, cid, parent, attributes, callbacks):
         menubar = MenuBarSection(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         menubar.add_component(self.elements)
 
-    def menu_bar_section_item(self, id, parent, attributes, callbacks):
+    def menu_bar_section_item(self, cid, parent, attributes, callbacks):
         menubar = MenuBarSectionItem(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         menubar.add_component(self.elements)
 
-    def message(self, id, parent, attributes, callbacks):
+    def message(self, cid, parent, attributes, callbacks):
         message = Message(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         message.add_component(self.elements)
 
-    def canvas(self, id, parent, attributes, callbacks):
+    def canvas(self, cid, parent, attributes, callbacks):
         canvas = Canvas(
-            self._args, id, parent, attributes, callbacks, self._base_engine
+            self._args, cid, parent, attributes, callbacks, self._base_engine
         )
         canvas.add_component(self.elements)
 
-    def draw_postprocessing(self, id):
-        self.elements[id].get_element().update()
+    def draw_postprocessing(self, cid):
+        self.elements[cid].get_element().update()
 
         elements_info = {}
         dependency = []
 
         for key in self.elements.keys():
             w = self.elements[key]
-            if w._id == "root":
+            if w.get_id() == "root":
                 continue
 
-            elements_info[w._id] = {"parent": w._parent, "type": w._id}
-            dependency.append((w._id, w._parent))
+            elements_info[w.get_id()] = {"parent": w.get_parent(), "type": w.get_id()}
+            dependency.append((w.get_id(), w.get_parent()))
 
-        DG = nx.DiGraph(dependency)
-        order = list((list(nx.topological_sort(DG))))
+        digraph = nx.DiGraph(dependency)
+        order = list((list(nx.topological_sort(digraph))))
 
         for element_key in order:
             if element_key == "root":
@@ -186,49 +203,61 @@ def draw_postprocessing(self, id):
 
             cur_element = self.elements[element_key]
 
-            attributes = cur_element.get_attributes()
+            attributes = cur_element.get_attributes_list()
 
             if (
                 AttributeNames.height in attributes
                 and AttributeNames.width in attributes
             ):
-                true_width = cur_element._element.winfo_width()
-                true_height = cur_element._element.winfo_height()
-
-                config_width = int(
-                    cur_element._attributes[AttributeNames.width]["value"]
-                )
-                config_height = int(
-                    cur_element._attributes[AttributeNames.height]["value"]
-                )
-
-                pack = False
-
-                if config_width > 0:
-                    pack = True
-                    cur_element._element.config(width=config_width)
-                else:
-                    cur_element._element.config(width=true_width)
-
-                if config_height > 0:
-                    pack = True
-                    cur_element._element.config(height=config_height)
-                else:
-                    cur_element._element.config(height=true_height)
-
-                if pack:
-                    if AttributeNames.child_layout in attributes:
-                        policy = cur_element._attributes[AttributeNames.child_layout][
-                            "value"
-                        ]
-                        if policy == ChildLayoutType.FLEX:
-                            cur_element._element.pack_propagate(0)
-                    else:
-                        cur_element._element.pack_propagate(0)
-
-                    self.elements[id].get_element().update()
-
-    def draw(self, id):
+                self.postprocessing_size_setter(cid, cur_element, attributes)
+
+    def postprocessing_size_setter(self, cid, cur_element, attributes):
+        """
+        Postprocessing - Used to enable setting the size and width of tkinter elemnents independent.
+        Normal behavior of tkinter: Only set set the size the user wants when setting both height and width.
+        Wished behavior: Also do this if only one of height or width is set.
+
+        This is implemented here, by first analyzing which elements are drawn latest.
+        Then from the latest to the first compute their actual sizes, and if necessary correct them.
+        In this manner every element takes the size it has been assigned.
+        """
+        true_width = cur_element.get_element().winfo_width()
+        true_height = cur_element.get_element().winfo_height()
+
+        config_width = int(
+            cur_element.get_attributes_list()[AttributeNames.width]["value"]
+        )
+        config_height = int(
+            cur_element.get_attributes_list()[AttributeNames.height]["value"]
+        )
+
+        pack = False
+
+        if config_width > 0:
+            pack = True
+            cur_element.get_element().config(width=config_width)
+        else:
+            cur_element.get_element().config(width=true_width)
+
+        if config_height > 0:
+            pack = True
+            cur_element.get_element().config(height=config_height)
+        else:
+            cur_element.get_element().config(height=true_height)
+
+        if pack:
+            if AttributeNames.child_layout in attributes:
+                policy = cur_element.get_attributes_list()[AttributeNames.child_layout][
+                    "value"
+                ]
+                if policy == ChildLayoutType.FLEX:
+                    cur_element.get_element().pack_propagate(0)
+            else:
+                cur_element.get_element().pack_propagate(0)
+
+            self.elements[cid].get_element().update()
+
+    def draw(self, cid):
         self.first = False
 
-        self.elements[id].get_element().mainloop()
+        self.elements[cid].get_element().mainloop()
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/attribute_names.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/attribute_names.py
index 72baa86e..cd493543 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/attribute_names.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/attribute_names.py
@@ -3,9 +3,10 @@
 """
 
 
-class AttributeNames:
+class AttributeNames:  # pylint: disable=R0903
     """
-    This class contains all the names for all the attributes that are used for the Frontend and also contains some standard descriptions of the attributes.
+    This class contains all the names for all the attributes that are used for the Frontend
+    and also contains some standard descriptions of the attributes.
     """
 
     title = "title"
@@ -62,9 +63,12 @@ class AttributeNames:
         width: "With this attribute one can set the width in pixels of the element.",
         height: "With this attribute one can set the height in pixels of the element.",
         onhover: "With this attribute one can enable or disable on-hover features for the element.",
-        onhover_background_color: "With this attribute one can set the background color the element shall have, when on_hover is enabled.",
-        onhover_foreground_color: "With this attribute one can set the forground color the element shall have, when on_hover is eneabled.",
-        onhover_border_color: "With this attribute one can set the color the border of the element shall have, when on_hover is enabled.",
+        onhover_background_color: "With this attribute one can set the background color the element shall have, when"
+        + "on_hover is enabled.",
+        onhover_foreground_color: "With this attribute one can set the forground color the element shall have,"
+        + "when on_hover is eneabled.",
+        onhover_border_color: "With this attribute one can set the color the border of the element shall have,"
+        + "when on_hover is enabled.",
         font_family: "With this attribute one can set the font-family of the element.",
         font_size: "With this attribute one can set the font size in pixels.",
         font_weight: "With this attribute one can set the font weight.",
@@ -75,15 +79,19 @@ class AttributeNames:
         grid_row: "With this attribute one can define in which row the element shall be positioned.",
         grid_column_span: "With this attribute one can define, that the elements stretches over several columns.",
         grid_row_span: "With this attribute one can define, that the elements stretches over several rows.",
-        pos_x: "With this attribute one sets the x-position of the element - it depends on the parent-child-layout how this is defined (either pixels, relative as a percentage, ...).",
-        pos_y: "With this attribute one sets the y-position of the element - it depends on the parent-child-layout how this is defined (either pixels, relative as a percentage, ...).",
+        pos_x: "With this attribute one sets the x-position of the element - it depends on the parent-child-layout"
+        + "how this is defined (either pixels, relative as a percentage, ...).",
+        pos_y: "With this attribute one sets the y-position of the element - it depends on the parent-child-layout"
+        + "how this is defined (either pixels, relative as a percentage, ...).",
         border_width: "With this attribute one defines the width of the border in pixels.",
         border_color: "With this attribute one may set the border color.",
         selected: "With this attribute one may define the text that shall be displayed if something is selected.",
         fit_children_size: "[DEPRECATED] - With this attribute one can define that the element fits the children.",
-        image: "Some backends define special values one can use, that e.g. a graph is shown (see corresponding backend description).",
+        image: "Some backends define special values one can use, that e.g. a graph is shown (see corresponding"
+        + "backend description).",
         image_path: "Include an image from a path.",
         resize: "With this attribute one can define if an image shall be resized.",
         accelerator: "The key binding for the menu option",
-        flex_direction: "With this attribute one can set the ''direction'' (i.e., where it gets placed) of an element which root has a specified flex layout.",
+        flex_direction: "With this attribute one can set the ''direction'' (i.e., where it gets placed) of an"
+        + "element which root has a specified flex layout.",
     }
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/call_back_definition.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/call_back_definition.py
index 8b44eed3..b264ba8e 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/call_back_definition.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/call_back_definition.py
@@ -8,8 +8,8 @@ class CallBackDefinition:
     Some elements use this class to define their callbacks (others just do it locally, which is the preferred method).
     """
 
-    def __init__(self, id, parent, click_policy, elements, callback):
-        self._id = id
+    def __init__(self, cid, parent, click_policy, elements, callback):
+        self._id = cid
         self._parent = parent
         self._click_policy = click_policy
         self._elements = elements
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/callback_names.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/callback_names.py
index 9612cd90..8b209ef0 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/callback_names.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/callback_names.py
@@ -3,7 +3,7 @@
 """
 
 
-class CallbackNames:
+class CallbackNames:  # pylint: disable=R0903
     """
     This class contains all possible names for actions for callbacks and their descriptions.
     """
@@ -12,6 +12,8 @@ class CallbackNames:
     clear = "clear"
 
     descriptions = {
-        click: "The click action, is the action that is executed if one clicks with the left-mouse button on a element.",
-        clear: "The clearlick action, is the action that is executed when the empty option of a dropdown menu is selected.",
+        click: "The click action, is the action that is executed if one clicks with the left-mouse button on a"
+        + "element.",
+        clear: "The clearlick action, is the action that is executed when the empty option of a dropdown menu is"
+        + "selected.",
     }
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_border.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_border.py
index 9ad76f35..79a76c7d 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_border.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_border.py
@@ -1,8 +1,12 @@
+# pylint: disable=E1101
 """
 This module contains the ConfigureBorder class.
 """
 
-from .extension_class import *
+from clinguin.utils.attribute_types import ColorType, IntegerType
+
+from .attribute_names import AttributeNames
+from .extension_class import ExtensionClass
 
 
 class ConfigureBorder(ExtensionClass):
@@ -26,7 +30,9 @@ def get_attributes(cls, attributes=None):
 
         return attributes
 
-    def _set_border_width(self, elements, key=AttributeNames.border_width):
+    def _set_border_width(
+        self, elements, key=AttributeNames.border_width
+    ):  # pylint: disable=W0613
         value = self._attributes[key]["value"]
         if value > 0:
             # Not using borderwidth as one cannot set the color of the default border
@@ -44,7 +50,9 @@ def _set_border_width(self, elements, key=AttributeNames.border_width):
                 + str(value)
             )
 
-    def _set_border_background_color(self, elements, key=AttributeNames.border_color):
+    def _set_border_background_color(
+        self, elements, key=AttributeNames.border_color
+    ):  # pylint: disable=W0613
         # Not using borderwidth as one cannot set the color of the default border
         value = self._attributes[key]["value"]
         self._element.configure(highlightbackground=value, highlightcolor=value)
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_font.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_font.py
index 8c38a319..37966f8d 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_font.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_font.py
@@ -1,15 +1,20 @@
+# pylint: disable=E1101
 """
 This module contains the ConfigureSize class.
 """
 from tkinter import font
 
-from .extension_class import *
+from clinguin.utils.attribute_types import FontFamiliesType, FontWeightType, IntegerType
+
+from .attribute_names import AttributeNames
+from .extension_class import ExtensionClass
 
 
 class ConfigureFont(ExtensionClass):
     """
     If a element is a subtype of the configure-size class the size of the element can be adjusted.
-    It is required that any subtype of this type has the ''_configure_font_element'' variable (and must be set appropriately).
+    It is required that any subtype of this type has the ''_configure_font_element'' variable
+    (and must be set appropriately).
     """
 
     def __init__(self):
@@ -32,7 +37,7 @@ def get_attributes(cls, attributes=None):
 
         return attributes
 
-    def _set_font(self, elements):
+    def _set_font(self, elements):  # pylint: disable=W0613
         family = family = self._attributes[AttributeNames.font_family]["value"]
         size = int(self._attributes[AttributeNames.font_size]["value"])
         weight = self._attributes[AttributeNames.font_weight]["value"]
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_size.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_size.py
index b9fe6186..fc26f4d5 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_size.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_size.py
@@ -1,7 +1,12 @@
+# pylint: disable=E1101,R0801
 """
 This module contains the ConfigureSize class.
 """
-from .extension_class import *
+
+from clinguin.utils.attribute_types import ChildLayoutType, IntegerType
+
+from .attribute_names import AttributeNames
+from .extension_class import ExtensionClass
 
 
 class ConfigureSize(ExtensionClass):
@@ -19,7 +24,7 @@ def get_attributes(cls, attributes=None):
 
         return attributes
 
-    def _set_size(self, elements):
+    def _set_size(self, elements):  # pylint: disable=W0613
         height = self._attributes[AttributeNames.height]["value"]
         width = self._attributes[AttributeNames.width]["value"]
 
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_text_element_size.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_text_element_size.py
index 7cda7dc0..4419f49b 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_text_element_size.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/configure_text_element_size.py
@@ -1,16 +1,20 @@
+# pylint: disable=E1101,R0801
 """
 This module contains the ConfigureTextElementSize class.
 """
 from tkinter import font
 
-from .extension_class import *
+from clinguin.utils.attribute_types import IntegerType
+
+from .attribute_names import AttributeNames
+from .extension_class import ExtensionClass
 
 
 class ConfigureTextElementSize(ExtensionClass):
     """
     If a element is a subtype of the configure-element-size class the size of the element can be adjusted.
-    It is required that any subtype of this type has the ''_configure_text_element_size'' variable (and must be set appropriately).
-    Further any subtype MUST also be a subtype of ''configure_font''
+    It is required that any subtype of this type has the ''_configure_text_element_size'' variable
+    (and must be set appropriately). Further any subtype MUST also be a subtype of ''configure_font''
     """
 
     def __init__(self):
@@ -26,13 +30,13 @@ def get_attributes(cls, attributes=None):
 
         return attributes
 
-    def _set_size(self, elements):
+    def _set_size(self, elements):  # pylint: disable=W0613
         height = self._attributes[AttributeNames.height]["value"]
         width = self._attributes[AttributeNames.width]["value"]
 
         self._element.pack_propagate(0)
 
-        used_font = self._configure_text_element_size["font"]
+        used_font = self._configure_text_element_size["font"]  # pylint: disable=E1136
         afont = font.Font(
             family=used_font, size=self._attributes[AttributeNames.font_size]["value"]
         )
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/extension_class.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/extension_class.py
index 3859ee81..46806192 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/extension_class.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/extension_class.py
@@ -1,21 +1,24 @@
 """
 This module contains the ExtensionClass
 """
-from clinguin.utils.attribute_types import *
-
-from .attribute_names import AttributeNames
-from .callback_names import CallbackNames
 
 
 class ExtensionClass:
     """
-    If a class is a subtype of the ExtensionClass it resembles a set of attributes/callbacks that can be applied to elements.
+    If a class is a subtype of the ExtensionClass it resembles a set of attributes/callbacks
+    that can be applied to elements.
     """
 
     @classmethod
-    def get_attributes(cls, attributes=None):
+    def get_attributes(cls, attributes=None):  # pylint: disable=W0613
+        """
+        Has to be implemented by children.
+        """
         return {}
 
     @classmethod
-    def get_callbacks(cls, attributes=None):
+    def get_callbacks(cls, attributes=None):  # pylint: disable=W0613
+        """
+        Has to be implemented by children.
+        """
         return {}
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/layout_controller.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/layout_controller.py
index 656631ee..74292d43 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/layout_controller.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/layout_controller.py
@@ -1,7 +1,12 @@
+# pylint: disable=E1101
 """
 This module contains the LayoutController class.
 """
-from .extension_class import *
+
+from clinguin.utils.attribute_types import ChildLayoutType
+
+from .attribute_names import AttributeNames
+from .extension_class import ExtensionClass
 
 
 class LayoutController(ExtensionClass):
@@ -9,6 +14,9 @@ class LayoutController(ExtensionClass):
     If a element is a subtype of this class, then it can steer the layouting behavior of children.
     """
 
+    def __init__(self):
+        self._child_layout = None
+
     @classmethod
     def get_attributes(cls, attributes=None):
         if attributes is None:
@@ -21,12 +29,18 @@ def get_attributes(cls, attributes=None):
 
         return attributes
 
-    def _set_child_org(self, elements):
+    def _set_child_org(self, elements):  # pylint: disable=W0613
         value = self._attributes[AttributeNames.child_layout]["value"]
         self._child_layout = value
 
     def get_child_org(self):
+        """
+        Returns which child layout is used.
+        """
         return self._child_layout
 
     def get_fit_children_size(self):
+        """
+        Returns the variable associated with ''if fit to children size''.
+        """
         return self._fit_children_size
diff --git a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/layout_follower.py b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/layout_follower.py
index 6bec25ce..36768236 100644
--- a/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/layout_follower.py
+++ b/clinguin/client/presentation/frontends/tkinter_frontend/tkinter_utils/layout_follower.py
@@ -1,11 +1,18 @@
+# pylint: disable=E1101
 """
 This module contains the LayoutFollower class.
 """
 import logging
 
 from clinguin.utils import Logger
+from clinguin.utils.attribute_types import (
+    ChildLayoutType,
+    FlexDirectionType,
+    IntegerType,
+)
 
-from .extension_class import *
+from .attribute_names import AttributeNames
+from .extension_class import ExtensionClass
 
 
 class LayoutFollower(ExtensionClass):
@@ -44,6 +51,7 @@ def get_attributes(cls, attributes=None):
         return attributes
 
     def _set_layout(self, elements):
+        # pylint: disable=R0912
         parent = elements[self._parent]
         if hasattr(parent, "get_child_org"):
             parent_org = getattr(parent, "get_child_org")()
diff --git a/clinguin/parse_input.py b/clinguin/parse_input.py
index 72030ccb..904edf68 100644
--- a/clinguin/parse_input.py
+++ b/clinguin/parse_input.py
@@ -113,10 +113,12 @@ def _clinguin_description(self, process):
         )
         if process not in ["server", "client", "client-server"]:
             ascci = f"{self._clinguin_title}{description}"
-            return f"{inspect.cleandoc(ascci)}\n\n{description}"
+            return_value = f"{inspect.cleandoc(ascci)}\n\n{description}"
         else:
             ascci = f"{self._clinguin_title}{self.titles[process]}"
-            return f"{inspect.cleandoc(ascci)}\n\n{description}\n{self.descriptions[process]}"
+            return_value = f"{inspect.cleandoc(ascci)}\n\n{description}\n{self.descriptions[process]}"
+
+        return return_value
 
     def _import_classes(self, path):
         if os.path.isfile(path):
@@ -135,11 +137,10 @@ def _import_files_from_path_array(self, file_paths, module=""):
                 if module != "":
                     try:
                         importlib.import_module(module + "." + file_name)
-                    except Exception:
-                        print("Could not import module: " + module + "." + file_name)
-                        print("<<<BEGIN-STACK-TRACE>>>")
-                        traceback.print_exc()
-                        print("<<<END-STACK-TRACE>>>")
+                    except Exception as ex:
+                        raise Exception(
+                            "Could not import module: " + module + "." + file_name
+                        ) from ex
                 else:
                     importlib.import_module(file_name)
 
@@ -153,7 +154,7 @@ def _recursive_import(self, full_path, rec_path, module):
                     folder_paths.append(entity.path)
                 elif entity.is_file():
                     file_paths.append(entity.path)
-        except Exception:
+        except Exception as ex:
             print("<<<BEGIN-STACK-TRACE>>>")
             traceback.print_exc()
             print("<<<END-STACK-TRACE>>>")
@@ -161,7 +162,7 @@ def _recursive_import(self, full_path, rec_path, module):
                 "Could not find path for importing libraries: "
                 + os.path.join(full_path, rec_path)
                 + ". Therefore program is terminating now (full stacktrace is printed below)."
-            )
+            ) from ex
 
         self._import_files_from_path_array(file_paths)
 
@@ -392,10 +393,11 @@ def _select_subclass_and_add_custom_arguments(
                 group = parser.add_argument_group(full_class_name)
                 sub_class.register_options(group)
 
-                should_show_frontend_syntax = (
-                    self._show_frontend_syntax == ShowFrontendSyntaxEnum.SHOW
-                    or self._show_frontend_syntax == ShowFrontendSyntaxEnum.FULL
-                )
+                should_show_frontend_syntax = self._show_frontend_syntax in [
+                    ShowFrontendSyntaxEnum.SHOW,
+                    ShowFrontendSyntaxEnum.FULL,
+                ]
+
                 if should_show_frontend_syntax and hasattr(
                     sub_class, "available_syntax"
                 ):
diff --git a/clinguin/server/application/attribute.py b/clinguin/server/application/attribute.py
index 3fce52ce..87a1e5b4 100644
--- a/clinguin/server/application/attribute.py
+++ b/clinguin/server/application/attribute.py
@@ -9,13 +9,19 @@ class AttributeDto:
     Objects of this class represent the attributes in the json convertible hierarchy.
     """
 
-    def __init__(self, id, key, value):
-        self.id = str(id)
+    def __init__(self, cid, key, value):
+        self.id = str(cid)  # pylint: disable=C0103
         self.key = str(key)
         self.value = str(value)
 
-    def to_JSON(self):
+    def to_JSON(self):  # pylint: disable=C0103
+        """
+        Converts the object (self) to a json representation.
+        """
         return json.dumps(self, default=lambda o: o.__dict__)
 
     def clone(self):
+        """
+        Creates a new AttributeDto object with the same properties.
+        """
         return AttributeDto(self.id, self.key, self.value)
diff --git a/clinguin/server/application/backends/__init__.py b/clinguin/server/application/backends/__init__.py
index 463c98d3..8904599c 100644
--- a/clinguin/server/application/backends/__init__.py
+++ b/clinguin/server/application/backends/__init__.py
@@ -4,8 +4,8 @@
 from clinguin.server.application.backends.clingo_backend import ClingoBackend
 from clinguin.server.application.backends.clingraph_backend import ClingraphBackend
 from clinguin.server.application.backends.explanation_backend import ExplanationBackend
-from clinguin.server.application.backends.temporal_backend import TemporalBackend
 from clinguin.server.application.backends.singleshot_backend import SingleShotBackend
+from clinguin.server.application.backends.temporal_backend import TemporalBackend
 
 __all__ = [
     ClingoBackend.__name__,
diff --git a/clinguin/server/application/backends/clingo_backend.py b/clinguin/server/application/backends/clingo_backend.py
index af5c234a..496c82b5 100644
--- a/clinguin/server/application/backends/clingo_backend.py
+++ b/clinguin/server/application/backends/clingo_backend.py
@@ -1,3 +1,4 @@
+# pylint: disable=R0801
 """
 Module that contains the ClingoBackend.
 """
@@ -7,17 +8,15 @@
 from clingo.script import enable_python
 
 from clinguin.server import UIFB, ClinguinBackend, StandardJsonEncoder
-from clinguin.server.application.backends.standard_utils.brave_cautious_helper import *
-
-# Self defined
-from clinguin.utils.errors import NoModelError
 
 enable_python()
 
 
 class ClingoBackend(ClinguinBackend):
     """
-    The ClingoBackend class is the backend that is selected by default. It provides basic functionality to argue bravely and cautiously. Further it provides several policies for assumptions, atoms and externals.
+    The ClingoBackend class is the backend that is selected by default.
+    It provides basic functionality to argue bravely and cautiously.
+    Further it provides several policies for assumptions, atoms and externals.
     """
 
     def __init__(self, args):
@@ -105,15 +104,19 @@ def _init_ctl(self):
                     existant_file_counter += 1
                 except Exception:
                     self._logger.critical(
-                        f'Failed to load file "{f}" (there is likely a syntax error in this logic program file).'
+                        "Failed to load file %s (there is likely a syntax error in this logic program file).",
+                        f,
                     )
             else:
                 self._logger.critical(
-                    f'File "{f}" does not exist, this file is skipped.'
+                    "File %s does not exist, this file is skipped.", f
                 )
 
         if existant_file_counter == 0:
-            exception_string = "None of the provided domain files exists, but at least one syntactically valid domain file must be specified. Exiting!"
+            exception_string = (
+                "None of the provided domain files exists, but at least one syntactically"
+                + "valid domain file must be specified. Exiting!"
+            )
             self._logger.critical(exception_string)
             raise Exception(exception_string)
 
@@ -170,7 +173,8 @@ def _add_assumption(self, predicate_symbol):
 
     def clear_assumptions(self):
         """
-        Policy: clear_assumptions removes all assumptions, then basically ''resets'' the backend (i.e. it regrounds, etc.) and finally updates the model and returns the updated gui as a Json structure.
+        Policy: clear_assumptions removes all assumptions, then basically ''resets'' the backend
+        (i.e. it regrounds, etc.) and finally updates the model and returns the updated gui as a Json structure.
         """
         self._end_browsing()
         self._assumptions = set()
@@ -224,7 +228,8 @@ def remove_assumption_signature(self, predicate):
 
     def clear_atoms(self):
         """
-        Policy: clear_atoms removes all atoms, then basically ''resets'' the backend (i.e. it regrounds, etc.) and finally updates the model and returns the updated gui as a Json structure.
+        Policy: clear_atoms removes all atoms, then basically ''resets'' the backend (i.e. it regrounds, etc.)
+        and finally updates the model and returns the updated gui as a Json structure.
         """
         self._end_browsing()
         self._atoms = set()
@@ -236,7 +241,8 @@ def clear_atoms(self):
 
     def add_atom(self, predicate):
         """
-        Policy: Adds an assumption and basically resets the rest of the application (reground) - finally it returns the udpated Json structure.
+        Policy: Adds an assumption and basically resets the rest of the application (reground) -
+        finally it returns the udpated Json structure.
         """
         predicate_symbol = parse_term(predicate)
         if predicate_symbol not in self._atoms:
@@ -250,7 +256,8 @@ def add_atom(self, predicate):
 
     def remove_atom(self, predicate):
         """
-        Policy: Removes an assumption and basically resets the rest of the application (reground) - finally it returns the udpated Json structure.
+        Policy: Removes an assumption and basically resets the rest of the application (reground) -
+        finally it returns the udpated Json structure.
         """
         predicate_symbol = parse_term(predicate)
         if predicate_symbol in self._atoms:
@@ -339,10 +346,10 @@ def select(self):
         Policy: Select the current solution during browsing
         """
         self._end_browsing()
-        last_model_symbols = self._uifb._conseq["auto"]
+        last_model_symbols = self._uifb.get_auto_conseq()
         symbols_to_ignore = self._externals["true"]
         symbols_to_ignore.union(self._externals["false"])
-        for s in last_model_symbols:
+        for s in last_model_symbols:  # pylint: disable=E1133
             if s not in symbols_to_ignore:
                 self._add_assumption(s)
         self._update_uifb()
diff --git a/clinguin/server/application/backends/clingraph_backend.py b/clinguin/server/application/backends/clingraph_backend.py
index c0f9f3c9..4b6dd872 100644
--- a/clinguin/server/application/backends/clingraph_backend.py
+++ b/clinguin/server/application/backends/clingraph_backend.py
@@ -1,3 +1,4 @@
+# pylint: disable=R0801
 """
 Module that contains the ClingraphBackend.
 """
@@ -5,26 +6,25 @@
 import textwrap
 from pathlib import Path
 
-import clorm
 from clingo import Control
 from clingo.symbol import Function, String
 from clingraph import Factbase, compute_graphs, render
 from clingraph.clingo_utils import ClingraphContext
 from clorm import Raw
 
-from clinguin.server import StandardJsonEncoder
 from clinguin.server.application.backends.clingo_backend import ClingoBackend
 from clinguin.server.data.attribute import AttributeDao
-from clinguin.server.data.uifb import UIFB
 
 # Self defined
-from clinguin.utils import NoModelError, StandardTextProcessing
+from clinguin.utils import StandardTextProcessing
 
 
 class ClingraphBackend(ClingoBackend):
     """
-    Extends ClingoBackend. With this Backend it is possible to create Clingraph-graphs by Clinguin. This can be done by both saving them to a file and by sending them to the client.
-    The process of sending them to the client includes the conversion to a Base64 encoding (so the binary images are encoded as a UTF-8 String) that is then send to the client.
+    Extends ClingoBackend. With this Backend it is possible to create Clingraph-graphs by Clinguin.
+    This can be done by both saving them to a file and by sending them to the client.
+    The process of sending them to the client includes the conversion to a Base64 encoding
+    (so the binary images are encoded as a UTF-8 String) that is then send to the client.
     """
 
     def __init__(self, args):
@@ -217,23 +217,23 @@ def _compute_clingraph_graphs(self, prg):
                     existant_file_counter += 1
                 except Exception:
                     self._logger.critical(
-                        f'Failed to load file "{f}" (there is likely a syntax error in this logic program file).'
+                        "Failed to load file %s (there is likely a syntax error in this logic program file).",
+                        f,
                     )
             else:
                 self._logger.critical(
-                    f'File "{f}" does not exist, this file is skipped.'
+                    "File %s does not exist, this file is skipped.", f
                 )
 
         if existant_file_counter == 0:
-            exception_string = "None of the provided clingraph files exists, but at least one syntactically valid clingraph file must be specified. Exiting!"
+            exception_string = (
+                "None of the provided clingraph files exists, but at least one syntactically"
+                + "valid clingraph file must be specified. Exiting!"
+            )
+
             self._logger.critical(exception_string)
             raise Exception(exception_string)
 
-        """
-        for f in self._clingraph_files:
-            ctl.load(f)
-        """
-
         ctl.add("base", [], prg)
         ctl.add("base", [], self._backend_state_prg)
         ctl.ground([("base", [])], ClingraphContext())
@@ -283,7 +283,8 @@ def _replace_uifb_with_b64_images(self, graphs):
             splits = attribute_value.split(self._attribute_image_value_seperator, 1)
             if len(splits) < 2:
                 raise ValueError(
-                    f"The images for clingraph should have format {self._attribute_image_value}{self._attribute_image_value_seperator}name"
+                    f"The images for clingraph should have format {self._attribute_image_value}"
+                    + f"{self._attribute_image_value_seperator}name"
                 )
             graph_name = splits[1]
             key_image = self._create_image_from_graph(graphs, key=graph_name)
@@ -293,8 +294,7 @@ def _replace_uifb_with_b64_images(self, graphs):
                 Raw(Function(str(attribute.key), [])),
                 Raw(String(str(base64_key_image))),
             )
-            self._uifb._factbase.remove(attribute)
-            self._uifb._factbase.add(new_attribute)
+            self._uifb.replace_attribute(attribute, new_attribute)
 
     def _create_image_from_graph(self, graphs, position=None, key=None):
         graphs = graphs[0]
diff --git a/clinguin/server/application/backends/explanation_backend.py b/clinguin/server/application/backends/explanation_backend.py
index 09171662..4b9711f4 100644
--- a/clinguin/server/application/backends/explanation_backend.py
+++ b/clinguin/server/application/backends/explanation_backend.py
@@ -4,13 +4,9 @@
 
 import textwrap
 
-from clingo import parse_term
 from clingo.script import enable_python
 
-from clinguin.server import UIFB
 from clinguin.server.application.backends.clingo_backend import ClingoBackend
-from clinguin.server.application.backends.standard_utils.brave_cautious_helper import *
-from clinguin.utils import NoModelError
 
 enable_python()
 
@@ -30,10 +26,10 @@ def __init__(self, args):
             try:
                 name = a.split(",")[0]
                 arity = int(a.split(",")[1])
-            except:
+            except Exception as ex:
                 raise ValueError(
                     "Argument assumption_signature must have format name,arity"
-                )
+                ) from ex
             for s in self._ctl.symbolic_atoms:
                 if s.symbol.match(name, arity):
                     self._mc_base_assumptions.add(s.symbol)
@@ -84,7 +80,7 @@ def _backend_state_prg(self):
         prg = super()._backend_state_prg
         if self._uifb.is_unsat:
             self._logger.info("UNSAT Answer, will add explanation")
-            clingo_core = self._uifb._unsat_core
+            clingo_core = self._uifb.get_unsat_core()
             clingo_core_symbols = [self._lit2symbol[s] for s in clingo_core if s != -1]
             muc_core = self._get_minimum_uc(clingo_core_symbols)
             for s in muc_core:
diff --git a/clinguin/server/application/backends/singleshot_backend.py b/clinguin/server/application/backends/singleshot_backend.py
index d1887f35..625b7c7f 100644
--- a/clinguin/server/application/backends/singleshot_backend.py
+++ b/clinguin/server/application/backends/singleshot_backend.py
@@ -5,19 +5,16 @@
 
 from clingo import Control, parse_term
 from clingo.script import enable_python
-# Self defined
-from clinguin.utils.errors import NoModelError
-from clinguin.server import StandardJsonEncoder
-from clinguin.server import UIFB
-from clinguin.server import ClinguinBackend
-from clinguin.server.application.backends.standard_utils.brave_cautious_helper import *
 
+from clinguin.server import UIFB, ClinguinBackend, StandardJsonEncoder
 
 enable_python()
 
+
 class SingleShotBackend(ClinguinBackend):
     """
-    The Single-shot Backend class is a backend that is reduced to the most important functionality. It only contains policies for adding and removing atoms and will reground after each user input.
+    The Single-shot Backend class is a backend that is reduced to the most important functionality.
+    It only contains policies for adding and removing atoms and will reground after each user input.
     """
 
     def __init__(self, args):
@@ -27,8 +24,8 @@ def __init__(self, args):
         self._ui_files = args.ui_files
 
         # For browising
-        self._handler=None
-        self._iterator=None
+        self._handler = None
+        self._iterator = None
 
         # To make static linters happy
         self._atoms = set()
@@ -41,8 +38,12 @@ def __init__(self, args):
         self._ground()
 
         include_unsat_msg = not args.ignore_unsat_msg
-        self._uifb=UIFB(self._ui_files, self._constants, include_menu_bar=args.include_menu_bar, include_unsat_msg=include_unsat_msg)
-
+        self._uifb = UIFB(
+            self._ui_files,
+            self._constants,
+            include_menu_bar=args.include_menu_bar,
+            include_unsat_msg=include_unsat_msg,
+        )
 
     # ---------------------------------------------
     # Required methods
@@ -55,43 +56,56 @@ def get(self):
         if self._uifb.is_empty:
             self._update_uifb()
         self._logger.debug(self._uifb)
-        json_structure =  StandardJsonEncoder.encode(self._uifb)
+        json_structure = StandardJsonEncoder.encode(self._uifb)
         return json_structure
 
     @classmethod
     def register_options(cls, parser):
-        parser.add_argument('--domain-files', nargs='+', help='Files',metavar='')
-        parser.add_argument('--ui-files', nargs='+', help='Files for the element generation',metavar='')
-        parser.add_argument('-c','--const',  nargs='+', help='Constant passed to clingo, <id>=<term> replaces term occurrences of <id> with <term>',metavar='')
-        parser.add_argument('--include-menu-bar',
-                    action='store_true',
-                    help='Inlcude a menu bar with options: Next, Select and Clear')
-        parser.add_argument('--ignore-unsat-msg',
-                    action='store_true',
-                    help='The automatic pop-up message in the UI when the domain files are UNSAT, will be ignored.')
+        parser.add_argument("--domain-files", nargs="+", help="Files", metavar="")
+        parser.add_argument(
+            "--ui-files", nargs="+", help="Files for the element generation", metavar=""
+        )
+        parser.add_argument(
+            "-c",
+            "--const",
+            nargs="+",
+            help="Constant passed to clingo, <id>=<term> replaces term occurrences of <id> with <term>",
+            metavar="",
+        )
+        parser.add_argument(
+            "--include-menu-bar",
+            action="store_true",
+            help="Inlcude a menu bar with options: Next, Select and Clear",
+        )
+        parser.add_argument(
+            "--ignore-unsat-msg",
+            action="store_true",
+            help="The automatic pop-up message in the UI when the domain files are UNSAT, will be ignored.",
+        )
 
     # ---------------------------------------------
     # Private methods
     # ---------------------------------------------
 
     def _init_ctl(self):
-        self._ctl = Control(['0']+self._constants)
+        self._ctl = Control(["0"] + self._constants)
         for f in self._domain_files:
             try:
                 self._ctl.load(str(f))
             except Exception as e:
                 self._logger.critical(str(e))
-                self._logger.critical("Failed to load modules (there is likely a syntax error in your logic program), now exiting - see previous stack trace for more information.")
+                self._logger.critical(
+                    "Failed to load modules (there is likely a syntax error in your logic program),"
+                    + "now exiting - see previous stack trace for more information."
+                )
                 sys.exit()
 
         for atom in self._atoms:
-            self._ctl.add("base",[],str(atom) + ".")
-
+            self._ctl.add("base", [], str(atom) + ".")
 
     def _ground(self):
         self._ctl.ground([("base", [])])
 
-
     def _end_browsing(self):
         if self._handler:
             self._handler.cancel()
@@ -109,15 +123,17 @@ def _backend_state_prg(self):
         """
         state_prg = "#defined _clinguin_browsing/0. "
         if self._is_browsing:
-            state_prg+="_clinguin_browsing."
+            state_prg += "_clinguin_browsing."
         if self._uifb.is_unsat:
-            state_prg+="_clinguin_unsat."
+            state_prg += "_clinguin_unsat."
         return state_prg
 
     def _update_uifb_consequences(self):
         self._uifb.update_all_consequences(self._ctl, set())
         if self._uifb.is_unsat:
-            self._logger.error("domain files are UNSAT. Setting _clinguin_unsat to true")
+            self._logger.error(
+                "domain files are UNSAT. Setting _clinguin_unsat to true"
+            )
 
     def _update_uifb_ui(self):
         self._uifb.update_ui(self._backend_state_prg)
@@ -126,14 +142,14 @@ def _update_uifb(self):
         self._update_uifb_consequences()
         self._update_uifb_ui()
 
-
     # ---------------------------------------------
     # Policies
     # ---------------------------------------------
 
     def clear_atoms(self):
         """
-        Policy: clear_atoms removes all atoms, then basically ''resets'' the backend (i.e. it regrounds, etc.) and finally updates the model and returns the updated gui as a Json structure.
+        Policy: clear_atoms removes all atoms, then basically ''resets'' the backend (i.e. it regrounds, etc.)
+        and finally updates the model and returns the updated gui as a Json structure.
         """
         self._end_browsing()
         self._atoms = set()
@@ -145,7 +161,8 @@ def clear_atoms(self):
 
     def add_atom(self, predicate):
         """
-        Policy: Adds an assumption and basically resets the rest of the application (reground) - finally it returns the udpated Json structure.
+        Policy: Adds an assumption and basically resets the rest of the application (reground) -
+        finally it returns the udpated Json structure.
         """
         predicate_symbol = parse_term(predicate)
         if predicate_symbol not in self._atoms:
@@ -157,9 +174,10 @@ def add_atom(self, predicate):
             self._update_uifb()
         return self.get()
 
-    def remove_atom(self,predicate):
+    def remove_atom(self, predicate):
         """
-        Policy: Removes an assumption and basically resets the rest of the application (reground) - finally it returns the udpated Json structure.
+        Policy: Removes an assumption and basically resets the rest of the application (reground) -
+        finally it returns the udpated Json structure.
         """
         predicate_symbol = parse_term(predicate)
         if predicate_symbol in self._atoms:
@@ -170,7 +188,7 @@ def remove_atom(self,predicate):
             self._update_uifb()
         return self.get()
 
-    def show_solution(self, opt_mode='ignore'):
+    def show_solution(self, opt_mode="ignore"):
         """
         Policy: Shows the first (optimal) solution found
         Arguments:
@@ -178,7 +196,7 @@ def show_solution(self, opt_mode='ignore'):
         """
         self._init_ctl()
         self._ground()
-        optimizing = opt_mode in ['optN','opt']
+        optimizing = opt_mode in ["optN", "opt"]
         self._ctl.configuration.solve.opt_mode = opt_mode
         self._ctl.configuration.solve.models = 0
         self._handler = self._ctl.solve(yield_=True)
@@ -188,14 +206,12 @@ def show_solution(self, opt_mode='ignore'):
             while optimizing and not model.optimality_proven:
                 self._logger.info("Skipping non-optimal model")
                 model = next(self._iterator)
-            self._uifb.set_auto_conseq(model.symbols(shown=True,atoms=False))
+            self._uifb.set_auto_conseq(model.symbols(shown=True, atoms=False))
             self._update_uifb_ui()
         except StopIteration:
             self._logger.info("No solutions")
             self._end_browsing()
             self._update_uifb()
-            self._uifb.add_message("Browsing Information","No solutions")
+            self._uifb.add_message("Browsing Information", "No solutions")
 
         return self.get()
-    
-
diff --git a/clinguin/server/application/backends/standard_utils/brave_cautious_helper.py b/clinguin/server/application/backends/standard_utils/brave_cautious_helper.py
index 0afec986..12a37a6e 100644
--- a/clinguin/server/application/backends/standard_utils/brave_cautious_helper.py
+++ b/clinguin/server/application/backends/standard_utils/brave_cautious_helper.py
@@ -1,7 +1,13 @@
 """
 This module contains one string (brave_cautious_externals) that is helpful for the brave-cautious implementation.
 """
-brave_cautious_externals = """
+
+
+def get_brave_cautious_externals():
+    """
+    Returns the brave/cautious encoding.
+    """
+    return """
 #external show_brave.
 #external show_cautious.
 #external show_untagged.
@@ -16,17 +22,17 @@
 #show attribute(ID,NAME,VALUE): _cautious(attribute(ID,NAME,VALUE)), show_cautious.
 #show callback(ID,ACTION,FUNCT): _cautious(callback(ID,ACTION,FUNCT)), show_cautious.
 
-#show element(ID,TYPE,PARENT): 
+#show element(ID,TYPE,PARENT):
     element(ID,TYPE,PARENT),
-    not _brave(element(ID,TYPE,PARENT)), 
-    not _cautious(element(ID,TYPE,PARENT)), 
+    not _brave(element(ID,TYPE,PARENT)),
+    not _cautious(element(ID,TYPE,PARENT)),
     show_untagged.
-#show attribute(ID,NAME,VALUE): 
+#show attribute(ID,NAME,VALUE):
     attribute(ID,NAME,VALUE),
-    not _brave(attribute(ID,NAME,VALUE)), 
-    not _cautious(attribute(ID,NAME,VALUE)), 
+    not _brave(attribute(ID,NAME,VALUE)),
+    not _cautious(attribute(ID,NAME,VALUE)),
     show_untagged.
-#show callback(ID,ACTION,FUNCT): 
+#show callback(ID,ACTION,FUNCT):
     callback(ID,ACTION,FUNCT),
     not _brave(callback(ID,ACTION,FUNCT)),
     not _cautious(callback(ID,ACTION,FUNCT)),
@@ -35,13 +41,13 @@
 #show .
 
 
-#show element(ID,TYPE,PARENT): 
+#show element(ID,TYPE,PARENT):
     element(ID,TYPE,PARENT),
     show_all.
-#show attribute(ID,NAME,VALUE): 
+#show attribute(ID,NAME,VALUE):
     attribute(ID,NAME,VALUE),
     show_all.
-#show callback(ID,ACTION,FUNCT): 
+#show callback(ID,ACTION,FUNCT):
     callback(ID,ACTION,FUNCT),
     show_all.
 
diff --git a/clinguin/server/application/backends/temporal_backend.py b/clinguin/server/application/backends/temporal_backend.py
index 816b92c9..88b0ef6d 100644
--- a/clinguin/server/application/backends/temporal_backend.py
+++ b/clinguin/server/application/backends/temporal_backend.py
@@ -7,9 +7,7 @@
 from clingo.symbol import Function, Number
 
 # Self defined
-from clinguin.server import UIFB
 from clinguin.server.application.backends.clingo_backend import ClingoBackend
-from clinguin.server.application.backends.standard_utils.brave_cautious_helper import *
 
 enable_python()
 
@@ -20,10 +18,12 @@ class TemporalBackend(ClingoBackend):
     """
 
     def __init__(self, args):
+        super().__init__(args)
+
         self._step = 1
         self._last_grounded_step = 0
         self._full_plan = None
-        super().__init__(args)
+        self._model = None
 
     def _init_ctl(self):
         self._step = 1
@@ -83,6 +83,9 @@ def _find_plan(self):
         return self._full_plan
 
     def find_plan(self):
+        """
+        TODO -> Add documentation!
+        """
         if not self._full_plan:
             self._find_incrementally()
 
@@ -93,6 +96,9 @@ def find_plan(self):
         return self.get()
 
     def assume_and_step(self, predicate):
+        """
+        TODO -> Add documentation!
+        """
         predicate_symbol = parse_term(predicate)
         self._add_assumption(predicate_symbol)
         self._step += 1
@@ -101,8 +107,14 @@ def assume_and_step(self, predicate):
         self._update_uifb()
         return self.get()
 
-    def remove_assumption(self, predicate):
+    def remove_assumption(self, predicate):  # pylint: disable=W0613
+        """
+        TODO -> Add documentation!
+        """
         raise NotImplementedError()
 
-    def next_solution(self):
+    def next_solution(self, opt_mode=None):  # pylint: disable=W0613
+        """
+        TODO -> Add documentation!
+        """
         raise NotImplementedError()
diff --git a/clinguin/server/application/callback.py b/clinguin/server/application/callback.py
index d1bf027c..f4d511a7 100644
--- a/clinguin/server/application/callback.py
+++ b/clinguin/server/application/callback.py
@@ -6,16 +6,24 @@
 
 class CallbackDto:
     """
-    This class represents a Callback that is Json convertible. Therefore objects of this class are part of the hierarchy that will get converted to Json by the endpoints on sending the reply.
+    This class represents a Callback that is Json convertible.
+    Therefore objects of this class are part of the hierarchy that will get converted to Json by the
+    endpoints on sending the reply.
     """
 
-    def __init__(self, id, action, policy):
-        self.id = str(id)
+    def __init__(self, cid, action, policy):
+        self.id = str(cid)  # pylint: disable=C0103
         self.action = str(action)
         self.policy = str(policy)
 
-    def to_JSON(self):
+    def to_JSON(self):  # pylint: disable=C0103
+        """
+        Converts a callback dto to json.
+        """
         return json.dumps(self, default=lambda o: o.__dict__)
 
     def clone(self):
+        """
+        Creates a new CallbackDto object with the same properties.
+        """
         return CallbackDto(self.id, self.action, self.policy)
diff --git a/clinguin/server/application/clinguin_backend.py b/clinguin/server/application/clinguin_backend.py
index cb01ce0e..fe87b937 100644
--- a/clinguin/server/application/clinguin_backend.py
+++ b/clinguin/server/application/clinguin_backend.py
@@ -10,7 +10,8 @@
 
 class ClinguinBackend(CustomArgs):
     """
-    Root class of all backends (here backend refers to the type like ClingoBackend, etc.). Just defines the logger, the standard arguments and get().
+    Root class of all backends (here backend refers to the type like ClingoBackend, etc.).
+    Just defines the logger, the standard arguments and get().
     """
 
     def __init__(self, args):
diff --git a/clinguin/server/application/element.py b/clinguin/server/application/element.py
index bcfbfeeb..91a20162 100644
--- a/clinguin/server/application/element.py
+++ b/clinguin/server/application/element.py
@@ -6,39 +6,47 @@
 
 class ElementDto:
     """
-    The class that represents elements that are Json convertible, i.e. these components are the heart of the Json convertible hierarchy.
+    The class that represents elements that are Json convertible,
+    i.e. these components are the heart of the Json convertible hierarchy.
     """
 
-    def __init__(self, id, type, parent):
-        self.id = str(id)
-        self.type = str(type)
+    def __init__(self, cid, element_type, parent):
+        self.id = str(cid)  # pylint: disable=C0103
+        self.type = str(element_type)
         self.parent = str(parent)
         self.attributes = []
         self.callbacks = []
         self.children = []
 
     def set_attributes(self, attributes):
+        """
+        Sets (all) the attributes of this element.
+        """
         self.attributes = attributes
 
     def add_attribute(self, attribute):
+        """
+        Adds an attribute to this element.
+        """
         self.attributes.append(attribute)
 
     def set_callbacks(self, callbacks):
+        """
+        Sets (all) the callbacks of this element.
+        """
         self.callbacks = callbacks
 
-    def add_child(self, child):
-        self.children.append(child)
-
-    def get_child_per_index(self, index: int):
-        return self.children[0]
-
-    def amount_of_children(self) -> int:
-        return len(self.children)
-
-    def to_JSON(self):
+    def to_JSON(self):  # pylint: disable=C0103
+        """
+        Converts the element to a json.
+        """
         return json.dumps(self, default=lambda o: str(o).__dict__)
 
     def clone(self):
+        """
+        Creates a new ElementDto object with the same properties as the self object.
+        Note that all attributes, callbacks and children (elements) are deep copied/cloned.
+        """
         clone = ElementDto(self.id, self.type, self.parent)
 
         cloned_attributes = []
@@ -58,10 +66,8 @@ def clone(self):
 
         return clone
 
-    def generate_table(self, table):
-        table[str(self.id)] = self
-
-        for child in self.children:
-            child.generate_table(table)
-
-        return table
+    def add_child(self, child):
+        """
+        Adds a child (element) to this element.
+        """
+        self.children.append(child)
diff --git a/clinguin/server/application/standard_json_encoder.py b/clinguin/server/application/standard_json_encoder.py
index 624bb61b..c00af262 100644
--- a/clinguin/server/application/standard_json_encoder.py
+++ b/clinguin/server/application/standard_json_encoder.py
@@ -40,7 +40,9 @@ def encode(cls, uifb):
     @classmethod
     def _generate_hierarchy(cls, uifb, hierarchy_root, elements_dict):
         """
-        Converts the UIFB into an Json Hierarchy (which is represented by an ElementDto). Therefore it first gets all dependencies, then orders the elements according to the dependencies and then adds for each element its attributes, callbacks and children.
+        Converts the UIFB into an Json Hierarchy (which is represented by an ElementDto).
+        Therefore it first gets all dependencies, then orders the elements according to the dependencies
+        and then adds for each element its attributes, callbacks and children.
 
         Arguments:
             uifb : UIFB
@@ -56,19 +58,19 @@ def _generate_hierarchy(cls, uifb, hierarchy_root, elements_dict):
             elements_info[w.id] = {"parent": w.parent, "type": w.type}
             dependency.append((w.id, w.parent))
 
-        DG = nx.DiGraph(dependency)
-        order = list(reversed(list(nx.topological_sort(DG))))
+        directed_graph = nx.DiGraph(dependency)
+        order = list(reversed(list(nx.topological_sort(directed_graph))))
 
-        attrs = uifb.get_attributesGrouped()
+        attrs = uifb.get_attributes_grouped()
         attrs = {a[0]: list(a[1]) for a in attrs}
-        cbs = uifb.get_callbacksGrouped()
+        cbs = uifb.get_callbacks_grouped()
         cbs = {a[0]: list(a[1]) for a in cbs}
 
         for element_id in order:
             if str(element_id) == str(hierarchy_root.id):
                 continue
 
-            if not element_id in elements_info:
+            if element_id not in elements_info:
                 logger.critical(
                     "The provided element id (ID : %s) could not be found!",
                     str(element_id),
@@ -79,9 +81,9 @@ def _generate_hierarchy(cls, uifb, hierarchy_root, elements_dict):
                     + ") could not be found!"
                 )
 
-            type = elements_info[element_id]["type"]
+            element_type = elements_info[element_id]["type"]
             parent = elements_info[element_id]["parent"]
-            element = ElementDto(element_id, type, parent)
+            element = ElementDto(element_id, element_type, parent)
 
             if element_id in attrs:
                 elem_attributes = [
diff --git a/clinguin/server/data/attribute.py b/clinguin/server/data/attribute.py
index d29d0ba4..dff30fa9 100644
--- a/clinguin/server/data/attribute.py
+++ b/clinguin/server/data/attribute.py
@@ -1,3 +1,4 @@
+# pylint: disable=R0903
 """
 Module that contains the AttributeDao.
 """
diff --git a/clinguin/server/data/callback.py b/clinguin/server/data/callback.py
index 5e330e81..30cc005e 100644
--- a/clinguin/server/data/callback.py
+++ b/clinguin/server/data/callback.py
@@ -1,3 +1,4 @@
+# pylint: disable=R0903
 """
 Module that contains the CallbackDao.
 """
diff --git a/clinguin/server/data/element.py b/clinguin/server/data/element.py
index 83d56b70..2a92b26b 100644
--- a/clinguin/server/data/element.py
+++ b/clinguin/server/data/element.py
@@ -1,3 +1,4 @@
+# pylint: disable=R0903
 """
 Module that contains the ElementDao.
 """
diff --git a/clinguin/server/data/uifb.py b/clinguin/server/data/uifb.py
index 5f081f07..a2bc5e3e 100644
--- a/clinguin/server/data/uifb.py
+++ b/clinguin/server/data/uifb.py
@@ -1,3 +1,4 @@
+# pylint: disable=R0904
 """
 Module that contains the UIFB class.
 """
@@ -5,7 +6,7 @@
 from pathlib import Path
 
 import clorm
-from clingo import Control, parse_term
+from clingo import Control
 from clingo.symbol import Function, Number, String
 from clorm import Raw
 
@@ -16,38 +17,12 @@
 from .element import ElementDao
 
 
-def symbols_to_facts(symbols):
-    return "\n".join([str(s) + "." for s in symbols])
-
-
-MENU_BAR = """
-element(m, menu_bar, window).
-element(menu_options, menu_bar_section, m).
-attribute(menu_options, label, "Options").
-element(menu_options_clear, menu_bar_section_item, menu_options).
-attribute(menu_options_clear, label, "Clear").
-attribute(menu_options_clear, accelerator, "Cmd+C").
-callback(menu_options_clear, click, clear_assumptions).
-element(menu_options_next, menu_bar_section_item, menu_options).
-attribute(menu_options_next, label, "Next").
-attribute(menu_options_next, accelerator, "Cmd+N").
-callback(menu_options_next, click, next_solution).
-element(menu_options_select, menu_bar_section_item, menu_options).
-attribute(menu_options_select, label, "Select").
-attribute(menu_options_select, accelerator, "Cmd+S").
-callback(menu_options_select, click, select)."""
-
-UNSAT_MSG = """
-element(message_unsat,message,window):-_clinguin_unsat.
-attribute(message_unsat,title,"Error"):-_clinguin_unsat.
-attribute(message_unsat,message,"Unsatisfiable output."):-_clinguin_unsat.
-attribute(message_unsat,type,error):-_clinguin_unsat.
-"""
-
-
 class UIFB:
     """
-    The UIFB is the low-level-access-class for handling clorm and clingo, regarding brave-cautious and other default things. This class provides functionality to create a factbase with brave-cautious extended files, functionality to query important things for clinguin, etc.
+    The UIFB is the low-level-access-class for handling clorm and clingo,
+    regarding brave-cautious and other default things.
+    This class provides functionality to create a factbase with brave-cautious extended files,
+    functionality to query important things for clinguin, etc.
     """
 
     unifiers = [ElementDao, AttributeDao, CallbackDao]
@@ -76,7 +51,7 @@ def __str__(self):
         s = "\nConsequences:\n==========\n"
         for k, v in self._conseq.items():
             s += f"{k} consequences: (tagged with {self._tags[k]})\n"
-            s += " ".join([str(s) for s in v])
+            s += " ".join([str(s) for s in v])  # pylint: disable=E1133
             s += "\n"
         s += "\nUI Factbase:\n=========\n"
         s += self._factbase.asp_str()
@@ -84,13 +59,24 @@ def __str__(self):
 
     @property
     def is_empty(self):
+        """
+        Checks whether the factbase is empty.
+        if so return true, else false.
+        """
         return self._factbase is None
 
     @property
     def is_unsat(self):
+        """
+        Checks for unsat.
+        Returns boolean.
+        """
         return self._unsat_core is not None
 
     def tag(self, symbols, tag):
+        """
+        TODO -> Documentation
+        """
         if tag is None:
             return symbols
         tagged = []
@@ -100,15 +86,19 @@ def tag(self, symbols, tag):
 
     @property
     def conseq_facts(self):
+        """
+        TODO -> Documentation
+        """
         conseq_facts = ""
         for c_type, symbols in self._conseq.items():
             if symbols is None:
                 # raise RuntimeError("Use update function before getting the program")
-                self._logger.warn(
-                    f"No {c_type} consequences where calculated. Update consequences before updating the UI."
+                self._logger.warning(
+                    "No %s consequences were calculated. Update consequences before updating the UI.",
+                    c_type,
                 )
                 continue
-            conseq_facts += symbols_to_facts(self.tag(symbols, self._tags[c_type]))
+            conseq_facts += UIFB.symbols_to_facts(self.tag(symbols, self._tags[c_type]))
 
         return conseq_facts
 
@@ -130,22 +120,26 @@ def ui_control(self, extra_ui_prg=""):
                     existant_file_counter += 1
                 except Exception:
                     self._logger.critical(
-                        f'Failed to load file "{f}" (there is likely a syntax error in this logic program file).'
+                        "Failed to load file %s (there is likely a syntax error in this logic program file).",
+                        f,
                     )
             else:
                 self._logger.critical(
-                    f'File "{f}" does not exist, this file is skipped.'
+                    "File %s does not exist, this file is skipped.", f
                 )
 
         if existant_file_counter == 0:
-            exception_string = "None of the provided ui files exists, but at least one syntactically valid ui file must be specified. Exiting!"
+            exception_string = (
+                "None of the provided ui files exists, but at least one syntactically valid ui"
+                + "file must be specified. Exiting!"
+            )
             self._logger.critical(exception_string)
             raise Exception(exception_string)
 
         if self._include_menu_bar:
-            uictl.add("base", [], MENU_BAR)
+            uictl.add("base", [], UIFB.get_menu_bar_ui_encoding())
         if self._include_unsat_msg:
-            uictl.add("base", [], UNSAT_MSG)
+            uictl.add("base", [], UIFB.get_unsat_messages_ui_encoding())
 
         uictl.add("base", [], extra_ui_prg)
         uictl.add("base", [], self.conseq_facts)
@@ -155,6 +149,9 @@ def ui_control(self, extra_ui_prg=""):
         return uictl
 
     def from_ctl(self, ctl):
+        """
+        Solves a control object and sets the result of the answer sets as the factbase symbols.
+        """
         with ctl.solve(yield_=True) as result:
             for m in result:
                 model_symbols = m.symbols(shown=True, atoms=True)
@@ -163,9 +160,21 @@ def from_ctl(self, ctl):
         return self._set_fb_symbols(symbols=model_symbols)
 
     def set_auto_conseq(self, model_symbols):
+        """
+        Sets the auto conseq.
+        """
         self._conseq["auto"] = model_symbols
 
+    def get_auto_conseq(self):
+        """
+        Gets the auto conseq.
+        """
+        return self._conseq["auto"]
+
     def update_all_consequences(self, ctl, assumptions=None):
+        """
+        Updates all consequences.
+        """
         c_types = ["brave", "cautious", "auto"]
         for c_type in c_types:
             try:
@@ -175,7 +184,10 @@ def update_all_consequences(self, ctl, assumptions=None):
                 return
 
     def update_ui(self, extra_ui_prg=""):
-        self._logger.debug(f"Computing Ui with additional program:\n{extra_ui_prg}")
+        """
+        Computes the answer sets for the ui and adds the resulting facts accordingly.
+        """
+        self._logger.debug("Computing Ui with additional program:\n%s", extra_ui_prg)
         uictl = self.ui_control(extra_ui_prg)
 
         with uictl.solve(yield_=True) as result:
@@ -192,16 +204,23 @@ def _compute_consequences(self, ctl, assumptions):
             model_symbols = None
             for m in result:
                 model_symbols = m.symbols(shown=True, atoms=True)
+
             if model_symbols is None:
-                self._logger.warn("Got an UNSAT result with the given domain encoding.")
+                self._logger.warning(
+                    "Got an UNSAT result with the given domain encoding."
+                )
                 self._unsat_core = result.core()
                 raise NoModelError()
-            else:
-                self._unsat_core = None
+
+            self._unsat_core = None
+
         return list(model_symbols)
 
     def update_consequence(self, c_type, ctl, assumptions=None):
-        self._logger.debug(f"Updating {c_type} consequences")
+        """
+        Computes for one consequence (brave/cautious/other) all consequences.
+        """
+        self._logger.debug("Updating %s consequences", c_type)
         if c_type in ["brave", "cautious"]:
             ctl.configuration.solve.models = 0
             ctl.configuration.solve.opt_mode = "ignore"
@@ -211,60 +230,141 @@ def update_consequence(self, c_type, ctl, assumptions=None):
         ctl.configuration.solve.enum_mode = c_type
         self._conseq[c_type] = self._compute_consequences(ctl, assumptions)
 
-    def add_message(self, title, message, type="info"):
+    def add_message(self, title, message, attribute_type="info"):
         """
         Adds a ''Message'' (aka. Notification/Pop-Up) for the user with a certain title and message.
         """
         self.add_element("message", "message", "window")
         self.add_attribute("message", "title", title)
         self.add_attribute("message", "message", message)
-        self.add_attribute("message", "type", type)
+        self.add_attribute("message", "type", attribute_type)
 
     # Manage factbase
 
-    def add_element(self, id, t, parent):
-        if type(id) == str:
-            id = Function(id, [])
-        if type(t) == str:
+    def add_element(self, cid, t, parent):
+        """
+        Adds an element to the factbase.
+        """
+        if isinstance(cid, str):
+            cid = Function(cid, [])
+        if isinstance(t, str):
             t = Function(t, [])
-        if type(parent) == str:
+        if isinstance(parent, str):
             parent = Function(parent, [])
-        self._factbase.add(ElementDao(Raw(id), Raw(t), Raw(parent)))
+        self._factbase.add(ElementDao(Raw(cid), Raw(t), Raw(parent)))
 
-    def add_attribute(self, id, key, value):
-        if type(id) == str:
-            id = Function(id, [])
-        if type(key) == str:
+    def add_attribute(self, cid, key, value):
+        """
+        Adds an attribute to the factbase.
+        """
+        if isinstance(cid, str):
+            cid = Function(cid, [])
+        if isinstance(key, str):
             key = Function(key, [])
-        if type(value) == str:
+        if isinstance(value, str):
             value = String(value)
-        if type(value) == int:
+        if isinstance(value, int):
             value = Number(value)
-        self._factbase.add(AttributeDao(Raw(id), Raw(key), Raw(value)))
+        self._factbase.add(AttributeDao(Raw(cid), Raw(key), Raw(value)))
 
     def get_elements(self):
+        """
+        Get all elements.
+        """
         return self._factbase.query(ElementDao).all()
 
     def get_attributes(self):
+        """
+        Get all attributes.
+        """
         return self._factbase.query(AttributeDao).all()
 
-    def get_attributesGrouped(self):
+    def get_callbacks(self):
+        """
+        Get all callbacks.
+        """
+        return self._factbase.query(CallbackDao).all()
+
+    def get_attributes_grouped(self):
+        """
+        Get all attributes grouped by element id.
+        """
         return self._factbase.query(AttributeDao).group_by(AttributeDao.id).all()
 
-    def get_callbacksGrouped(self):
+    def get_callbacks_grouped(self):
+        """
+        Get all callbacks grouped by element id.
+        """
         return self._factbase.query(CallbackDao).group_by(CallbackDao.id).all()
 
-    def get_callbacks(self):
-        return self._factbase.query(CallbackDao).all()
-
-    def get_attributesForElementId(self, element_id):
+    def get_attributes_for_element_id(self, element_id):
+        """
+        Get all attributes for one element id.
+        """
         return (
             self._factbase.query(AttributeDao)
             .where(AttributeDao.id == element_id)
             .all()
         )
 
-    def get_callbacksForElementId(self, element_id):
+    def get_callbacks_for_element_id(self, element_id):
+        """
+        Get all callbacks for one element id.
+        """
         return (
             self._factbase.query(CallbackDao).where(CallbackDao.id == element_id).all()
         )
+
+    def replace_attribute(self, old_attribute, new_attribute):
+        """
+        Replaces the old_attribute with the new_attribute.
+        """
+        self._factbase.remove(old_attribute)
+        self._factbase.add(new_attribute)
+
+    def get_unsat_core(self):
+        """
+        Gets the unsat core variable.
+        """
+        return self._unsat_core
+
+    @classmethod
+    def symbols_to_facts(cls, symbols):
+        """
+        Converts a iterable symbols to a string of facts.
+        """
+        return "\n".join([str(s) + "." for s in symbols])
+
+    @classmethod
+    def get_menu_bar_ui_encoding(cls):
+        """
+        Get the standard lp encoding for the menu bar.
+        """
+        return """
+element(m, menu_bar, window).
+element(menu_options, menu_bar_section, m).
+attribute(menu_options, label, "Options").
+element(menu_options_clear, menu_bar_section_item, menu_options).
+attribute(menu_options_clear, label, "Clear").
+attribute(menu_options_clear, accelerator, "Cmd+C").
+callback(menu_options_clear, click, clear_assumptions).
+element(menu_options_next, menu_bar_section_item, menu_options).
+attribute(menu_options_next, label, "Next").
+attribute(menu_options_next, accelerator, "Cmd+N").
+callback(menu_options_next, click, next_solution).
+element(menu_options_select, menu_bar_section_item, menu_options).
+attribute(menu_options_select, label, "Select").
+attribute(menu_options_select, accelerator, "Cmd+S").
+callback(menu_options_select, click, select)."""
+
+    @classmethod
+    def get_unsat_messages_ui_encoding(cls):
+        """
+        Get the standard unsat encoding for error messages.
+        """
+        return """
+element(message_unsat,message,window):-_clinguin_unsat.
+attribute(message_unsat,title,"Error"):-_clinguin_unsat.
+attribute(message_unsat,message,"Unsatisfiable output."):-_clinguin_unsat.
+attribute(message_unsat,type,error):-_clinguin_unsat.
+"""
diff --git a/clinguin/server/presentation/endpoints.py b/clinguin/server/presentation/endpoints.py
index e3827cdd..cfb23017 100644
--- a/clinguin/server/presentation/endpoints.py
+++ b/clinguin/server/presentation/endpoints.py
@@ -17,7 +17,9 @@
 
 class Endpoints:
     """
-    The endpoints class define the available endpoints the backend (this time backend refers to the general concept of backend, like a server backend) has. These are defined in the ''__init__'', and correspond to the three methods:
+    The endpoints class define the available endpoints the backend
+    (this time backend refers to the general concept of backend, like a server backend) has.
+    These are defined in the ''__init__'', and correspond to the three methods:
 
     Methods:
         health -> Json : Returns name, version and description of clinguin.
@@ -39,6 +41,10 @@ def __init__(self, args) -> None:
         self._backend = args.backend(args)
 
     async def health(self):
+        """
+        Health endpoint (/health) of the server-backend,
+        returns name, version and summary of clinguin.
+        """
         self._logger.info("--> Health")
         cuin = metadata("clinguin")
         return {
@@ -48,10 +54,22 @@ async def health(self):
         }
 
     async def standard_executor(self):
+        """
+        Get endpoint (/) of the server-backend,
+        calls the get() method of the respective backend (clinguin/clingo/clingraph/etc.).
+        The get() method is implemented by every backend.
+        """
         self._logger.info("--> %s:   get()", self._backend.__class__.__name__)
         return self._backend.get()
 
     async def policy_executor(self, backend_call_string: BackendPolicyDto):
+        """
+        Post endpoint (/backend) of the server-backend,
+        which can be used to call specific methods/functions of the backend.
+        It takes a backend_call_string, which is essentially a json defining a function to be called,
+        including arguments.
+        For example: {'function':'add_assumption(p(1))'}
+        """
         self._logger.debug("Got endpoint")
         symbol = clingo.parse_term(backend_call_string.function)
         function_name = symbol.name
diff --git a/clinguin/server/presentation/endpoints_helper.py b/clinguin/server/presentation/endpoints_helper.py
index e6f40563..47fce8e8 100644
--- a/clinguin/server/presentation/endpoints_helper.py
+++ b/clinguin/server/presentation/endpoints_helper.py
@@ -4,22 +4,22 @@
 import logging
 import traceback
 
-from ...utils import SERVER_ERROR_ALERT, CaseConverter, Logger
-
-# def sever_error_json(e):
-#     model = UIFB()
-#     model.add_message("Error","Server error")
-#     json_structure =  StandardJsonEncoder.encode(model)
-#     return json_structure
+from ...utils import CaseConverter, Logger, get_server_error_alert
 
 
 class EndpointsHelper:
     """
-    The EndpointsHelper class is responsible for getting the correct method in the ''backend'' (here backend refers to ClingoBackend, TemporalBackend, etc.). This is done via reflections, i.e. it checks if the method is in the backend, if yes the method it returned.
+    The EndpointsHelper class is responsible for getting the correct method in the ''backend''
+    (here backend refers to ClingoBackend, TemporalBackend, etc.). This is done via reflections,
+    i.e. it checks if the method is in the backend, if yes the method it returned.
     """
 
     @classmethod
     def call_function(cls, backend, name, args, kwargs):
+        """
+        Helper function that calls given a backend, a name for a function/method and arguments,
+        the respective function/method.
+        """
         logger = logging.getLogger(Logger.server_logger_name)
 
         found = False
@@ -42,7 +42,7 @@ def call_function(cls, backend, name, args, kwargs):
             except Exception as e:
                 logger.error(e)
                 logger.error(traceback.format_exc())
-                return SERVER_ERROR_ALERT
+                return get_server_error_alert()
 
                 # return sever_error_json(e)
         else:
diff --git a/clinguin/server_helper.py b/clinguin/server_helper.py
index 26cdbf37..de7f50db 100644
--- a/clinguin/server_helper.py
+++ b/clinguin/server_helper.py
@@ -16,7 +16,7 @@ def start(args):
     app = FastAPI()
 
     @app.on_event("startup")
-    async def startupEvent():
+    async def startup_event():
         Logger.setup_uvicorn_logger_on_startup(args.log_args)
 
     endpoints = Endpoints(args)
diff --git a/clinguin/utils/__init__.py b/clinguin/utils/__init__.py
index fc385b42..c0fd9a79 100644
--- a/clinguin/utils/__init__.py
+++ b/clinguin/utils/__init__.py
@@ -4,7 +4,7 @@
 from .attribute_types.utils.standard_text_processing import StandardTextProcessing
 from .case_converter import CaseConverter
 from .custom_args import CustomArgs
-from .errors import SERVER_ERROR_ALERT, NoModelError
+from .errors import NoModelError, get_server_error_alert
 from .logger import Logger
 
 __all__ = [
@@ -13,4 +13,5 @@
     CaseConverter.__name__,
     NoModelError.__name__,
     StandardTextProcessing.__name__,
+    get_server_error_alert.__name__,
 ]
diff --git a/clinguin/utils/attribute_types/boolean.py b/clinguin/utils/attribute_types/boolean.py
index 8e4d0e41..31874a0e 100644
--- a/clinguin/utils/attribute_types/boolean.py
+++ b/clinguin/utils/attribute_types/boolean.py
@@ -12,17 +12,24 @@ class BooleanType(Type):
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = StandardTextProcessing.parse_string_with_quotes(input)
+    def parse(cls, parse_input: str, logger):
+        parsed_string = StandardTextProcessing.parse_string_with_quotes(parse_input)
+
+        return_value = None
 
         if parsed_string.lower() == "true":
-            return True
+            return_value = True
         elif parsed_string.lower() == "false":
-            return False
+            return_value = False
         else:
             logger.error("Could not parse string to boolean: " + parsed_string)
             raise Exception("Could not parse string to boolean: " + parsed_string)
 
+        return return_value
+
     @classmethod
     def description(cls):
-        return "For the boolean type, either true or false are allowed - either as string or as a clingo-symbol. If one provides it as a string, it is case-insensitive."
+        return (
+            "For the boolean type, either true or false are allowed - either as string or as a clingo-symbol."
+            + "If one provides it as a string, it is case-insensitive."
+        )
diff --git a/clinguin/utils/attribute_types/child_layout.py b/clinguin/utils/attribute_types/child_layout.py
index 71a92dc0..6ae39990 100644
--- a/clinguin/utils/attribute_types/child_layout.py
+++ b/clinguin/utils/attribute_types/child_layout.py
@@ -18,23 +18,35 @@ class ChildLayoutType(EnumType):
     RELSTATIC = auto()
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = (StandardTextProcessing.parse_string_with_quotes(input)).lower()
+    def parse(cls, parse_input: str, logger):
+        parsed_string = (
+            StandardTextProcessing.parse_string_with_quotes(parse_input)
+        ).lower()
+
+        return_value = None
 
         if parsed_string == cls.FLEX.name.lower():
-            return cls.FLEX
+            return_value = cls.FLEX
         elif parsed_string == cls.GRID.name.lower():
-            return cls.GRID
+            return_value = cls.GRID
         elif parsed_string == cls.ABSSTATIC.name.lower():
-            return cls.ABSSTATIC
+            return_value = cls.ABSSTATIC
         elif parsed_string == cls.RELSTATIC.name.lower():
-            return cls.RELSTATIC
+            return_value = cls.RELSTATIC
         else:
             logger.error("Could not parse " + parsed_string + " to child_layout type.")
             raise Exception(
                 "Could not parse " + parsed_string + " to child_layout type."
             )
 
+        return return_value
+
     @classmethod
     def description(cls):
-        return "For the child-layout four different options exists: flex (default, tries to do it automatically), grid (grid-like-specification), absstatic (if one wants to specify the position with absolute-pixel coordinates) and relstatic (if one wants to specify the position with relative-pixel coordinates (from 0 to 100 percent, where 0 means left/top and 100 means right/bottom)). They can either be specified via a clingo symbol or via a string (string is case-insensitive)."
+        return (
+            "For the child-layout four different options exists: flex (default, tries to do it automatically),"
+            + "grid (grid-like-specification), absstatic (if one wants to specify the position with absolute-pixel"
+            + "coordinates) and relstatic (if one wants to specify the position with relative-pixel coordinates"
+            + "(from 0 to 100 percent, where 0 means left/top and 100 means right/bottom)). They can either be"
+            + "specified via a clingo symbol or via a string (string is case-insensitive)."
+        )
diff --git a/clinguin/utils/attribute_types/color.py b/clinguin/utils/attribute_types/color.py
index 5ca95b2d..6d895fd4 100644
--- a/clinguin/utils/attribute_types/color.py
+++ b/clinguin/utils/attribute_types/color.py
@@ -12,11 +12,19 @@ class ColorType(Type):
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = (StandardTextProcessing.parse_string_with_quotes(input)).lower()
+    def parse(cls, parse_input: str, logger):
+        parsed_string = (
+            StandardTextProcessing.parse_string_with_quotes(parse_input)
+        ).lower()
 
         return parsed_string
 
     @classmethod
     def description(cls):
-        return 'One can specify the color either by providing a simple-color symbol or string (like white, black, etc.), or by specifying it directly via a 9-digit hex-string, where the definition of it is: "#RRRGGGBBB", where R means Red, G means Green and B means Blue. E.g. black is "#000000000", red is "#fff000000", green "#000fff000", blue "#000000fff" and white "fffffffff".'
+        return (
+            "One can specify the color either by providing a simple-color symbol or string"
+            + "(like white, black, etc.), or by specifying it directly via a 9-digit hex-string,"
+            + "where the definition of it is: '#RRRGGGBBB' where R means Red, G means Green and B means Blue."
+            + "E.g. black is '#000000000', red is '#fff000000', green '#000fff000', "
+            + "blue '#000000fff' and white 'fffffffff'."
+        )
diff --git a/clinguin/utils/attribute_types/enum.py b/clinguin/utils/attribute_types/enum.py
index 0225bb13..7ff8dd01 100644
--- a/clinguin/utils/attribute_types/enum.py
+++ b/clinguin/utils/attribute_types/enum.py
@@ -9,5 +9,6 @@
 
 class EnumType(Type, Enum):
     """
-    The EnumType shall not be directly used, only subtypes of the EnumType (like the ChildLayout) shall be used.
+    The EnumType shall not be directly used, only subtypes of the EnumType
+    (like the ChildLayout) shall be used.
     """
diff --git a/clinguin/utils/attribute_types/flex_direction.py b/clinguin/utils/attribute_types/flex_direction.py
index e603bb72..e4c2ffca 100644
--- a/clinguin/utils/attribute_types/flex_direction.py
+++ b/clinguin/utils/attribute_types/flex_direction.py
@@ -9,7 +9,8 @@
 
 class FlexDirectionType(EnumType):
     """
-    The FlexDirectionType is an Enum Type, which can be used to specify where a component shall be added relative to the parent.
+    The FlexDirectionType is an Enum Type, which can be used to specify where a component shall
+    be added relative to the parent.
     """
 
     COLUMN = auto()
@@ -18,17 +19,21 @@ class FlexDirectionType(EnumType):
     ROW_REVERSE = auto()
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = (StandardTextProcessing.parse_string_with_quotes(input)).lower()
+    def parse(cls, parse_input: str, logger):
+        parsed_string = (
+            StandardTextProcessing.parse_string_with_quotes(parse_input)
+        ).lower()
+
+        return_value = None
 
         if parsed_string == cls.COLUMN.name.lower():
-            return cls.COLUMN
+            return_value = cls.COLUMN
         elif parsed_string == cls.COLUMN_REVERSE.name.lower():
-            return cls.COLUMN_REVERSE
+            return_value = cls.COLUMN_REVERSE
         elif parsed_string == cls.ROW.name.lower():
-            return cls.ROW
+            return_value = cls.ROW
         elif parsed_string == cls.ROW_REVERSE.name.lower():
-            return cls.ROW_REVERSE
+            return_value = cls.ROW_REVERSE
         else:
             logger.error(
                 "Could not parse " + parsed_string + " to flex_direction type."
@@ -37,6 +42,11 @@ def parse(cls, input: str, logger):
                 "Could not parse " + parsed_string + " to flex_direction type."
             )
 
+        return return_value
+
     @classmethod
     def description(cls):
-        return "For the flex-direction type two possible values exist: column (vertical alignment) and row (horizontal alignment)."
+        return (
+            "For the flex-direction type two possible values exist: column (vertical alignment)"
+            + "and row (horizontal alignment)."
+        )
diff --git a/clinguin/utils/attribute_types/float.py b/clinguin/utils/attribute_types/float.py
index 5e0eab99..66b97760 100644
--- a/clinguin/utils/attribute_types/float.py
+++ b/clinguin/utils/attribute_types/float.py
@@ -12,14 +12,14 @@ class FloatType(Type):
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = StandardTextProcessing.parse_string_with_quotes(input)
+    def parse(cls, parse_input: str, logger):
+        parsed_string = StandardTextProcessing.parse_string_with_quotes(parse_input)
 
         try:
             return float(parsed_string)
-        except:
+        except Exception as ex:
             logger.error("Could not parse string to float: " + parsed_string)
-            raise Exception("Could not parse string to float: " + parsed_string)
+            raise Exception("Could not parse string to float: " + parsed_string) from ex
 
     @classmethod
     def description(cls):
diff --git a/clinguin/utils/attribute_types/font_families.py b/clinguin/utils/attribute_types/font_families.py
index b4fed5ef..244fc624 100644
--- a/clinguin/utils/attribute_types/font_families.py
+++ b/clinguin/utils/attribute_types/font_families.py
@@ -13,11 +13,17 @@ class FontFamiliesType(Type):
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = StandardTextProcessing.parse_string_with_quotes(input)
+    def parse(cls, parse_input: str, logger):
+        parsed_string = StandardTextProcessing.parse_string_with_quotes(parse_input)
 
         return parsed_string
 
     @classmethod
     def description(cls):
-        return "As the font-families change from system to system, clinguin cannot provide a useful selection of fonts here. Therefore one should search in one's favorite search engine, how to get a list of available fonts for one's operating system. Generally one can then use the name of the preferred font-family as the value. Some wide spread and popular font-families are (NOTE THAT THEY MIGHT NOT WORK ON YOUR SYSTEM!!!): [''helvetica'',''times'',''arial'',''courier'']."
+        return (
+            "As the font-families change from system to system, clinguin cannot provide a useful selection"
+            + "of fonts here. Therefore one should search in one's favorite search engine, how to get a list"
+            + "of available fonts for one's operating system. Generally one can then use the name of the"
+            + "preferred font-family as the value. Some wide spread and popular font-families are"
+            + "(NOTE THAT THEY MIGHT NOT WORK ON YOUR SYSTEM!!!): [''helvetica'',''times'',''arial'',''courier'']."
+        )
diff --git a/clinguin/utils/attribute_types/font_weight.py b/clinguin/utils/attribute_types/font_weight.py
index 0bad8655..4d496380 100644
--- a/clinguin/utils/attribute_types/font_weight.py
+++ b/clinguin/utils/attribute_types/font_weight.py
@@ -19,8 +19,10 @@ class FontWeightType(EnumType):
     ITALIC_BOLD = auto()
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = (StandardTextProcessing.parse_string_with_quotes(input)).lower()
+    def parse(cls, parse_input: str, logger):
+        parsed_string = (
+            StandardTextProcessing.parse_string_with_quotes(parse_input)
+        ).lower()
 
         normals = ["n", "normal"]
         bolds = ["b", "bold"]
@@ -38,20 +40,27 @@ def parse(cls, input: str, logger):
                 bolds_italic_list.append(str(l[0]) + "_" + str(l[1]))
                 bolds_italic_list.append(str(l[0]) + "-" + str(l[1]))
 
+        return_value = None
+
         if parsed_string in bolds_italic_list:
-            return cls.ITALIC_BOLD
+            return_value = cls.ITALIC_BOLD
         elif parsed_string in bolds:
-            return cls.BOLD
+            return_value = cls.BOLD
         elif parsed_string in italics:
-            return cls.ITALIC
+            return_value = cls.ITALIC
         elif parsed_string in normals:
-            return cls.NORMAL
+            return_value = cls.NORMAL
         else:
             error_string = "Could not parse " + parsed_string + " to FontWeightType."
             logger.error(error_string)
             raise Exception(error_string)
-        return cls.NORMAL
+
+        return return_value
 
     @classmethod
     def description(cls):
-        return 'For the FontWeightType several different options exists - ["i" or "italic"] for italic, ["b" or "bold"] for bold and any permuation (with the delimiters "_", "-" and no delimiter) of those for both italic and bolt. Further "normal" exists for specifying normal font weight.'
+        return (
+            "For the FontWeightType several different options exists - ['i' or 'italic'] for italic,"
+            + "['b' or 'bold'] for bold and any permuation (with the delimiters '_', '-' and no delimiter)"
+            + "of those for both italic and bolt. Further 'normal' exists for specifying normal font weight."
+        )
diff --git a/clinguin/utils/attribute_types/image.py b/clinguin/utils/attribute_types/image.py
index 55d47a6b..090581e6 100644
--- a/clinguin/utils/attribute_types/image.py
+++ b/clinguin/utils/attribute_types/image.py
@@ -9,19 +9,20 @@
 
 class ImageType(Type):
     """
-    The ImageType shall be used when the image is transferred from the backend to the frontend via a Base64 encoded string.
+    The ImageType shall be used when the image is transferred from the backend to the frontend
+    via a Base64 encoded string.
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = StandardTextProcessing.parse_string_with_quotes(input)
+    def parse(cls, parse_input: str, logger):
+        parsed_string = StandardTextProcessing.parse_string_with_quotes(parse_input)
 
         try:
             image_initial_bytes = parsed_string.encode("utf-8")
             base64.b64decode(image_initial_bytes)
-        except:
+        except Exception as ex:
             logger.error("Sent image is not base64 encoded.")
-            raise Exception("Sent image is not base64 encoded.")
+            raise Exception("Sent image is not base64 encoded.") from ex
 
         return parsed_string
 
diff --git a/clinguin/utils/attribute_types/integer.py b/clinguin/utils/attribute_types/integer.py
index bee5fed5..57bbfa29 100644
--- a/clinguin/utils/attribute_types/integer.py
+++ b/clinguin/utils/attribute_types/integer.py
@@ -12,14 +12,14 @@ class IntegerType(Type):
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = StandardTextProcessing.parse_string_with_quotes(input)
+    def parse(cls, parse_input: str, logger):
+        parsed_string = StandardTextProcessing.parse_string_with_quotes(parse_input)
 
         try:
             return int(parsed_string)
-        except:
+        except Exception as ex:
             logger.error("Could not parse string to int: " + parsed_string)
-            raise Exception("Could not parse string to int: " + parsed_string)
+            raise Exception("Could not parse string to int: " + parsed_string) from ex
 
     @classmethod
     def description(cls):
diff --git a/clinguin/utils/attribute_types/path.py b/clinguin/utils/attribute_types/path.py
index 9cd7146e..746edd0a 100644
--- a/clinguin/utils/attribute_types/path.py
+++ b/clinguin/utils/attribute_types/path.py
@@ -14,16 +14,20 @@ class PathType(Type):
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = StandardTextProcessing.parse_string_with_quotes(input)
+    def parse(cls, parse_input: str, logger):
+        parsed_string = StandardTextProcessing.parse_string_with_quotes(parse_input)
+
+        return_value = None
 
         if path.exists(parsed_string):
-            return parsed_string
+            return_value = parsed_string
         else:
             error_string = "Could not find specified path: " + parsed_string
             logger.error(error_string)
             raise Exception(error_string)
 
+        return return_value
+
     @classmethod
     def description(cls):
         return "String, can either be specified as a string or if it is simple as a symbol."
diff --git a/clinguin/utils/attribute_types/popup_types.py b/clinguin/utils/attribute_types/popup_types.py
index 24dd27f3..64f8281a 100644
--- a/clinguin/utils/attribute_types/popup_types.py
+++ b/clinguin/utils/attribute_types/popup_types.py
@@ -17,20 +17,29 @@ class PopupTypesType(EnumType):
     ERROR = auto()
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = (StandardTextProcessing.parse_string_with_quotes(input)).lower()
+    def parse(cls, parse_input: str, logger):
+        parsed_string = (
+            StandardTextProcessing.parse_string_with_quotes(parse_input)
+        ).lower()
+
+        return_value = None
 
         if parsed_string == cls.INFO.name.lower():
-            return cls.INFO
+            return_value = cls.INFO
         elif parsed_string == cls.WARNING.name.lower():
-            return cls.WARNING
+            return_value = cls.WARNING
         elif parsed_string == cls.ERROR.name.lower():
-            return cls.ERROR
+            return_value = cls.ERROR
         else:
             error_string = "Could not parse " + parsed_string + " to PopupTypesType."
             logger.error(error_string)
             raise Exception(error_string)
 
+        return return_value
+
     @classmethod
     def description(cls):
-        return "For the popup-types three different options exists: ''info'' (Default information message), ''warning'' and ''error''"
+        return (
+            "For the popup-types three different options exists: 'info' (Default information message),"
+            + "'warning' and 'error'"
+        )
diff --git a/clinguin/utils/attribute_types/string.py b/clinguin/utils/attribute_types/string.py
index 75f0aaa5..c717b10a 100644
--- a/clinguin/utils/attribute_types/string.py
+++ b/clinguin/utils/attribute_types/string.py
@@ -12,8 +12,8 @@ class StringType(Type):
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
-        parsed_string = StandardTextProcessing.parse_string_with_quotes(input)
+    def parse(cls, parse_input: str, logger):
+        parsed_string = StandardTextProcessing.parse_string_with_quotes(parse_input)
 
         return parsed_string
 
diff --git a/clinguin/utils/attribute_types/symbol.py b/clinguin/utils/attribute_types/symbol.py
index e95e0b87..d34bf11a 100644
--- a/clinguin/utils/attribute_types/symbol.py
+++ b/clinguin/utils/attribute_types/symbol.py
@@ -14,16 +14,16 @@ class SymbolType(Type):
     """
 
     @classmethod
-    def parse(cls, input: str, logger) -> str:
-        parsed_string = StandardTextProcessing.parse_string_with_quotes(input)
+    def parse(cls, parse_input: str, logger) -> str:
+        parsed_string = StandardTextProcessing.parse_string_with_quotes(parse_input)
 
         try:
             clingo.parse_term(parsed_string)
             return parsed_string
-        except:
+        except Exception as ex:
             error_string = "The string " + parsed_string + " is not a clingo symbol!"
             logger.error(error_string)
-            raise Exception(error_string)
+            raise Exception(error_string) from ex
 
     @classmethod
     def description(cls):
diff --git a/clinguin/utils/attribute_types/type.py b/clinguin/utils/attribute_types/type.py
index 26c2bf81..3ff3fb5d 100644
--- a/clinguin/utils/attribute_types/type.py
+++ b/clinguin/utils/attribute_types/type.py
@@ -5,11 +5,12 @@
 
 class Type:
     """
-    The Type class is the super class of all Clinguin-Value-Types, i.e. each individual type must be a subtype of Type.
+    The Type class is the super class of all Clinguin-Value-Types, i.e. each individual type
+    must be a subtype of Type.
     """
 
     @classmethod
-    def parse(cls, input: str, logger):
+    def parse(cls, parse_input: str, logger):  # pylint: disable=W0613
         """
         Every type must override this method. This method parses/checks the given value.
         """
@@ -18,6 +19,7 @@ def parse(cls, input: str, logger):
     @classmethod
     def description(cls):
         """
-        Every type must override this method. One provides a textual description of available values in the return string.
+        Every type must override this method. One provides a textual description of available values
+        in the return string.
         """
         return ""
diff --git a/clinguin/utils/attribute_types/utils/standard_text_processing.py b/clinguin/utils/attribute_types/utils/standard_text_processing.py
index d1ecb8bf..05c1d770 100644
--- a/clinguin/utils/attribute_types/utils/standard_text_processing.py
+++ b/clinguin/utils/attribute_types/utils/standard_text_processing.py
@@ -10,6 +10,10 @@ class StandardTextProcessing:
 
     @classmethod
     def parse_string_with_quotes(cls, text):
+        """
+        Parses a string with quotes inside and returns the string without quotes.
+        Additionally it correctly parses newlines to ''correct'' newlines.
+        """
         if len(text) > 0:
             if text[0] == '"':
                 text = text[1:]
diff --git a/clinguin/utils/case_converter.py b/clinguin/utils/case_converter.py
index 5c58ce80..01bc2233 100644
--- a/clinguin/utils/case_converter.py
+++ b/clinguin/utils/case_converter.py
@@ -5,7 +5,8 @@
 
 class CaseConverter:
     """
-    The CaseConverter class provides functionality to convert strings from one type-case (like snake_case) to another (like camelCase).
+    The CaseConverter class provides functionality to convert strings from one type-case
+    (like snake_case) to another (like camelCase).
 
     Methods:
         snake_case_to_camel_case(snake_case : str) -> str
@@ -13,6 +14,9 @@ class CaseConverter:
 
     @classmethod
     def snake_case_to_camel_case(cls, snake_case):
+        """
+        Converts a snake case name to a camel case one.
+        """
         components = snake_case.split("_")
 
         return components[0] + "".join(x.title() for x in components[1:])
diff --git a/clinguin/utils/custom_args.py b/clinguin/utils/custom_args.py
index 59aaa776..5a50eb2b 100644
--- a/clinguin/utils/custom_args.py
+++ b/clinguin/utils/custom_args.py
@@ -1,3 +1,4 @@
+# pylint: disable=W0107
 """
 The module contains the CustomArgs class.
 """
@@ -5,7 +6,9 @@
 
 class CustomArgs:
     """
-    The root class of all backend- (like ClingoBackend) and gui-classes (like TkinterFrontend). Needed for argparse (with the method register_options one can specify command line arguments, that are specific to a certain class).
+    The root class of all backend- (like ClingoBackend) and gui-classes (like TkinterFrontend).
+    Needed for argparse (with the method register_options one can specify command line arguments,
+    that are specific to a certain class).
 
     Method:
         register_options (parser: argparse-object)
@@ -13,4 +16,6 @@ class CustomArgs:
 
     @classmethod
     def register_options(cls, parser):
-        pass
+        """
+        Method that needs to be implemented by all children.
+        """
diff --git a/clinguin/utils/errors.py b/clinguin/utils/errors.py
index 5cde2d89..975c462f 100644
--- a/clinguin/utils/errors.py
+++ b/clinguin/utils/errors.py
@@ -13,35 +13,39 @@ def __init__(self, core=None) -> None:
         self.core = core
 
 
-SERVER_ERROR_ALERT = {
-    "id": "root",
-    "type": "root",
-    "parent": "root",
-    "attributes": [],
-    "callbacks": [],
-    "children": [
-        {
-            "id": "window",
-            "type": "window",
-            "parent": "root",
-            "attributes": [],
-            "callbacks": [],
-            "children": [
-                {
-                    "id": "message",
-                    "type": "message",
-                    "parent": "window",
-                    "callbacks": [],
-                    "attributes": [
-                        {
-                            "id": "message",
-                            "key": "message",
-                            "value": '"Server Error (Check logs)"',
-                        }
-                    ],
-                    "children": [],
-                },
-            ],
-        }
-    ],
-}
+def get_server_error_alert():
+    """
+    Returns a JSON, which corresponds to valid clinguin json syntax and displays an error message.
+    """
+    return {
+        "id": "root",
+        "type": "root",
+        "parent": "root",
+        "attributes": [],
+        "callbacks": [],
+        "children": [
+            {
+                "id": "window",
+                "type": "window",
+                "parent": "root",
+                "attributes": [],
+                "callbacks": [],
+                "children": [
+                    {
+                        "id": "message",
+                        "type": "message",
+                        "parent": "window",
+                        "callbacks": [],
+                        "attributes": [
+                            {
+                                "id": "message",
+                                "key": "message",
+                                "value": '"Server Error (Check logs)"',
+                            }
+                        ],
+                        "children": [],
+                    },
+                ],
+            }
+        ],
+    }
diff --git a/clinguin/utils/logger.py b/clinguin/utils/logger.py
index 2287feba..7163e392 100644
--- a/clinguin/utils/logger.py
+++ b/clinguin/utils/logger.py
@@ -8,7 +8,8 @@
 
 class Logger:
     """
-    Provides methods to set the logging config appropriatly. In principle two loggers exists - one for the client (default name: clinguin_client) and one for the server (default name: clinguin_server).
+    Provides methods to set the logging config appropriatly. In principle two loggers exists -
+    one for the client (default name: clinguin_client) and one for the server (default name: clinguin_server).
     """
 
     class ColoredFormatter(logging.Formatter):
@@ -47,6 +48,9 @@ def format(self, record):
 
     @classmethod
     def formatter_message(cls, message, use_color=True):
+        """
+        Formats certain aspects of the messages (color).
+        """
         if use_color:
             message = message.replace("$RESET", cls.RESET_SEQ).replace(
                 "$BOLD", cls.BOLD_SEQ
@@ -85,7 +89,7 @@ def _add_shell_handler_to_logger(cls, logger, log_arg_dict):
     def _add_file_handler_to_logger(cls, logger, log_arg_dict, log_file_path):
         file_formatter = Logger.ColoredFormatter(log_arg_dict["format_file"])
 
-        with open(log_file_path, "a+") as file_object:
+        with open(log_file_path, "a+", encoding="utf-8") as file_object:
             file_object.write(
                 "<<<<<NEW-LOG-INSTANCE-" + log_arg_dict["name"] + ">>>>>\n\n"
             )
@@ -96,6 +100,9 @@ def _add_file_handler_to_logger(cls, logger, log_arg_dict, log_file_path):
 
     @classmethod
     def setup_logger(cls, log_arg_dict, process=None):
+        """
+        Function for setting up the logger.
+        """
         if process and process == "client":
             cls.client_logger_name = log_arg_dict["name"]
         elif process and process == "server":
@@ -111,8 +118,9 @@ def setup_logger(cls, log_arg_dict, process=None):
 
     @classmethod
     def setup_uvicorn_logger_on_startup(cls, log_arg_dict):
-        # ----------------------------------------------------------
-        # Remove handlers from uvicorn loggers
+        """
+        General function for setting up the logger on startup.
+        """
         logger = logging.getLogger("uvicorn.access")
         for handler in logger.handlers:
             logger.removeHandler(handler)
diff --git a/noxfile.py b/noxfile.py
index fb18efa2..c93189f1 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -3,9 +3,7 @@
 import nox
 
 # default sessions that shall be run
-nox.options.sessions = ["test"]
-
-
+nox.options.sessions = ["test", "lint_pylint", "lint_flake8"]
 
 EDITABLE_TESTS = True
 PYTHON_VERSIONS = None
@@ -13,6 +11,16 @@
     PYTHON_VERSIONS = ["3.10"]
     EDITABLE_TESTS = False
 
+@nox.session
+def lint_flake8(session):
+    session.install("-e", ".[lint_flake8]")
+    session.run("flake8", "clinguin", "tests")
+
+@nox.session
+def lint_pylint(session):
+    session.install("-e", ".[lint_pylint]")
+    session.run("pylint", "clinguin")    
+
 @nox.session
 def format(session):
     session.install("-e", ".[format]")
diff --git a/setup.cfg b/setup.cfg
index 740e77bb..80abb3a0 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -37,6 +37,14 @@ format =
     isort
     black
 
+lint_flake8 =
+    nox
+    flake8 
+
+lint_pylint = 
+    nox
+    pylint
+
 [options.entry_points]
 console_scripts =
     clinguin = clinguin:main


Test patch:
diff --git a/tests/reference_json_output/coloring.py b/tests/reference_json_output/coloring.py
index 40e2de5d..857e73a4 100644
--- a/tests/reference_json_output/coloring.py
+++ b/tests/reference_json_output/coloring.py
@@ -1,3 +1,4 @@
+# flake8: noqa
 import json
 
 
diff --git a/tests/test_backend_unit_00_05.py b/tests/test_backend_unit_00_05.py
index 65f16247..a964ba2d 100644
--- a/tests/test_backend_unit_00_05.py
+++ b/tests/test_backend_unit_00_05.py
@@ -1,4 +1,11 @@
-from reference_json_output import *
+from reference_json_output import (
+    BasicTest00,
+    BasicTest01,
+    BasicTest02,
+    BasicTest03,
+    BasicTest04,
+    BasicTest05,
+)
 from utils_test_utils import UtilsTestUtils
 
 
diff --git a/tests/test_backend_unit_06_11.py b/tests/test_backend_unit_06_11.py
index 086b168e..90e63389 100644
--- a/tests/test_backend_unit_06_11.py
+++ b/tests/test_backend_unit_06_11.py
@@ -1,4 +1,11 @@
-from reference_json_output import *
+from reference_json_output import (
+    BasicTest06,
+    BasicTest07,
+    BasicTest08,
+    BasicTest09,
+    BasicTest10,
+    BasicTest11,
+)
 from utils_test_utils import UtilsTestUtils
 
 
diff --git a/tests/test_basic_00_05.py b/tests/test_basic_00_05.py
index 20a3016b..898b10fb 100644
--- a/tests/test_basic_00_05.py
+++ b/tests/test_basic_00_05.py
@@ -1,4 +1,12 @@
-from reference_json_output import *
+from reference_json_output import (
+    BasicTest00,
+    BasicTest01,
+    BasicTest02,
+    BasicTest03,
+    BasicTest04,
+    BasicTest05,
+    Health,
+)
 from utils_test_utils import UtilsTestUtils
 
 
diff --git a/tests/test_basic_06_11.py b/tests/test_basic_06_11.py
index a431a04d..a6b3ddd3 100644
--- a/tests/test_basic_06_11.py
+++ b/tests/test_basic_06_11.py
@@ -1,4 +1,11 @@
-from reference_json_output import *
+from reference_json_output import (
+    BasicTest06,
+    BasicTest07,
+    BasicTest08,
+    BasicTest09,
+    BasicTest10,
+    BasicTest11,
+)
 from utils_test_utils import UtilsTestUtils
 
 
diff --git a/tests/test_clingraph.py b/tests/test_clingraph.py
index ddcd6bab..94b288cf 100644
--- a/tests/test_clingraph.py
+++ b/tests/test_clingraph.py
@@ -1,4 +1,3 @@
-from reference_json_output import *
 from utils_test_utils import UtilsTestUtils
 
 
@@ -44,7 +43,7 @@ def test_assumptions(self):
         post_calls = [
             ("add_assumption(assign(1,blue))", Coloring.post_assumption_1),
             ("add_assumption(assign(2,green))", Coloring.post_assumption_2),
-            ("add_assumption(assign(5,blue))", Coloring.post_assumption_3)           
+            ("add_assumption(assign(5,blue))", Coloring.post_assumption_3)
         ]
 
         for post_call in post_calls:
diff --git a/tests/test_sudoku.py b/tests/test_sudoku.py
index 0fc5ac0b..e3fab5d8 100644
--- a/tests/test_sudoku.py
+++ b/tests/test_sudoku.py
@@ -1,4 +1,4 @@
-from reference_json_output import *
+from reference_json_output import Sudoku
 from utils_test_utils import UtilsTestUtils
 
 
diff --git a/tests/test_temporal.py b/tests/test_temporal.py
index 1a1adb38..eecfa11c 100644
--- a/tests/test_temporal.py
+++ b/tests/test_temporal.py
@@ -1,4 +1,4 @@
-from reference_json_output import *
+from reference_json_output import Elevator
 from utils_test_utils import UtilsTestUtils
 
 
diff --git a/tests/utils_test_utils.py b/tests/utils_test_utils.py
index 3547cec1..9a7b349d 100644
--- a/tests/utils_test_utils.py
+++ b/tests/utils_test_utils.py
@@ -7,7 +7,7 @@
 
 import httpx
 
-from clinguin import argsToDictConvert
+from clinguin import args_to_dict_converter
 from clinguin.parse_input import ArgumentParser
 from clinguin.server.application.backends.clingo_backend import ClingoBackend
 
@@ -72,9 +72,9 @@ def start_server(cls, domain_files, ui_files, optional=None):
         uvicorn_url = f"http://{url}:{port}"
 
         arguments = (
-            ["clinguin", "server", f"--domain-files"]
+            ["clinguin", "server", "--domain-files"]
             + domain_files
-            + [f"--ui-files"]
+            + ["--ui-files"]
             + ui_files
         )
 
@@ -114,7 +114,7 @@ def instantiate_backend(self, test_method):
         parser = ArgumentParser()
 
         arguments = (
-            ["server", f"--domain-files"] + domain_files + [f"--ui-files"] + ui_files
+            ["server", "--domain-files"] + domain_files + ["--ui-files"] + ui_files
         )
 
         args = parser.parse("server", arguments)
@@ -123,7 +123,7 @@ def instantiate_backend(self, test_method):
 
         timestamp = datetime.now().strftime("%Y-%m-%d::%H:%M:%S")
 
-        log_dict = argsToDictConvert(args_dict, timestamp)
+        log_dict = args_to_dict_converter(args_dict, timestamp)
 
         args_copy = copy.deepcopy(args)
         args_copy.log_args = log_dict