refactoring

src/app.py

@@ -17,8 +17,9 @@ if not os.path.isdir(path_to_images):
     st.title("There is no directory: " + path_to_images)
 else:
     # select interface type
-    interface_type = st.sidebar.radio('Select the interface type',
-                                      ['Simple', 'Professional'])
+    interface_type = st.sidebar.radio(
+        "Select the interface type", ["Simple", "Professional"]
+    )
 
     # select image
     status, image = select_image(path_to_images, interface_type)
@@ -40,20 +41,26 @@ else:
         )
 
         # select a transformation
-        if interface_type == 'Simple':
-            transform_names = [st.sidebar.selectbox(
-                "Select a transformation:", sorted(list(augmentations.keys()))
-            )]
+        if interface_type == "Simple":
+            transform_names = [
+                st.sidebar.selectbox(
+                    "Select a transformation:", sorted(list(augmentations.keys()))
+                )
+            ]
         # in the professional mode you can choose several transforms
-        elif interface_type == 'Professional':
-            transform_names = [st.sidebar.selectbox(
-                "Select transformation №1:", sorted(list(augmentations.keys()))
-            )]
-            while transform_names[-1] != 'None':
-                transform_names.append(st.sidebar.selectbox(
-                    f"Select transformation №{len(transform_names) + 1}:",
-                    ['None'] + sorted(list(augmentations.keys()))
-            ))
+        elif interface_type == "Professional":
+            transform_names = [
+                st.sidebar.selectbox(
+                    "Select transformation №1:", sorted(list(augmentations.keys()))
+                )
+            ]
+            while transform_names[-1] != "None":
+                transform_names.append(
+                    st.sidebar.selectbox(
+                        f"Select transformation №{len(transform_names) + 1}:",
+                        ["None"] + sorted(list(augmentations.keys())),
+                    )
+                )
             transform_names = transform_names[:-1]
 
         transforms = []
@@ -69,8 +76,10 @@ else:
             error = 0
         except ValueError:
             error = 1
-            st.title("The error has occurred. Most probably you have passed wrong set of parameters. \
-            Check transforms that change the shape of image.")
+            st.title(
+                "The error has occurred. Most probably you have passed wrong set of parameters. \
+            Check transforms that change the shape of image."
+            )
 
         if error == 0:
             augmented_image = data["image"]
@@ -83,14 +92,18 @@ else:
             )
 
             st.image(image, caption="Original image", width=width_original)
-            st.image(augmented_image, caption="Transformed image", width=width_transformed)
+            st.image(
+                augmented_image, caption="Transformed image", width=width_transformed
+            )
 
             # random values used to get transformations
-            if interface_type == 'Professional':
+            if interface_type == "Professional":
                 st.subheader("Random params used")
                 random_values = {}
                 for applied_params in data["replay"]["transforms"]:
-                    random_values[applied_params['__class_fullname__'].split('.')[-1]] = applied_params['params']
+                    random_values[
+                        applied_params["__class_fullname__"].split(".")[-1]
+                    ] = applied_params["params"]
                 st.write(random_values)
 
             # print additional info

src/control.py

@@ -3,10 +3,16 @@ import streamlit as st
 # TODO: rename and refactor everything
 
 
-def select_num_interval(param_name: str, limits_list: list, defaults, n_for_hash, **kwargs):
+def select_num_interval(
+    param_name: str, limits_list: list, defaults, n_for_hash, **kwargs
+):
     st.sidebar.subheader(param_name)
     min_max_interval = st.sidebar.slider(
-        "", limits_list[0], limits_list[1], defaults, key=hash(param_name + str(n_for_hash))
+        "",
+        limits_list[0],
+        limits_list[1],
+        defaults,
+        key=hash(param_name + str(n_for_hash)),
     )
     return min_max_interval
 
@@ -22,16 +28,24 @@ def select_several_nums(
     for name, limits, defaults in zip(subparam_names, limits_list, defaults_list):
         result.append(
             st.sidebar.slider(
-                name, limits[0], limits[1], defaults, key=hash(param_name + name + str(n_for_hash))
+                name,
+                limits[0],
+                limits[1],
+                defaults,
+                key=hash(param_name + name + str(n_for_hash)),
             )
         )
     return tuple(result)
 
 
-def select_min_max(param_name, limits_list, defaults_list, n_for_hash, min_diff=0,  **kwargs):
+def select_min_max(
+    param_name, limits_list, defaults_list, n_for_hash, min_diff=0, **kwargs
+):
     assert len(param_name) == 2
     result = list(
-        select_num_interval(" & ".join(param_name), limits_list, defaults_list, n_for_hash)
+        select_num_interval(
+            " & ".join(param_name), limits_list, defaults_list, n_for_hash
+        )
     )
     if result[1] - result[0] < min_diff:
         diff = min_diff - result[1] + result[0]
@@ -49,7 +63,8 @@ def select_RGB(param_name, n_for_hash, **kwargs):
         param_name,
         subparam_names=["Red", "Green", "Blue"],
         limits_list=[[0, 255], [0, 255], [0, 255]],
-        defaults_list=[0, 0, 0], n_for_hash = n_for_hash
+        defaults_list=[0, 0, 0],
+        n_for_hash=n_for_hash,
     )
     return tuple(result)
 
@@ -69,7 +84,9 @@ def select_radio(param_name, options_list, n_for_hash, **kwargs):
 
 def select_checkbox(param_name, defaults, n_for_hash, **kwargs):
     st.sidebar.subheader(param_name)
-    result = st.sidebar.checkbox("True", defaults, key=hash(param_name + str(n_for_hash)))
+    result = st.sidebar.checkbox(
+        "True", defaults, key=hash(param_name + str(n_for_hash))
+    )
     return result
 
 

src/utils.py

@@ -49,12 +49,15 @@ def upload_image(bgr2rgb: bool = True):
     Args:
         bgr2rgb (bool): converts BGR image to RGB if True
     """
-    file = st.sidebar.file_uploader("Upload your image (jpg, jpeg, or png)", ["jpg", "jpeg", "png"])
+    file = st.sidebar.file_uploader(
+        "Upload your image (jpg, jpeg, or png)", ["jpg", "jpeg", "png"]
+    )
     image = cv2.imdecode(np.fromstring(file.read(), np.uint8), 1)
     if bgr2rgb:
         image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
     return image
 
+
 @st.cache
 def load_augmentations_config(
     placeholder_params: dict, path_to_config: str = "configs/augmentations.json"

src/visuals.py

@@ -9,17 +9,19 @@ def show_logo():
     st.image(load_image("logo.png", "../images"), format="PNG")
 
 
-def select_image(path_to_images: str, interface_type:str = 'Simple'):
+def select_image(path_to_images: str, interface_type: str = "Simple"):
     image_names_list = get_images_list(path_to_images)
     if len(image_names_list) < 1:
         return 0, 0
     else:
-        if interface_type == 'Professional':
-            image_name = st.sidebar.selectbox("Select an image:", image_names_list + ["Upload my image"])
+        if interface_type == "Professional":
+            image_name = st.sidebar.selectbox(
+                "Select an image:", image_names_list + ["Upload my image"]
+            )
         else:
             image_name = st.sidebar.selectbox("Select an image:", image_names_list)
 
-        if image_name != 'Upload my image':
+        if image_name != "Upload my image":
             try:
                 image = load_image(image_name, path_to_images)
                 return 1, image
@@ -43,11 +45,13 @@ def show_transform_control(transform_params: dict, n_for_hash: int) -> dict:
         for param in transform_params:
             control_function = param2func[param["type"]]
             if isinstance(param["param_name"], list):
-                returned_values = control_function(**param, n_for_hash = n_for_hash)
+                returned_values = control_function(**param, n_for_hash=n_for_hash)
                 for name, value in zip(param["param_name"], returned_values):
                     param_values[name] = value
             else:
-                param_values[param["param_name"]] = control_function(**param,n_for_hash = n_for_hash)
+                param_values[param["param_name"]] = control_function(
+                    **param, n_for_hash=n_for_hash
+                )
     return param_values