v0.10.7

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -4,7 +4,7 @@ emoji: 😀🤓😎😉😤
 colorFrom: gray
 colorTo: red
 sdk: gradio
-sdk_version: 5.5.0
+sdk_version: 5.8.0
 app_file: app.py
 pinned: false
 license: mit

app.css

@@ -14,9 +14,8 @@ div.app-flex-container {
     gap: 6px;
 }
 
-div.video-container {
-    height: 350px;
-    max-height: 350px;
+div.media-container {
+    align-items: stretch;
 }
 
 div.video-column-container {
@@ -28,11 +27,17 @@ div.video-sorted-container {
     max-height: 350px;
 }
 
+div.webcam,
 div.files-container {
     height: 350px;
     max-height: 350px;
 }
 
+div.webcam div[data-testid="video"] > div.wrap,
+div.webcam div[data-testid="video"] > div.upload-container {
+    height: 310px;
+}
+
 div.files-container tr {
     padding-right: 20px;
 }
@@ -42,6 +47,8 @@ div.video-sorted-container div.icon-buttons > button {
     display: none;
 }
 
+div.webcam:hover label[data-testid="block-label"],
+div.video-container:hover label[data-testid="block-label"],
 div.files-container:hover label[data-testid="block-label"],
 div.video-container:hover label[data-testid="block-label"],
 div.video-sorted-container:hover label[data-testid="block-label"] {
@@ -58,11 +65,14 @@ div.dataframe div.table-wrap {
     height: auto !important;
 }
 
+div.video-container div.file-preview-holder,
 div.files-container div.file-preview-holder {
     overflow-y: scroll;
     height: 100%;
 }
 
+div.webcam label[data-testid="block-label"],
+div.video-container label[data-testid="block-label"],
 div.files-container label[data-testid="block-label"] {
     position: absolute;
 }
@@ -130,6 +140,10 @@ div.files-container label[data-testid="block-label"] {
     max-width: fit-content;
 }
 
+div.notifications {
+    height: 85px;
+}
+
 div.languages-container_wrapper {
     display: grid;
     justify-content: end;
@@ -169,6 +183,10 @@ div.languages-container > div.country_flags div.image-container > button > div.i
     height: 32px;
 }
 
+div.languages-container > div.country_flags div.image-container > div.icon-button-wrapper {
+    display: none;
+}
+
 .dropdown-language-container {
     display: contents;
 }
@@ -247,6 +265,14 @@ div.surname-container > div.metadata_surname-logo div.image-container,
 div.email-container > div.metadata_email-logo div.image-container,
 div.phone-container > div.metadata_phone-logo div.image-container {
     width: fit-content;
+    min-width: auto;
+}
+
+div.name-container > div.metadata_name-logo div.image-container > div.icon-button-wrapper,
+div.surname-container > div.metadata_surname-logo div.image-container > div.icon-button-wrapper,
+div.email-container > div.metadata_email-logo div.image-container > div.icon-button-wrapper,
+div.phone-container > div.metadata_phone-logo div.image-container > div.icon-button-wrapper {
+    display: none;
 }
 
 div.name-container > div.metadata_name-logo div.image-container > button > div > img,

app.py

@@ -12,12 +12,15 @@ from app.config import CONFIG_NAME, config_data, load_tab_creators
 from app.event_handlers.event_handlers import setup_app_event_handlers
 from app import tabs
 from app.components import dropdown_create_ui
+from app.port import is_port_in_use, free_ports
 
 gr.set_static_paths(paths=[config_data.StaticPaths_IMAGES])
 
 
 def create_gradio_app() -> gr.Blocks:
-    with gr.Blocks(css=config_data.AppSettings_CSS_PATH) as gradio_app:
+    with gr.Blocks(
+        theme=gr.themes.Default(), css_paths=config_data.AppSettings_CSS_PATH
+    ) as gradio_app:
         with gr.Column(
             visible=True,
             render=True,
@@ -39,6 +42,7 @@ def create_gradio_app() -> gr.Blocks:
                     visible=True,
                     show_download_button=False,
                     elem_classes="country_flags",
+                    show_fullscreen_button=False,
                 )
 
                 languages = dropdown_create_ui(
@@ -81,4 +85,14 @@ def create_gradio_app() -> gr.Blocks:
 
 
 if __name__ == "__main__":
-    create_gradio_app().queue(api_open=False).launch(share=False)
+    ports_to_check = [config_data.AppSettings_PORT]
+
+    for port in filter(None, ports_to_check):
+        if is_port_in_use(config_data.AppSettings_SERVER_NAME, port):
+            free_ports(port)
+
+    create_gradio_app().queue(api_open=False).launch(
+        share=True,
+        server_name=config_data.AppSettings_SERVER_NAME,
+        server_port=config_data.AppSettings_PORT,
+    )

app/authors.py

@@ -76,7 +76,7 @@ AUTHORS = """
         <a href="https://github.com/DmitryRyumin" style="display: inline-block;">
             <img src="https://github-stats-alpha.vercel.app/api?username=DmitryRyumin&cc=3081F7&tc=FFFFFF&ic=FFFFFF&bc=FFFFFF" alt="" />
         </a>
-        <div style="display: flex; flex-wrap: wrap;">
+        <div style="display: flex; flex-wrap: wrap; align-items: flex-start;">
             <img src="https://custom-icon-badges.demolab.com/badge/dynamic/json?style=flat-square&logo=fire&logoColor=fff&color=orange&label=GitHub%20streak&query=%24.currentStreak.length&suffix=%20days&url=https%3A%2F%2Fstreak-stats.demolab.com%2F%3Fuser%3Ddmitryryumin%26type%3Djson" alt="" style="margin-right: 6px; margin-bottom: 6px;" />
             <img src="https://komarev.com/ghpvc/?username=DmitryRyumin&style=flat-square" alt="" style="margin-bottom: 6px;" />
         </div>

app/components.py

@@ -13,11 +13,18 @@ from app.config import config_data
 
 
 def html_message(
-    message: str = "", error: bool = True, visible: bool = True
+    message: str = "",
+    error: bool = True,
+    visible: bool = True,
+    elem_classes: Optional[str] = "html-container",
 ) -> gr.HTML:
     css_class = "noti_err" if not error else "noti_true"
 
-    return gr.HTML(value=f"<h3 class='{css_class}'>{message}</h3>", visible=visible)
+    return gr.HTML(
+        value=f"<h3 class='{css_class}'>{message}</h3>",
+        visible=visible,
+        elem_classes=elem_classes,
+    )
 
 
 def files_create_ui(
@@ -53,7 +60,7 @@ def video_create_ui(
     show_label: bool = True,
     interactive: bool = False,
     visible: bool = True,
-    elem_classes: Optional[str] = "files-container",
+    elem_classes: Optional[str] = "video-container",
 ) -> gr.Video:
     if file_name is not None:
         label += f" ({file_name})"

app/data_init.py

@@ -0,0 +1,16 @@
+"""
+File: data_init.py
+Author: Elena Ryumina and Dmitry Ryumin
+Description: Data initialization.
+License: MIT License
+"""
+
+from app.config import config_data
+from app.utils import read_csv_file, extract_profession_weights
+
+
+df_traits_priority_for_professions = read_csv_file(config_data.Links_PROFESSIONS)
+weights_professions, interactive_professions = extract_profession_weights(
+    df_traits_priority_for_professions,
+    config_data.Settings_DROPDOWN_CANDIDATES[0],
+)

app/event_handlers/calculate_practical_tasks.py

@@ -6,18 +6,23 @@ License: MIT License
 """
 
 from app.oceanai_init import b5
+import pandas as pd
 import re
 import gradio as gr
 from pathlib import Path
+from bs4 import BeautifulSoup
 
 # Importing necessary components for the Gradio app
 from app.config import config_data
 from app.video_metadata import video_metadata
 from app.mbti_description import MBTI_DESCRIPTION, MBTI_DATA
+from app.data_init import df_traits_priority_for_professions
 from app.utils import (
     read_csv_file,
     apply_rounding_and_rename_columns,
     preprocess_scores_df,
+    get_language_settings,
+    extract_profession_weights,
 )
 from app.components import (
     html_message,
@@ -166,7 +171,10 @@ def create_person_metadata(person_id, files, video_metadata):
 
 
 def event_handler_calculate_practical_task_blocks(
+    language,
+    type_modes,
     files,
+    video,
     practical_subtasks,
     pt_scores,
     dropdown_mbti,
@@ -188,6 +196,11 @@ def event_handler_calculate_practical_task_blocks(
     number_agreeableness,
     number_non_neuroticism,
 ):
+    lang_id, _ = get_language_settings(language)
+
+    if type_modes == config_data.Settings_TYPE_MODES[1]:
+        files = [video]
+
     if practical_subtasks.lower() == "16 personality types of mbti":
         df_correlation_coefficients = read_csv_file(config_data.Links_MBTI)
 
@@ -195,44 +208,107 @@ def event_handler_calculate_practical_task_blocks(
 
         preprocess_scores_df(pt_scores_copy, config_data.Dataframes_PT_SCORES[0][0])
 
-        b5._professional_match(
-            df_files=pt_scores_copy,
-            correlation_coefficients=df_correlation_coefficients,
-            personality_type=remove_parentheses(dropdown_mbti),
-            threshold=threshold_mbti,
-            out=False,
-        )
+        if type_modes == config_data.Settings_TYPE_MODES[0]:
+            b5._professional_match(
+                df_files=pt_scores_copy,
+                correlation_coefficients=df_correlation_coefficients,
+                personality_type=remove_parentheses(dropdown_mbti),
+                threshold=threshold_mbti,
+                out=False,
+            )
 
-        df = apply_rounding_and_rename_columns(b5.df_files_MBTI_job_match_)
+            df = apply_rounding_and_rename_columns(b5.df_files_MBTI_job_match_)
 
-        df_hidden = df.drop(
-            columns=config_data.Settings_SHORT_PROFESSIONAL_SKILLS
-            + config_data.Settings_DROPDOWN_MBTI_DEL_COLS
-        )
+            df_hidden = df.drop(
+                columns=config_data.Settings_SHORT_PROFESSIONAL_SKILLS
+                + config_data.Settings_DROPDOWN_MBTI_DEL_COLS
+            )
 
-        df_hidden.rename(
-            columns={
-                "Path": "Filename",
-                "MBTI": "Personality Type",
-                "MBTI_Score": "Personality Type Score",
-            },
-            inplace=True,
-        )
+            df_hidden.rename(
+                columns={
+                    "Path": "Filename",
+                    "MBTI": "Personality Type",
+                    "MBTI_Score": "Personality Type Score",
+                },
+                inplace=True,
+            )
 
-        df_hidden.to_csv(config_data.Filenames_MBTI_JOB)
+            df_copy = df_hidden.copy()
+            df_copy["Personality Type"] = df_copy["Personality Type"].apply(
+                lambda x: "".join(BeautifulSoup(x, "html.parser").stripped_strings)
+            )
+            df_copy.to_csv(config_data.Filenames_MBTI_JOB, index=False)
 
-        df_hidden.reset_index(inplace=True)
+            df_hidden.reset_index(inplace=True)
 
-        person_id = int(df_hidden.iloc[0][config_data.Dataframes_PT_SCORES[0][0]]) - 1
+            person_id = (
+                int(df_hidden.iloc[0][config_data.Dataframes_PT_SCORES[0][0]]) - 1
+            )
 
-        short_mbti = extract_text_in_parentheses(dropdown_mbti)
-        mbti_values = df_hidden["Personality Type"].tolist()
+            short_mbti = extract_text_in_parentheses(dropdown_mbti)
+            mbti_values = df_hidden["Personality Type"].tolist()
 
-        df_hidden["Personality Type"] = [
-            compare_strings(short_mbti, mbti, False) for mbti in mbti_values
-        ]
+            df_hidden["Personality Type"] = [
+                compare_strings(short_mbti, mbti, False) for mbti in mbti_values
+            ]
 
-        person_metadata = create_person_metadata(person_id, files, video_metadata)
+            person_metadata = create_person_metadata(person_id, files, video_metadata)
+        elif type_modes == config_data.Settings_TYPE_MODES[1]:
+            all_hidden_dfs = []
+
+            for dropdown_mbti in config_data.Settings_DROPDOWN_MBTI:
+                b5._professional_match(
+                    df_files=pt_scores_copy,
+                    correlation_coefficients=df_correlation_coefficients,
+                    personality_type=remove_parentheses(dropdown_mbti),
+                    threshold=threshold_mbti,
+                    out=False,
+                )
+
+                df = apply_rounding_and_rename_columns(b5.df_files_MBTI_job_match_)
+
+                df_hidden = df.drop(
+                    columns=config_data.Settings_SHORT_PROFESSIONAL_SKILLS
+                    + config_data.Settings_DROPDOWN_MBTI_DEL_COLS
+                    + config_data.Settings_DROPDOWN_MBTI_DEL_COLS_WEBCAM
+                )
+
+                df_hidden.insert(0, "Popular Occupations", dropdown_mbti)
+
+                df_hidden.rename(
+                    columns={
+                        "MBTI": "Personality Type",
+                        "MBTI_Score": "Personality Type Score",
+                    },
+                    inplace=True,
+                )
+
+                short_mbti = extract_text_in_parentheses(dropdown_mbti)
+                mbti_values = df_hidden["Personality Type"].tolist()
+
+                df_hidden["Personality Type"] = [
+                    compare_strings(short_mbti, mbti, False) for mbti in mbti_values
+                ]
+
+                all_hidden_dfs.append(df_hidden)
+
+            df_hidden = pd.concat(all_hidden_dfs, ignore_index=True)
+
+            df_hidden = df_hidden.sort_values(
+                by="Personality Type Score", ascending=False
+            )
+
+            df_hidden.reset_index(drop=True, inplace=True)
+
+            df_copy = df_hidden.copy()
+            df_copy["Personality Type"] = df_copy["Personality Type"].apply(
+                lambda x: "".join(BeautifulSoup(x, "html.parser").stripped_strings)
+            )
+            df_copy.to_csv(config_data.Filenames_MBTI_JOB, index=False)
+
+            person_id = 0
+
+            person_metadata = create_person_metadata(person_id, files, video_metadata)
 
         existing_tuple = (
             gr.Row(visible=True),
@@ -277,117 +353,226 @@ def event_handler_calculate_practical_task_blocks(
 
         return existing_tuple[:-1] + person_metadata + existing_tuple[-1:]
     elif practical_subtasks.lower() == "professional groups":
-        sum_weights = sum(
-            [
-                number_openness,
-                number_conscientiousness,
-                number_extraversion,
-                number_agreeableness,
-                number_non_neuroticism,
-            ]
-        )
-
-        if sum_weights != 100:
-            gr.Warning(config_data.InformationMessages_SUM_WEIGHTS.format(sum_weights))
-
-            return (
-                gr.Row(visible=False),
-                gr.Column(visible=False),
-                dataframe(visible=False),
-                files_create_ui(
-                    None,
-                    "single",
-                    [".csv"],
-                    config_data.OtherMessages_EXPORT_PS,
-                    True,
-                    False,
-                    False,
-                    "csv-container",
-                ),
-                gr.Accordion(visible=False),
-                gr.HTML(visible=False),
-                dataframe(visible=False),
-                gr.Column(visible=False),
-                video_create_ui(visible=False),
-                gr.Column(visible=False),
-                gr.Row(visible=False),
-                gr.Row(visible=False),
-                gr.Image(visible=False),
-                textbox_create_ui(visible=False),
-                gr.Row(visible=False),
-                gr.Image(visible=False),
-                textbox_create_ui(visible=False),
-                gr.Row(visible=False),
-                gr.Row(visible=False),
-                gr.Image(visible=False),
-                textbox_create_ui(visible=False),
-                gr.Row(visible=False),
-                gr.Image(visible=False),
-                textbox_create_ui(visible=False),
-                html_message(
-                    config_data.InformationMessages_SUM_WEIGHTS.format(sum_weights),
-                    False,
-                    True,
-                ),
-            )
-        else:
-            b5._candidate_ranking(
-                df_files=pt_scores.iloc[:, 1:],
-                weigths_openness=number_openness,
-                weigths_conscientiousness=number_conscientiousness,
-                weigths_extraversion=number_extraversion,
-                weigths_agreeableness=number_agreeableness,
-                weigths_non_neuroticism=number_non_neuroticism,
-                out=False,
+        if type_modes == config_data.Settings_TYPE_MODES[0]:
+            sum_weights = sum(
+                [
+                    number_openness,
+                    number_conscientiousness,
+                    number_extraversion,
+                    number_agreeableness,
+                    number_non_neuroticism,
+                ]
             )
 
-            df = apply_rounding_and_rename_columns(b5.df_files_ranking_)
-
-            df_hidden = df.drop(columns=config_data.Settings_SHORT_PROFESSIONAL_SKILLS)
-
-            df_hidden.to_csv(config_data.Filenames_POTENTIAL_CANDIDATES)
-
-            df_hidden.reset_index(inplace=True)
+            if sum_weights != 100:
+                gr.Warning(
+                    config_data.InformationMessages_SUM_WEIGHTS.format(sum_weights)
+                )
+
+                return (
+                    gr.Row(visible=False),
+                    gr.Column(visible=False),
+                    dataframe(visible=False),
+                    files_create_ui(
+                        None,
+                        "single",
+                        [".csv"],
+                        config_data.OtherMessages_EXPORT_PS,
+                        True,
+                        False,
+                        False,
+                        "csv-container",
+                    ),
+                    gr.Accordion(visible=False),
+                    gr.HTML(visible=False),
+                    dataframe(visible=False),
+                    gr.Column(visible=False),
+                    video_create_ui(visible=False),
+                    gr.Column(visible=False),
+                    gr.Row(visible=False),
+                    gr.Row(visible=False),
+                    gr.Image(visible=False),
+                    textbox_create_ui(visible=False),
+                    gr.Row(visible=False),
+                    gr.Image(visible=False),
+                    textbox_create_ui(visible=False),
+                    gr.Row(visible=False),
+                    gr.Row(visible=False),
+                    gr.Image(visible=False),
+                    textbox_create_ui(visible=False),
+                    gr.Row(visible=False),
+                    gr.Image(visible=False),
+                    textbox_create_ui(visible=False),
+                    html_message(
+                        config_data.InformationMessages_SUM_WEIGHTS.format(sum_weights),
+                        False,
+                        True,
+                    ),
+                )
+            else:
+                b5._candidate_ranking(
+                    df_files=pt_scores.iloc[:, 1:],
+                    weigths_openness=number_openness,
+                    weigths_conscientiousness=number_conscientiousness,
+                    weigths_extraversion=number_extraversion,
+                    weigths_agreeableness=number_agreeableness,
+                    weigths_non_neuroticism=number_non_neuroticism,
+                    out=False,
+                )
+
+                df = apply_rounding_and_rename_columns(b5.df_files_ranking_)
+
+                df_hidden = df.drop(
+                    columns=config_data.Settings_SHORT_PROFESSIONAL_SKILLS
+                )
+
+                df_hidden.to_csv(config_data.Filenames_POTENTIAL_CANDIDATES)
+
+                df_hidden.reset_index(inplace=True)
+
+                person_id = (
+                    int(df_hidden.iloc[0][config_data.Dataframes_PT_SCORES[0][0]]) - 1
+                )
+
+                person_metadata = create_person_metadata(
+                    person_id, files, video_metadata
+                )
+        elif type_modes == config_data.Settings_TYPE_MODES[1]:
+            all_hidden_dfs = []
+
+            for dropdown_candidate in config_data.Settings_DROPDOWN_CANDIDATES[:-1]:
+                weights, _ = extract_profession_weights(
+                    df_traits_priority_for_professions,
+                    dropdown_candidate,
+                )
+
+                sum_weights = sum(weights)
+
+                if sum_weights != 100:
+                    gr.Warning(
+                        config_data.InformationMessages_SUM_WEIGHTS.format(sum_weights)
+                    )
+
+                    return (
+                        gr.Row(visible=False),
+                        gr.Column(visible=False),
+                        dataframe(visible=False),
+                        files_create_ui(
+                            None,
+                            "single",
+                            [".csv"],
+                            config_data.OtherMessages_EXPORT_PS,
+                            True,
+                            False,
+                            False,
+                            "csv-container",
+                        ),
+                        gr.Accordion(visible=False),
+                        gr.HTML(visible=False),
+                        dataframe(visible=False),
+                        gr.Column(visible=False),
+                        video_create_ui(visible=False),
+                        gr.Column(visible=False),
+                        gr.Row(visible=False),
+                        gr.Row(visible=False),
+                        gr.Image(visible=False),
+                        textbox_create_ui(visible=False),
+                        gr.Row(visible=False),
+                        gr.Image(visible=False),
+                        textbox_create_ui(visible=False),
+                        gr.Row(visible=False),
+                        gr.Row(visible=False),
+                        gr.Image(visible=False),
+                        textbox_create_ui(visible=False),
+                        gr.Row(visible=False),
+                        gr.Image(visible=False),
+                        textbox_create_ui(visible=False),
+                        html_message(
+                            config_data.InformationMessages_SUM_WEIGHTS.format(
+                                sum_weights
+                            ),
+                            False,
+                            True,
+                        ),
+                    )
+                else:
+                    b5._candidate_ranking(
+                        df_files=pt_scores.iloc[:, 1:],
+                        weigths_openness=weights[0],
+                        weigths_conscientiousness=weights[1],
+                        weigths_extraversion=weights[2],
+                        weigths_agreeableness=weights[3],
+                        weigths_non_neuroticism=weights[4],
+                        out=False,
+                    )
+
+                    df = apply_rounding_and_rename_columns(b5.df_files_ranking_)
+
+                    df_hidden = df.drop(
+                        columns=config_data.Settings_SHORT_PROFESSIONAL_SKILLS
+                        + config_data.Settings_DROPDOWN_MBTI_DEL_COLS_WEBCAM
+                    )
+
+                    df_hidden.insert(0, "Professional Group", dropdown_candidate)
+
+                    all_hidden_dfs.append(df_hidden)
+
+                df_hidden = pd.concat(all_hidden_dfs, ignore_index=True)
+
+                df_hidden.rename(
+                    columns={
+                        "Candidate score": "Summary Score",
+                    },
+                    inplace=True,
+                )
+
+                df_hidden = df_hidden.sort_values(by="Summary Score", ascending=False)
+
+                df_hidden.reset_index(drop=True, inplace=True)
+
+                df_hidden.to_csv(
+                    config_data.Filenames_POTENTIAL_CANDIDATES, index=False
+                )
+
+                person_id = 0
+
+                person_metadata = create_person_metadata(
+                    person_id, files, video_metadata
+                )
 
-            person_id = (
-                int(df_hidden.iloc[0][config_data.Dataframes_PT_SCORES[0][0]]) - 1
-            )
-
-            person_metadata = create_person_metadata(person_id, files, video_metadata)
-
-            existing_tuple = (
-                gr.Row(visible=True),
-                gr.Column(visible=True),
-                dataframe(
-                    headers=df_hidden.columns.tolist(),
-                    values=df_hidden.values.tolist(),
-                    visible=True,
-                ),
-                files_create_ui(
-                    config_data.Filenames_POTENTIAL_CANDIDATES,
-                    "single",
-                    [".csv"],
-                    config_data.OtherMessages_EXPORT_PG,
-                    True,
-                    False,
-                    True,
-                    "csv-container",
-                ),
-                gr.Accordion(visible=False),
-                gr.HTML(visible=False),
-                dataframe(visible=False),
-                gr.Column(visible=True),
-                video_create_ui(
-                    value=files[person_id],
-                    file_name=Path(files[person_id]).name,
-                    label="Best Person ID - " + str(person_id + 1),
-                    visible=True,
-                    elem_classes="video-sorted-container",
-                ),
-                html_message(config_data.InformationMessages_NOTI_IN_DEV, False, False),
-            )
+        existing_tuple = (
+            gr.Row(visible=True),
+            gr.Column(visible=True),
+            dataframe(
+                headers=df_hidden.columns.tolist(),
+                values=df_hidden.values.tolist(),
+                visible=True,
+            ),
+            files_create_ui(
+                config_data.Filenames_POTENTIAL_CANDIDATES,
+                "single",
+                [".csv"],
+                config_data.OtherMessages_EXPORT_PG,
+                True,
+                False,
+                True,
+                "csv-container",
+            ),
+            gr.Accordion(visible=False),
+            gr.HTML(visible=False),
+            dataframe(visible=False),
+            gr.Column(visible=True),
+            video_create_ui(
+                value=files[person_id],
+                file_name=Path(files[person_id]).name,
+                label="Best Person ID - " + str(person_id + 1),
+                visible=True,
+                elem_classes="video-sorted-container",
+            ),
+            html_message(config_data.InformationMessages_NOTI_IN_DEV, False, False),
+        )
 
-            return existing_tuple[:-1] + person_metadata + existing_tuple[-1:]
+        return existing_tuple[:-1] + person_metadata + existing_tuple[-1:]
     elif practical_subtasks.lower() == "professional skills":
         df_professional_skills = read_csv_file(config_data.Links_PROFESSIONAL_SKILLS)
 
@@ -400,26 +585,44 @@ def event_handler_calculate_practical_task_blocks(
 
         df = apply_rounding_and_rename_columns(b5.df_files_priority_skill_)
 
-        professional_skills_list = (
-            config_data.Settings_DROPDOWN_PROFESSIONAL_SKILLS.copy()
-        )
+        if type_modes == config_data.Settings_TYPE_MODES[0]:
+            professional_skills_list = (
+                config_data.Settings_DROPDOWN_PROFESSIONAL_SKILLS.copy()
+            )
+
+            professional_skills_list.remove(dropdown_professional_skills)
 
-        professional_skills_list.remove(dropdown_professional_skills)
+            del_cols = []
+        elif type_modes == config_data.Settings_TYPE_MODES[1]:
+            professional_skills_list = []
+            del_cols = config_data.Settings_DROPDOWN_MBTI_DEL_COLS_WEBCAM
 
         df_hidden = df.drop(
             columns=config_data.Settings_SHORT_PROFESSIONAL_SKILLS
             + professional_skills_list
+            + del_cols
         )
 
-        df_hidden.to_csv(config_data.Filenames_PT_SKILLS_SCORES)
+        if type_modes == config_data.Settings_TYPE_MODES[0]:
+            df_hidden = df_hidden.sort_values(
+                by=[dropdown_professional_skills], ascending=False
+            )
+        elif type_modes == config_data.Settings_TYPE_MODES[1]:
+            df_hidden = df_hidden.melt(
+                var_name="Professional Skill", value_name="Summary Score"
+            )
+            df_hidden = df_hidden.sort_values(by=["Summary Score"], ascending=False)
 
-        df_hidden.reset_index(inplace=True)
+        df_hidden.reset_index(drop=True, inplace=True)
 
-        df_hidden = df_hidden.sort_values(
-            by=[dropdown_professional_skills], ascending=False
-        )
+        df_hidden.to_csv(config_data.Filenames_PT_SKILLS_SCORES)
 
-        person_id = int(df_hidden.iloc[0][config_data.Dataframes_PT_SCORES[0][0]]) - 1
+        if type_modes == config_data.Settings_TYPE_MODES[0]:
+            person_id = (
+                int(df_hidden.iloc[0][config_data.Dataframes_PT_SCORES[0][0]]) - 1
+            )
+        elif type_modes == config_data.Settings_TYPE_MODES[1]:
+            person_id = 0
 
         person_metadata = create_person_metadata(person_id, files, video_metadata)
 

app/event_handlers/calculate_pt_scores_blocks.py

@@ -26,23 +26,52 @@ from app.components import (
 )
 
 
-def event_handler_calculate_pt_scores_blocks(language, files, evt_data: gr.EventData):
+def event_handler_calculate_pt_scores_blocks(
+    language, type_modes, files, video, evt_data: gr.EventData
+):
     _ = evt_data.target.__class__.__name__
 
     lang_id, _ = get_language_settings(language)
 
     out = False
-    b5.get_avt_predictions_gradio(
-        paths=files, url_accuracy="", accuracy=False, lang="en", out=out
-    )
 
-    first_practical_task = next(iter(supported_practical_tasks))
+    try:
+        b5.get_avt_predictions_gradio(
+            paths=(
+                files if type_modes == config_data.Settings_TYPE_MODES[0] else [video]
+            ),
+            url_accuracy="",
+            accuracy=False,
+            lang="en",
+            out=out,
+        )
+    except TypeError:
+        out = True
+
+    if type_modes == config_data.Settings_TYPE_MODES[0]:
+        supported_practical_tasks_ren = supported_practical_tasks
+    elif type_modes == config_data.Settings_TYPE_MODES[1]:
+        rename_map = {
+            "Ranking potential candidates by professional responsibilities": "Estimating professional abilities",
+            "Ранжирование потенциальных кандидатов по профессиональным обязанностям": "Определить профессиональные возможности",
+        }
 
-    if len(b5.df_files_) == 0:
-        gr.Warning(config_data.OtherMessages_CALCULATE_PT_SCORES_ERR)
+        supported_practical_tasks_ren = [
+            {rename_map.get(k, k): v for k, v in d.items()}
+            for d in supported_practical_tasks
+        ]
+
+    first_practical_task = next(iter(supported_practical_tasks_ren[lang_id]))
+
+    if out or len(b5.df_files_) == 0:
+        gr.Warning(config_data.OtherMessages_CALCULATE_PT_SCORES_ERR[lang_id])
 
         return (
-            html_message(config_data.OtherMessages_CALCULATE_PT_SCORES_ERR, False),
+            html_message(
+                config_data.OtherMessages_CALCULATE_PT_SCORES_ERR[lang_id],
+                False,
+                "notifications",
+            ),
             dataframe(visible=False),
             files_create_ui(
                 None,
@@ -59,23 +88,24 @@ def event_handler_calculate_pt_scores_blocks(language, files, evt_data: gr.Event
             radio_create_ui(
                 first_practical_task,
                 config_data.Labels_PRACTICAL_TASKS_LABEL,
-                list(map(str, supported_practical_tasks.keys())),
-                config_data.InformationMessages_PRACTICAL_TASKS_INFO,
+                list(map(str, supported_practical_tasks_ren[lang_id].keys())),
+                config_data.InformationMessages_PRACTICAL_TASKS_INFO[lang_id],
                 True,
                 True,
             ),
             radio_create_ui(
-                supported_practical_tasks[first_practical_task][0],
-                config_data.Labels_PRACTICAL_SUBTASKS_LABEL,
-                supported_practical_tasks[first_practical_task],
-                config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO,
+                supported_practical_tasks_ren[lang_id][first_practical_task][0],
+                config_data.Labels_PRACTICAL_SUBTASKS_LABEL[lang_id],
+                supported_practical_tasks_ren[lang_id][first_practical_task],
+                config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO[lang_id],
                 True,
                 True,
             ),
             gr.JSON(
                 value={
-                    str(task): supported_practical_tasks.get(task, [None])[0]
-                    for task in supported_practical_tasks.keys()
+                    str(task): supported_practical_tasks_ren[index].get(task, [None])[0]
+                    for index in range(len(supported_practical_tasks_ren))
+                    for task in supported_practical_tasks_ren[index].keys()
                 },
                 visible=False,
                 render=True,
@@ -149,9 +179,25 @@ def event_handler_calculate_pt_scores_blocks(language, files, evt_data: gr.Event
     df_files = b5.df_files_.copy()
     df_files.reset_index(inplace=True)
 
+    if type_modes == config_data.Settings_TYPE_MODES[0]:
+        practical_tasks_choices = list(
+            map(str, supported_practical_tasks_ren[lang_id].keys())
+        )
+    elif type_modes == config_data.Settings_TYPE_MODES[1]:
+        practical_tasks_choices = [
+            value
+            for i, value in enumerate(
+                map(str, supported_practical_tasks_ren[lang_id].keys())
+            )
+            if i not in {1}
+        ]
+
     return (
         html_message(
-            config_data.InformationMessages_NOTI_VIDEOS[lang_id], False, False
+            config_data.InformationMessages_NOTI_VIDEOS[lang_id],
+            False,
+            False,
+            "notifications",
         ),
         dataframe(
             headers=(config_data.Dataframes_PT_SCORES[lang_id]),
@@ -172,35 +218,38 @@ def event_handler_calculate_pt_scores_blocks(language, files, evt_data: gr.Event
         gr.Column(visible=True),
         radio_create_ui(
             first_practical_task,
-            "Practical tasks",
-            list(map(str, supported_practical_tasks.keys())),
-            config_data.InformationMessages_PRACTICAL_TASKS_INFO,
+            config_data.Labels_PRACTICAL_TASKS_LABEL[lang_id],
+            practical_tasks_choices,
+            config_data.InformationMessages_PRACTICAL_TASKS_INFO[lang_id],
             True,
             True,
         ),
         radio_create_ui(
-            supported_practical_tasks[first_practical_task][0],
-            "Practical subtasks",
-            supported_practical_tasks[first_practical_task],
-            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO,
+            supported_practical_tasks_ren[lang_id][first_practical_task][0],
+            config_data.Labels_PRACTICAL_SUBTASKS_LABEL[lang_id],
+            supported_practical_tasks_ren[lang_id][first_practical_task],
+            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO[lang_id],
             True,
             True,
         ),
         gr.JSON(
             value={
-                str(task): supported_practical_tasks.get(task, [None])[0]
-                for task in supported_practical_tasks.keys()
+                str(task): supported_practical_tasks_ren[index].get(task, [None])[0]
+                for index in range(len(supported_practical_tasks_ren))
+                for task in supported_practical_tasks_ren[index].keys()
             },
             visible=False,
             render=True,
         ),
-        gr.Column(visible=True),
+        gr.Column(
+            visible=True if type_modes == config_data.Settings_TYPE_MODES[0] else False
+        ),
         dropdown_create_ui(
             label=f"Potential candidates by Personality Type of MBTI ({len(config_data.Settings_DROPDOWN_MBTI)})",
             info=config_data.InformationMessages_DROPDOWN_MBTI_INFO,
             choices=config_data.Settings_DROPDOWN_MBTI,
             value=config_data.Settings_DROPDOWN_MBTI[0],
-            visible=True,
+            visible=True if type_modes == config_data.Settings_TYPE_MODES[0] else False,
             elem_classes="dropdown-container",
         ),
         number_create_ui(
@@ -212,7 +261,7 @@ def event_handler_calculate_pt_scores_blocks(language, files, evt_data: gr.Event
             info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
             show_label=True,
             interactive=True,
-            visible=True,
+            visible=True if type_modes == config_data.Settings_TYPE_MODES[0] else False,
             render=True,
             elem_classes="number-container",
         ),

app/event_handlers/clear_blocks.py

@@ -25,20 +25,47 @@ from app.components import (
 from app.utils import get_language_settings
 
 
-def event_handler_clear_blocks(language):
+def event_handler_clear_blocks(language, type_modes):
     lang_id, _ = get_language_settings(language)
 
-    first_practical_task = next(iter(supported_practical_tasks))
+    first_practical_task = next(iter(supported_practical_tasks[lang_id]))
 
-    return (
-        html_message(config_data.InformationMessages_NOTI_VIDEOS[lang_id], False),
-        files_create_ui(
+    if type_modes == config_data.Settings_TYPE_MODES[0]:
+        files_ui = files_create_ui(
+            label="{} ({})".format(
+                config_data.OtherMessages_VIDEO_FILES[
+                    config_data.AppSettings_DEFAULT_LANG_ID
+                ],
+                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+            ),
+            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
+        )
+        webcam = gr.Video(interactive=False, visible=False)
+    elif type_modes == config_data.Settings_TYPE_MODES[1]:
+        files_ui = files_create_ui(
             label="{} ({})".format(
                 config_data.OtherMessages_VIDEO_FILES[lang_id],
                 ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
             ),
             file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
+            interactive=False,
+            visible=False,
+        )
+        webcam = gr.Video(interactive=True, visible=True)
+
+    return (
+        html_message(
+            (
+                config_data.InformationMessages_NOTI_VIDEOS[lang_id].split("(")[0]
+                if lang_id == 0
+                else config_data.InformationMessages_NOTI_VIDEOS[lang_id]
+            ),
+            False,
+            True,
+            "notifications",
         ),
+        files_ui,
+        webcam,
         video_create_ui(),
         button(
             config_data.OtherMessages_CALCULATE_PT_SCORES[lang_id],
@@ -71,24 +98,25 @@ def event_handler_clear_blocks(language):
         gr.Column(visible=False),
         radio_create_ui(
             first_practical_task,
-            "Practical tasks",
-            list(map(str, supported_practical_tasks.keys())),
-            config_data.InformationMessages_PRACTICAL_TASKS_INFO,
+            config_data.Labels_PRACTICAL_TASKS_LABEL[lang_id],
+            list(map(str, supported_practical_tasks[lang_id].keys())),
+            config_data.InformationMessages_PRACTICAL_TASKS_INFO[lang_id],
             True,
             True,
         ),
         radio_create_ui(
-            supported_practical_tasks[first_practical_task][0],
-            "Practical subtasks",
-            supported_practical_tasks[first_practical_task],
-            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO,
+            supported_practical_tasks[lang_id][first_practical_task][0],
+            config_data.Labels_PRACTICAL_SUBTASKS_LABEL[lang_id],
+            supported_practical_tasks[lang_id][first_practical_task],
+            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO[lang_id],
             True,
             True,
         ),
         gr.JSON(
             value={
-                str(task): supported_practical_tasks.get(task, [None])[0]
-                for task in supported_practical_tasks.keys()
+                str(task): supported_practical_tasks[index].get(task, [None])[0]
+                for index in range(len(supported_practical_tasks))
+                for task in supported_practical_tasks[index].keys()
             },
             visible=False,
             render=True,

app/event_handlers/dropdown_candidates.py

@@ -7,16 +7,13 @@ License: MIT License
 
 # Importing necessary components for the Gradio app
 from app.config import config_data
-from app.utils import read_csv_file, extract_profession_weights
-from app.components import number_create_ui, dropdown_create_ui
+from app.utils import extract_profession_weights
+from app.data_init import df_traits_priority_for_professions
+from app.components import number_create_ui
 
 
 def event_handler_dropdown_candidates(practical_subtasks, dropdown_candidates):
     if practical_subtasks.lower() == "professional groups":
-        df_traits_priority_for_professions = read_csv_file(
-            config_data.Links_PROFESSIONS
-        )
-
         weights, interactive = extract_profession_weights(
             df_traits_priority_for_professions,
             dropdown_candidates,

app/event_handlers/event_handlers.py

@@ -9,11 +9,13 @@ import gradio as gr
 
 # Importing necessary components for the Gradio app
 from app.event_handlers.languages import event_handler_languages
+from app.event_handlers.switching_modes import event_handler_switching_modes
 from app.event_handlers.files import (
     event_handler_files,
     event_handler_files_select,
     event_handler_files_delete,
 )
+from app.event_handlers.webcam import event_handler_webcam
 from app.event_handlers.examples_blocks import event_handler_examples_blocks
 from app.event_handlers.clear_blocks import event_handler_clear_blocks
 from app.event_handlers.calculate_pt_scores_blocks import (
@@ -33,6 +35,9 @@ def setup_app_event_handlers(
     step_1,
     notifications,
     files,
+    webcam,
+    switching_modes,
+    type_modes,
     video,
     examples,
     calculate_pt_scores,
@@ -101,7 +106,16 @@ def setup_app_event_handlers(
     # Events
     languages.select(
         fn=event_handler_languages,
-        inputs=[languages, files, video, pt_scores, csv_pt_scores],
+        inputs=[
+            languages,
+            files,
+            video,
+            type_modes,
+            pt_scores,
+            csv_pt_scores,
+            practical_tasks,
+            practical_subtasks,
+        ],
         outputs=[
             description,
             step_1,
@@ -112,6 +126,8 @@ def setup_app_event_handlers(
             tab3,
             tab4,
             files,
+            webcam,
+            switching_modes,
             video,
             examples,
             calculate_pt_scores,
@@ -120,6 +136,77 @@ def setup_app_event_handlers(
             pt_scores,
             csv_pt_scores,
             step_2,
+            practical_tasks_column,
+            practical_tasks,
+            practical_subtasks,
+        ],
+        queue=True,
+    )
+    switching_modes.click(
+        fn=event_handler_switching_modes,
+        inputs=[languages, type_modes],
+        outputs=[
+            notifications,
+            files,
+            webcam,
+            switching_modes,
+            type_modes,
+            video,
+            examples,
+            calculate_pt_scores,
+            clear_app,
+            pt_scores,
+            csv_pt_scores,
+            step_2,
+            practical_tasks_column,
+            practical_tasks,
+            practical_subtasks,
+            practical_subtasks_selected,
+            settings_practical_tasks,
+            dropdown_mbti,
+            threshold_mbti,
+            threshold_professional_skills,
+            dropdown_professional_skills,
+            target_score_ope,
+            target_score_con,
+            target_score_ext,
+            target_score_agr,
+            target_score_nneu,
+            equal_coefficient,
+            number_priority,
+            number_importance_traits,
+            threshold_consumer_preferences,
+            dropdown_candidates,
+            number_openness,
+            number_conscientiousness,
+            number_extraversion,
+            number_agreeableness,
+            number_non_neuroticism,
+            sorted_videos,
+            sorted_videos_column,
+            practical_task_sorted,
+            csv_practical_task_sorted,
+            mbti_accordion,
+            mbti_description,
+            mbti_description_data,
+            video_sorted_column,
+            video_sorted,
+            metadata,
+            metadata_1,
+            name_row,
+            name_logo,
+            name,
+            surname_row,
+            surname_logo,
+            surname,
+            metadata_2,
+            email_row,
+            email_logo,
+            email,
+            phone_row,
+            phone_logo,
+            phone,
+            in_development,
         ],
         queue=True,
     )
@@ -141,13 +228,17 @@ def setup_app_event_handlers(
         [video],
         queue=True,
     )
+    gr.on(
+        triggers=[webcam.upload, webcam.stop_recording],
+        fn=event_handler_webcam,
+        inputs=[languages, webcam, pt_scores],
+        outputs=[notifications, video, webcam, calculate_pt_scores, clear_app],
+        queue=True,
+    )
     gr.on(
         triggers=[calculate_pt_scores.click],
         fn=event_handler_calculate_pt_scores_blocks,
-        inputs=[
-            languages,
-            files,
-        ],
+        inputs=[languages, type_modes, files, video],
         outputs=[
             notifications,
             pt_scores,
@@ -208,18 +299,75 @@ def setup_app_event_handlers(
     )
     examples.click(
         fn=event_handler_examples_blocks,
-        inputs=[],
+        inputs=[languages, type_modes],
         outputs=[
+            notifications,
             files,
+            video,
+            calculate_pt_scores,
+            clear_app,
+            pt_scores,
+            csv_pt_scores,
+            step_2,
+            practical_tasks_column,
+            practical_tasks,
+            practical_subtasks,
+            practical_subtasks_selected,
+            settings_practical_tasks,
+            dropdown_mbti,
+            threshold_mbti,
+            threshold_professional_skills,
+            dropdown_professional_skills,
+            target_score_ope,
+            target_score_con,
+            target_score_ext,
+            target_score_agr,
+            target_score_nneu,
+            equal_coefficient,
+            number_priority,
+            number_importance_traits,
+            threshold_consumer_preferences,
+            dropdown_candidates,
+            number_openness,
+            number_conscientiousness,
+            number_extraversion,
+            number_agreeableness,
+            number_non_neuroticism,
+            sorted_videos,
+            sorted_videos_column,
+            practical_task_sorted,
+            csv_practical_task_sorted,
+            mbti_accordion,
+            mbti_description,
+            mbti_description_data,
+            video_sorted_column,
+            video_sorted,
+            metadata,
+            metadata_1,
+            name_row,
+            name_logo,
+            name,
+            surname_row,
+            surname_logo,
+            surname,
+            metadata_2,
+            email_row,
+            email_logo,
+            email,
+            phone_row,
+            phone_logo,
+            phone,
+            in_development,
         ],
         queue=True,
     )
     clear_app.click(
         fn=event_handler_clear_blocks,
-        inputs=[languages],
+        inputs=[languages, type_modes],
         outputs=[
             notifications,
             files,
+            webcam,
             video,
             calculate_pt_scores,
             clear_app,
@@ -280,13 +428,19 @@ def setup_app_event_handlers(
     )
     practical_tasks.change(
         event_handler_practical_tasks,
-        [practical_tasks, practical_subtasks_selected],
+        [languages, type_modes, practical_tasks, practical_subtasks_selected],
         [practical_subtasks],
         queue=True,
     )
     practical_subtasks.change(
         event_handler_practical_subtasks,
-        [practical_tasks, practical_subtasks, practical_subtasks_selected],
+        [
+            languages,
+            type_modes,
+            practical_tasks,
+            practical_subtasks,
+            practical_subtasks_selected,
+        ],
         [
             practical_subtasks_selected,
             settings_practical_tasks,
@@ -327,7 +481,10 @@ def setup_app_event_handlers(
     calculate_practical_task.click(
         fn=event_handler_calculate_practical_task_blocks,
         inputs=[
+            languages,
+            type_modes,
             files,
+            video,
             practical_subtasks,
             pt_scores,
             dropdown_mbti,
@@ -380,7 +537,7 @@ def setup_app_event_handlers(
     )
     practical_task_sorted.select(
         event_handler_practical_task_sorted,
-        [files, practical_task_sorted],
+        [type_modes, files, video, practical_task_sorted],
         [
             video_sorted_column,
             video_sorted,

app/event_handlers/examples_blocks.py

@@ -6,25 +6,177 @@ License: MIT License
 """
 
 import re
+import gradio as gr
 from pathlib import Path
 
 # Importing necessary components for the Gradio app
+from app.config import config_data
+from app.description_steps import STEP_2
+from app.practical_tasks import supported_practical_tasks
+from app.components import (
+    html_message,
+    files_create_ui,
+    video_create_ui,
+    button,
+    dataframe,
+    radio_create_ui,
+    number_create_ui,
+    dropdown_create_ui,
+    textbox_create_ui,
+)
+from app.utils import get_language_settings
 
-# import hashlib
-# import time
 
-# for _ in range(6):
-#     current_time = time.time()
-#     time_bytes = str(current_time).encode("utf-8")
-#     hash_object = hashlib.sha256(time_bytes)
-#     hex_digest = hash_object.hexdigest()
-#     print(hex_digest[:15])
+def event_handler_examples_blocks(language, type_modes):
+    lang_id, _ = get_language_settings(language)
 
+    first_practical_task = next(iter(supported_practical_tasks[lang_id]))
 
-def event_handler_examples_blocks():
     videos_dir = Path("videos")
     video_files = sorted(
         (str(p) for p in videos_dir.glob("*.mp4")),
         key=lambda x: int(re.search(r"\d+", Path(x).stem).group()),
     )
-    return video_files
+
+    if type_modes == config_data.Settings_TYPE_MODES[0]:
+        files_ui = files_create_ui(
+            value=video_files,
+            label="{} ({})".format(
+                config_data.OtherMessages_VIDEO_FILES[lang_id],
+                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+            ),
+            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
+        )
+    elif type_modes == config_data.Settings_TYPE_MODES[1]:
+        files_ui = files_create_ui(
+            label="{} ({})".format(
+                config_data.OtherMessages_VIDEO_FILES[lang_id],
+                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+            ),
+            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
+            interactive=False,
+            visible=False,
+        )
+
+    return (
+        html_message(
+            config_data.OtherMessages_NOTI_CALCULATE[lang_id],
+            True,
+            True,
+            "notifications",
+        ),
+        files_ui,
+        video_create_ui(
+            value=video_files[0],
+            label=config_data.OtherMessages_VIDEO_PLAYER[lang_id],
+            file_name=Path(Path(video_files[0]).name).name,
+        ),
+        button(
+            config_data.OtherMessages_CALCULATE_PT_SCORES[lang_id],
+            True,
+            3,
+            "./images/calculate_pt_scores.ico",
+            True,
+            "calculate_oceanai",
+        ),
+        button(
+            config_data.OtherMessages_CLEAR_APP[lang_id],
+            True,
+            1,
+            "./images/clear.ico",
+            True,
+            "clear_oceanai",
+        ),
+        dataframe(visible=False),
+        files_create_ui(
+            None,
+            "single",
+            [".csv"],
+            config_data.OtherMessages_EXPORT_PT_SCORES[lang_id],
+            True,
+            False,
+            False,
+            "csv-container",
+        ),
+        gr.HTML(value=STEP_2[lang_id], visible=False),
+        gr.Column(visible=False),
+        radio_create_ui(
+            first_practical_task,
+            config_data.Labels_PRACTICAL_TASKS_LABEL[lang_id],
+            list(map(str, supported_practical_tasks[lang_id].keys())),
+            config_data.InformationMessages_PRACTICAL_TASKS_INFO[lang_id],
+            True,
+            True,
+        ),
+        radio_create_ui(
+            supported_practical_tasks[lang_id][first_practical_task][0],
+            config_data.Labels_PRACTICAL_SUBTASKS_LABEL[lang_id],
+            supported_practical_tasks[lang_id][first_practical_task],
+            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO[lang_id],
+            True,
+            True,
+        ),
+        gr.JSON(
+            value={
+                str(task): supported_practical_tasks[index].get(task, [None])[0]
+                for index in range(len(supported_practical_tasks))
+                for task in supported_practical_tasks[index].keys()
+            },
+            visible=False,
+            render=True,
+        ),
+        gr.Column(visible=False),
+        dropdown_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        dropdown_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        dropdown_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        gr.Row(visible=False),
+        gr.Column(visible=False),
+        dataframe(visible=False),
+        files_create_ui(
+            None,
+            "single",
+            [".csv"],
+            config_data.OtherMessages_EXPORT_PS,
+            True,
+            False,
+            False,
+            "csv-container",
+        ),
+        gr.Accordion(visible=False),
+        gr.HTML(visible=False),
+        dataframe(visible=False),
+        gr.Column(visible=False),
+        video_create_ui(visible=False),
+        gr.Column(visible=False),
+        gr.Row(visible=False),
+        gr.Row(visible=False),
+        gr.Image(visible=False),
+        textbox_create_ui(visible=False),
+        gr.Row(visible=False),
+        gr.Image(visible=False),
+        textbox_create_ui(visible=False),
+        gr.Row(visible=False),
+        gr.Row(visible=False),
+        gr.Image(visible=False),
+        textbox_create_ui(visible=False),
+        gr.Row(visible=False),
+        gr.Image(visible=False),
+        textbox_create_ui(visible=False),
+        html_message(config_data.InformationMessages_NOTI_IN_DEV, False, False),
+    )

app/event_handlers/files.py

@@ -1,7 +1,7 @@
 """
-File: search.py
+File: files.py
 Author: Elena Ryumina and Dmitry Ryumin
-Description: Event handler for searching and filtering papers in the Gradio app.
+Description: Event handler for files.
 License: MIT License
 """
 
@@ -19,7 +19,16 @@ def event_handler_files(language, files, video, pt_scores):
 
     if not files:
         return (
-            html_message(config_data.InformationMessages_NOTI_VIDEOS[lang_id], False),
+            html_message(
+                (
+                    config_data.InformationMessages_NOTI_VIDEOS[lang_id].split("(")[0]
+                    if lang_id == 0
+                    else config_data.InformationMessages_NOTI_VIDEOS[lang_id]
+                ),
+                False,
+                True,
+                "notifications",
+            ),
             video_create_ui(label=config_data.OtherMessages_VIDEO_PLAYER[lang_id]),
             button(
                 config_data.OtherMessages_CALCULATE_PT_SCORES[lang_id],
@@ -47,6 +56,7 @@ def event_handler_files(language, files, video, pt_scores):
             config_data.OtherMessages_NOTI_CALCULATE[lang_id],
             True,
             False if pt_scores.shape[1] >= 7 else True,
+            "notifications",
         ),
         video_create_ui(
             value=video,

app/event_handlers/languages.py

@@ -19,17 +19,91 @@ from app.components import (
     button,
     html_message,
     dataframe,
+    radio_create_ui,
 )
 from app.utils import get_language_settings
+from app.practical_tasks import supported_practical_tasks
 
 
-def event_handler_languages(languages, files, video, pt_scores, csv_pt_scores):
+def event_handler_languages(
+    languages,
+    files,
+    video,
+    type_modes,
+    pt_scores,
+    csv_pt_scores,
+    practical_tasks,
+    practical_subtasks,
+):
     lang_id, choices = get_language_settings(languages)
+    lang_id_inverse = {0: 1, 1: 0}.get(lang_id, None)
+
+    if type_modes == config_data.Settings_TYPE_MODES[0]:
+        files_ui = files_create_ui(
+            label="{} ({})".format(
+                config_data.OtherMessages_VIDEO_FILES[
+                    config_data.AppSettings_DEFAULT_LANG_ID
+                ],
+                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+            ),
+            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
+        )
+        webcam = gr.Video(interactive=False, visible=False)
+        switching_modes = button(
+            config_data.OtherMessages_SWITCHEHG_MODES_ONLINE[lang_id],
+            True,
+            1,
+            "./images/webcam.ico",
+            True,
+            "switching_modes",
+        )
+        examples = button(
+            config_data.OtherMessages_EXAMPLES_APP[lang_id],
+            True,
+            1,
+            "./images/examples.ico",
+            True,
+            "examples_oceanai",
+        )
+    elif type_modes == config_data.Settings_TYPE_MODES[1]:
+        files_ui = files_create_ui(
+            label="{} ({})".format(
+                config_data.OtherMessages_VIDEO_FILES[lang_id],
+                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+            ),
+            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
+            interactive=False,
+            visible=False,
+        )
+        webcam = gr.Video(interactive=True, visible=True)
+        switching_modes = button(
+            config_data.OtherMessages_SWITCHEHG_MODES_OFFLINE[lang_id],
+            True,
+            1,
+            "./images/videos.ico",
+            True,
+            "switching_modes",
+        )
+        examples = button(
+            config_data.OtherMessages_EXAMPLE_APP[lang_id],
+            True,
+            1,
+            "./images/examples.ico",
+            True,
+            "examples_oceanai",
+        )
 
     if not video:
         video = video_create_ui(label=config_data.OtherMessages_VIDEO_PLAYER[lang_id])
         noti_videos = html_message(
-            config_data.InformationMessages_NOTI_VIDEOS[lang_id], False
+            (
+                config_data.InformationMessages_NOTI_VIDEOS[lang_id].split("(")[0]
+                if lang_id == 0
+                else config_data.InformationMessages_NOTI_VIDEOS[lang_id]
+            ),
+            False,
+            True,
+            "notifications",
         )
     else:
         video = video_create_ui(
@@ -41,6 +115,7 @@ def event_handler_languages(languages, files, video, pt_scores, csv_pt_scores):
             config_data.OtherMessages_NOTI_CALCULATE[lang_id],
             True,
             False if pt_scores.shape[1] >= 7 else True,
+            "notifications",
         )
 
     csv_pt_scores = files_create_ui(
@@ -57,6 +132,10 @@ def event_handler_languages(languages, files, video, pt_scores, csv_pt_scores):
         value=STEP_2[lang_id], visible=True if pt_scores.shape[1] >= 7 else False
     )
 
+    practical_tasks_column = gr.Column(
+        visible=True if pt_scores.shape[1] >= 7 else False
+    )
+
     if pt_scores.shape[1] >= 7:
         pt_scores = dataframe(
             headers=(config_data.Dataframes_PT_SCORES[lang_id]),
@@ -66,6 +145,22 @@ def event_handler_languages(languages, files, video, pt_scores, csv_pt_scores):
     else:
         pt_scores = dataframe(visible=False)
 
+    current_lang_tasks = list(map(str, supported_practical_tasks[lang_id].keys()))
+    inverse_lang_tasks = list(
+        map(str, supported_practical_tasks[lang_id_inverse].keys())
+    )
+
+    if practical_tasks in inverse_lang_tasks:
+        practical_task = current_lang_tasks[inverse_lang_tasks.index(practical_tasks)]
+    else:
+        practical_task = next(iter(supported_practical_tasks[lang_id]))
+
+    # print(current_lang_tasks, "\n")
+    # print(inverse_lang_tasks, "\n")
+    # print(practical_tasks, "\n")
+    # print(supported_practical_tasks, "\n")
+    # print(practical_subtasks, "\n")
+
     return (
         gr.Markdown(value=DESCRIPTIONS[lang_id]),
         gr.HTML(value=STEP_1[lang_id]),
@@ -85,23 +180,11 @@ def event_handler_languages(languages, files, video, pt_scores, csv_pt_scores):
         gr.Tab(config_data.Labels_ABOUT_APP_LABEL[lang_id]),
         gr.Tab(config_data.Labels_ABOUT_AUTHORS_LABEL[lang_id]),
         gr.Tab(config_data.Labels_REQUIREMENTS_LABEL[lang_id]),
-        files_create_ui(
-            value=files,
-            label="{} ({})".format(
-                config_data.OtherMessages_VIDEO_FILES[lang_id],
-                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
-            ),
-            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
-        ),
+        files_ui,
+        webcam,
+        switching_modes,
         video,
-        button(
-            config_data.OtherMessages_EXAMPLES_APP[lang_id],
-            True,
-            1,
-            "./images/examples.ico",
-            True,
-            "examples_oceanai",
-        ),
+        examples,
         button(
             config_data.OtherMessages_CALCULATE_PT_SCORES[lang_id],
             True if files else False,
@@ -122,4 +205,21 @@ def event_handler_languages(languages, files, video, pt_scores, csv_pt_scores):
         pt_scores,
         csv_pt_scores,
         step_2,
+        practical_tasks_column,
+        radio_create_ui(
+            practical_task,
+            config_data.Labels_PRACTICAL_TASKS_LABEL[lang_id],
+            current_lang_tasks,
+            config_data.InformationMessages_PRACTICAL_TASKS_INFO[lang_id],
+            True,
+            True,
+        ),
+        radio_create_ui(
+            supported_practical_tasks[lang_id][practical_task][0],
+            config_data.Labels_PRACTICAL_SUBTASKS_LABEL[lang_id],
+            supported_practical_tasks[lang_id][practical_task],
+            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO[lang_id],
+            True,
+            True,
+        ),
     )

app/event_handlers/practical_subtasks.py

@@ -9,25 +9,36 @@ import gradio as gr
 
 # Importing necessary components for the Gradio app
 from app.config import config_data
-from app.utils import read_csv_file, extract_profession_weights
+from app.utils import read_csv_file, get_language_settings
+from app.data_init import weights_professions, interactive_professions
 from app.components import number_create_ui, dropdown_create_ui
 
 
 def event_handler_practical_subtasks(
-    practical_tasks, practical_subtasks, practical_subtasks_selected
+    language,
+    type_modes,
+    practical_tasks,
+    practical_subtasks,
+    practical_subtasks_selected,
 ):
+    lang_id, _ = get_language_settings(language)
+
     practical_subtasks_selected[practical_tasks] = practical_subtasks
 
+    visible_subtasks = (
+        True if type_modes == config_data.Settings_TYPE_MODES[0] else False
+    )
+
     if practical_subtasks.lower() == "16 personality types of mbti":
         return (
             practical_subtasks_selected,
-            gr.Column(visible=True),
+            gr.Column(visible=visible_subtasks),
             dropdown_create_ui(
                 label=f"Potential candidates by Personality Type of MBTI ({len(config_data.Settings_DROPDOWN_MBTI)})",
                 info=config_data.InformationMessages_DROPDOWN_MBTI_INFO,
                 choices=config_data.Settings_DROPDOWN_MBTI,
                 value=config_data.Settings_DROPDOWN_MBTI[0],
-                visible=True,
+                visible=visible_subtasks,
                 elem_classes="dropdown-container",
             ),
             number_create_ui(
@@ -39,7 +50,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
                 show_label=True,
                 interactive=True,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -62,17 +73,9 @@ def event_handler_practical_subtasks(
             number_create_ui(visible=False),
         )
     elif practical_subtasks.lower() == "professional groups":
-        df_traits_priority_for_professions = read_csv_file(
-            config_data.Links_PROFESSIONS
-        )
-        weights_professions, interactive_professions = extract_profession_weights(
-            df_traits_priority_for_professions,
-            config_data.Settings_DROPDOWN_CANDIDATES[0],
-        )
-
         return (
             practical_subtasks_selected,
-            gr.Column(visible=True),
+            gr.Column(visible=visible_subtasks),
             dropdown_create_ui(visible=False),
             number_create_ui(visible=False),
             number_create_ui(visible=False),
@@ -91,7 +94,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_DROPDOWN_CANDIDATES_INFO,
                 choices=config_data.Settings_DROPDOWN_CANDIDATES,
                 value=config_data.Settings_DROPDOWN_CANDIDATES[0],
-                visible=True,
+                visible=visible_subtasks,
                 elem_classes="dropdown-container",
             ),
             number_create_ui(
@@ -105,7 +108,7 @@ def event_handler_practical_subtasks(
                 ),
                 show_label=True,
                 interactive=interactive_professions,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -120,7 +123,7 @@ def event_handler_practical_subtasks(
                 ),
                 show_label=True,
                 interactive=interactive_professions,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -135,7 +138,7 @@ def event_handler_practical_subtasks(
                 ),
                 show_label=True,
                 interactive=interactive_professions,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -150,7 +153,7 @@ def event_handler_practical_subtasks(
                 ),
                 show_label=True,
                 interactive=interactive_professions,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -165,7 +168,7 @@ def event_handler_practical_subtasks(
                 ),
                 show_label=True,
                 interactive=interactive_professions,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -173,7 +176,7 @@ def event_handler_practical_subtasks(
     elif practical_subtasks.lower() == "professional skills":
         return (
             practical_subtasks_selected,
-            gr.Column(visible=True),
+            gr.Column(visible=visible_subtasks),
             dropdown_create_ui(visible=False),
             number_create_ui(visible=False),
             number_create_ui(
@@ -185,7 +188,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
                 show_label=True,
                 interactive=True,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -194,7 +197,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_DROPDOWN_PROFESSIONAL_SKILLS_INFO,
                 choices=config_data.Settings_DROPDOWN_PROFESSIONAL_SKILLS,
                 value=config_data.Settings_DROPDOWN_PROFESSIONAL_SKILLS[0],
-                visible=True,
+                visible=visible_subtasks,
                 elem_classes="dropdown-container",
             ),
             number_create_ui(visible=False),
@@ -219,7 +222,7 @@ def event_handler_practical_subtasks(
     ):
         return (
             practical_subtasks_selected,
-            gr.Column(visible=True),
+            gr.Column(visible=visible_subtasks),
             dropdown_create_ui(visible=False),
             number_create_ui(visible=False),
             number_create_ui(visible=False),
@@ -233,7 +236,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
                 show_label=True,
                 interactive=True,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -246,7 +249,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
                 show_label=True,
                 interactive=True,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -259,7 +262,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
                 show_label=True,
                 interactive=True,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -272,7 +275,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
                 show_label=True,
                 interactive=True,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -285,7 +288,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
                 show_label=True,
                 interactive=True,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -298,7 +301,7 @@ def event_handler_practical_subtasks(
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(0, 1.0),
                 show_label=True,
                 interactive=True,
-                visible=True,
+                visible=visible_subtasks,
                 render=True,
                 elem_classes="number-container",
             ),
@@ -349,11 +352,20 @@ def event_handler_practical_subtasks(
             number_create_ui(
                 value=1,
                 minimum=1,
-                maximum=df_correlation_coefficients.columns.size,
+                maximum=(
+                    df_correlation_coefficients.columns.size
+                    if practical_subtasks.lower() == "car characteristics"
+                    else df_correlation_coefficients.columns.size - 1
+                ),
                 step=1,
                 label=config_data.Labels_NUMBER_PRIORITY_LABEL,
                 info=config_data.InformationMessages_VALUE_FROM_TO_INFO.format(
-                    1, df_correlation_coefficients.columns.size
+                    1,
+                    (
+                        df_correlation_coefficients.columns.size
+                        if practical_subtasks.lower() == "car characteristics"
+                        else df_correlation_coefficients.columns.size - 1
+                    ),
                 ),
                 show_label=True,
                 interactive=True,

app/event_handlers/practical_task_sorted.py

@@ -15,16 +15,21 @@ from app.components import video_create_ui, textbox_create_ui
 
 
 def event_handler_practical_task_sorted(
-    files, practical_task_sorted, evt_data: gr.SelectData
+    type_modes, files, video, practical_task_sorted, evt_data: gr.SelectData
 ):
-    person_id = (
-        int(
-            practical_task_sorted.iloc[evt_data.index[0]][
-                config_data.Dataframes_PT_SCORES[0][0]
-            ]
+    if type_modes == config_data.Settings_TYPE_MODES[0]:
+        person_id = (
+            int(
+                practical_task_sorted.iloc[evt_data.index[0]][
+                    config_data.Dataframes_PT_SCORES[0][0]
+                ]
+            )
+            - 1
         )
-        - 1
-    )
+    elif type_modes == config_data.Settings_TYPE_MODES[1]:
+        files = [video]
+
+        person_id = 0
 
     if evt_data.index[0] == 0:
         label = "Best"

app/event_handlers/practical_tasks.py

@@ -9,14 +9,32 @@ License: MIT License
 from app.config import config_data
 from app.practical_tasks import supported_practical_tasks
 from app.components import radio_create_ui
+from app.utils import get_language_settings
 
 
-def event_handler_practical_tasks(practical_tasks, practical_subtasks_selected):
+def event_handler_practical_tasks(
+    language, type_modes, practical_tasks, practical_subtasks_selected
+):
+    lang_id, _ = get_language_settings(language)
+
+    if type_modes == config_data.Settings_TYPE_MODES[0]:
+        supported_practical_tasks_ren = supported_practical_tasks
+    elif type_modes == config_data.Settings_TYPE_MODES[1]:
+        rename_map = {
+            "Ranking potential candidates by professional responsibilities": "Estimating professional abilities",
+            "Ранжирование потенциальных кандидатов по профессиональным обязанностям": "Определить профессиональные возможности",
+        }
+
+        supported_practical_tasks_ren = [
+            {rename_map.get(k, k): v for k, v in d.items()}
+            for d in supported_practical_tasks
+        ]
+
     return radio_create_ui(
         practical_subtasks_selected[practical_tasks],
-        config_data.Labels_PRACTICAL_SUBTASKS_LABEL,
-        supported_practical_tasks[practical_tasks],
-        config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO,
+        config_data.Labels_PRACTICAL_SUBTASKS_LABEL[lang_id],
+        supported_practical_tasks_ren[lang_id][practical_tasks],
+        config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO[lang_id],
         True,
         True,
     )

app/event_handlers/switching_modes.py

@@ -0,0 +1,226 @@
+"""
+File: switching_modes.py
+Author: Elena Ryumina and Dmitry Ryumin
+Description: Event handler for switching modes.
+License: MIT License
+"""
+
+import gradio as gr
+
+# Importing necessary components for the Gradio app
+from app.config import config_data
+from app.description_steps import STEP_2
+from app.practical_tasks import supported_practical_tasks
+from app.components import (
+    html_message,
+    files_create_ui,
+    video_create_ui,
+    button,
+    dataframe,
+    radio_create_ui,
+    number_create_ui,
+    dropdown_create_ui,
+    textbox_create_ui,
+)
+from app.utils import get_language_settings
+
+
+def event_handler_switching_modes(language, type_modes):
+    lang_id, _ = get_language_settings(language)
+
+    first_practical_task = next(iter(supported_practical_tasks[lang_id]))
+
+    if type_modes == config_data.Settings_TYPE_MODES[0]:
+        notifications = html_message(
+            (
+                config_data.InformationMessages_NOTI_VIDEOS[lang_id].split("(")[0]
+                if lang_id == 0
+                else config_data.InformationMessages_NOTI_VIDEOS[lang_id]
+            ),
+            False,
+            True,
+            "notifications",
+        )
+        files_ui = files_create_ui(
+            label="{} ({})".format(
+                config_data.OtherMessages_VIDEO_FILES[lang_id],
+                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+            ),
+            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
+            interactive=False,
+            visible=False,
+        )
+        webcam = gr.Video(interactive=True, visible=True)
+        switching_modes = button(
+            config_data.OtherMessages_SWITCHEHG_MODES_OFFLINE[lang_id],
+            True,
+            1,
+            "./images/videos.ico",
+            True,
+            "switching_modes",
+        )
+        type_modes_ui = gr.Radio(
+            choices=config_data.Settings_TYPE_MODES,
+            value=config_data.Settings_TYPE_MODES[1],
+        )
+        examples = button(
+            config_data.OtherMessages_EXAMPLE_APP[lang_id],
+            True,
+            1,
+            "./images/examples.ico",
+            True,
+            "examples_oceanai",
+        )
+    elif type_modes == config_data.Settings_TYPE_MODES[1]:
+        notifications = html_message(
+            config_data.InformationMessages_NOTI_VIDEOS[lang_id],
+            False,
+            True,
+            "notifications",
+        )
+        files_ui = files_create_ui(
+            label="{} ({})".format(
+                config_data.OtherMessages_VIDEO_FILES[lang_id],
+                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+            ),
+            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
+        )
+        webcam = gr.Video(interactive=False, visible=False)
+        switching_modes = button(
+            config_data.OtherMessages_SWITCHEHG_MODES_ONLINE[lang_id],
+            True,
+            1,
+            "./images/webcam.ico",
+            True,
+            "switching_modes",
+        )
+        type_modes_ui = gr.Radio(
+            choices=config_data.Settings_TYPE_MODES,
+            value=config_data.Settings_TYPE_MODES[0],
+        )
+        examples = button(
+            config_data.OtherMessages_EXAMPLES_APP[lang_id],
+            True,
+            1,
+            "./images/examples.ico",
+            True,
+            "examples_oceanai",
+        )
+
+    return (
+        notifications,
+        files_ui,
+        webcam,
+        switching_modes,
+        type_modes_ui,
+        video_create_ui(),
+        examples,
+        button(
+            config_data.OtherMessages_CALCULATE_PT_SCORES[lang_id],
+            False,
+            3,
+            "./images/calculate_pt_scores.ico",
+            True,
+            "calculate_oceanai",
+        ),
+        button(
+            config_data.OtherMessages_CLEAR_APP[lang_id],
+            False,
+            1,
+            "./images/clear.ico",
+            True,
+            "clear_oceanai",
+        ),
+        dataframe(visible=False),
+        files_create_ui(
+            None,
+            "single",
+            [".csv"],
+            config_data.OtherMessages_EXPORT_PT_SCORES[lang_id],
+            True,
+            False,
+            False,
+            "csv-container",
+        ),
+        gr.HTML(value=STEP_2[lang_id], visible=False),
+        gr.Column(visible=False),
+        radio_create_ui(
+            first_practical_task,
+            config_data.Labels_PRACTICAL_TASKS_LABEL[lang_id],
+            list(map(str, supported_practical_tasks[lang_id].keys())),
+            config_data.InformationMessages_PRACTICAL_TASKS_INFO[lang_id],
+            True,
+            True,
+        ),
+        radio_create_ui(
+            supported_practical_tasks[lang_id][first_practical_task][0],
+            config_data.Labels_PRACTICAL_SUBTASKS_LABEL[lang_id],
+            supported_practical_tasks[lang_id][first_practical_task],
+            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO[lang_id],
+            True,
+            True,
+        ),
+        gr.JSON(
+            value={
+                str(task): supported_practical_tasks[index].get(task, [None])[0]
+                for index in range(len(supported_practical_tasks))
+                for task in supported_practical_tasks[index].keys()
+            },
+            visible=False,
+            render=True,
+        ),
+        gr.Column(visible=False),
+        dropdown_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        dropdown_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        dropdown_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        number_create_ui(visible=False),
+        gr.Row(visible=False),
+        gr.Column(visible=False),
+        dataframe(visible=False),
+        files_create_ui(
+            None,
+            "single",
+            [".csv"],
+            config_data.OtherMessages_EXPORT_PS,
+            True,
+            False,
+            False,
+            "csv-container",
+        ),
+        gr.Accordion(visible=False),
+        gr.HTML(visible=False),
+        dataframe(visible=False),
+        gr.Column(visible=False),
+        video_create_ui(visible=False),
+        gr.Column(visible=False),
+        gr.Row(visible=False),
+        gr.Row(visible=False),
+        gr.Image(visible=False),
+        textbox_create_ui(visible=False),
+        gr.Row(visible=False),
+        gr.Image(visible=False),
+        textbox_create_ui(visible=False),
+        gr.Row(visible=False),
+        gr.Row(visible=False),
+        gr.Image(visible=False),
+        textbox_create_ui(visible=False),
+        gr.Row(visible=False),
+        gr.Image(visible=False),
+        textbox_create_ui(visible=False),
+        html_message(config_data.InformationMessages_NOTI_IN_DEV, False, False),
+    )

app/event_handlers/webcam.py

@@ -0,0 +1,84 @@
+"""
+File: webcam.py
+Author: Elena Ryumina and Dmitry Ryumin
+Description: Event handler for webcam.
+License: MIT License
+"""
+
+import gradio as gr
+from pathlib import Path
+
+# Importing necessary components for the Gradio app
+from app.config import config_data
+from app.components import html_message, video_create_ui, button
+from app.utils import get_language_settings, webm2mp4
+
+
+def event_handler_webcam(language, webcam, pt_scores):
+    lang_id, _ = get_language_settings(language)
+
+    if not webcam:
+        return (
+            html_message(
+                (
+                    config_data.InformationMessages_NOTI_VIDEOS[lang_id].split("(")[0]
+                    if lang_id == 0
+                    else config_data.InformationMessages_NOTI_VIDEOS[lang_id]
+                ),
+                False,
+                True,
+                "notifications",
+            ),
+            video_create_ui(label=config_data.OtherMessages_VIDEO_PLAYER[lang_id]),
+            gr.Video(value=None),
+            button(
+                config_data.OtherMessages_CALCULATE_PT_SCORES[lang_id],
+                False,
+                3,
+                "./images/calculate_pt_scores.ico",
+                True,
+                "calculate_oceanai",
+            ),
+            button(
+                config_data.OtherMessages_CLEAR_APP[lang_id],
+                False,
+                1,
+                "./images/clear.ico",
+                True,
+                "clear_oceanai",
+            ),
+        )
+
+    if webcam.split(".")[-1] == "webm":
+        webcam = webm2mp4(webcam)
+
+    return (
+        html_message(
+            config_data.OtherMessages_NOTI_CALCULATE[lang_id],
+            True,
+            False if pt_scores.shape[1] >= 7 else True,
+            "notifications",
+        ),
+        video_create_ui(
+            value=webcam,
+            label=config_data.OtherMessages_VIDEO_PLAYER[lang_id],
+            file_name=Path(Path(webcam).name).name,
+        ),
+        gr.Video(value=None),
+        button(
+            config_data.OtherMessages_CALCULATE_PT_SCORES[lang_id],
+            True,
+            3,
+            "./images/calculate_pt_scores.ico",
+            True,
+            "calculate_oceanai",
+        ),
+        button(
+            config_data.OtherMessages_CLEAR_APP[lang_id],
+            True,
+            1,
+            "./images/clear.ico",
+            True,
+            "clear_oceanai",
+        ),
+    )

app/port.py

@@ -0,0 +1,35 @@
+"""
+File: port.py
+Author: Elena Ryumina and Dmitry Ryumin
+Description: Utility functions to check and free ports by terminating processes holding them.
+License: MIT License
+"""
+
+import socket
+import psutil
+from typing import Iterable, Union
+
+
+def is_port_in_use(host: str, port: int) -> bool:
+    try:
+        with socket.create_connection((host, port), timeout=1):
+            return True
+    except (ConnectionRefusedError, OSError):
+        return False
+
+
+def free_ports(ports: Union[int, Iterable[int]]) -> None:
+    ports_to_free = {ports} if isinstance(ports, int) else set(ports)
+
+    for proc in psutil.process_iter(attrs=["pid", "name"]):
+        try:
+            connections = proc.net_connections(kind="inet")
+            for conn in connections:
+                if conn.laddr.port in ports_to_free:
+                    proc.terminate()
+                    proc.wait()
+                    ports_to_free.discard(conn.laddr.port)
+                    if not ports_to_free:
+                        return
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+            continue

app/practical_tasks.py

@@ -11,17 +11,27 @@ from typing import Dict, List
 # Importing necessary components for the Gradio app
 
 
-def load_practical_tasks_data(file_path: str) -> List:
-    with open(file_path, "r") as file:
-        return yaml.safe_load(file) or []
+def load_practical_tasks_data(file_paths: List[str]) -> List[Dict]:
+    all_tasks_data = []
 
+    for file_path in file_paths:
+        with open(file_path, "r") as file:
+            data = yaml.safe_load(file) or []
+            all_tasks_data.append(data)
 
-def transform_practical_tasks_data(data: List) -> Dict:
-    output_dict = {item["task"]: item["subtasks"] for item in data}
+    return all_tasks_data
 
-    return output_dict
 
+def transform_practical_tasks_data(data: List[Dict]) -> List[Dict]:
+    output_list = []
 
-yaml_file_path = "./practical_tasks.yaml"
-practical_tasks_data = load_practical_tasks_data(yaml_file_path)
+    for task_data in data:
+        output_dict = {item["task"]: item["subtasks"] for item in task_data}
+        output_list.append(output_dict)
+
+    return output_list
+
+
+yaml_file_paths = ["./practical_tasks_en.yaml", "./practical_tasks_ru.yaml"]
+practical_tasks_data = load_practical_tasks_data(yaml_file_paths)
 supported_practical_tasks = transform_practical_tasks_data(practical_tasks_data)

app/tabs.py

@@ -13,10 +13,11 @@ from app.description_steps import STEP_1, STEP_2
 from app.mbti_description import MBTI_DESCRIPTION, MBTI_DATA
 from app.app import APP
 from app.authors import AUTHORS
+from app.data_init import weights_professions, interactive_professions
 from app.requirements_app import read_requirements_to_df
 from app.config import config_data
 from app.practical_tasks import supported_practical_tasks
-from app.utils import read_csv_file, extract_profession_weights
+from app.utils import read_csv_file
 from app.components import (
     html_message,
     files_create_ui,
@@ -37,16 +38,59 @@ def app_tab():
 
     step_1 = gr.HTML(value=STEP_1[config_data.AppSettings_DEFAULT_LANG_ID])
 
-    with gr.Row():
-        files = files_create_ui(
-            label="{} ({})".format(
-                config_data.OtherMessages_VIDEO_FILES[
+    with gr.Row(elem_classes="media-container"):
+        with gr.Column():
+            files = files_create_ui(
+                label="{} ({})".format(
+                    config_data.OtherMessages_VIDEO_FILES[
+                        config_data.AppSettings_DEFAULT_LANG_ID
+                    ],
+                    ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+                ),
+                file_types=[
+                    f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT
+                ],
+            )
+
+            webcam = gr.Video(
+                label="{} ({})".format(
+                    config_data.OtherMessages_VIDEO_FILES[
+                        config_data.AppSettings_DEFAULT_LANG_ID
+                    ],
+                    ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
+                ),
+                show_label=True,
+                interactive=False,
+                visible=False,
+                mirror_webcam=False,
+                include_audio=True,
+                elem_classes="webcam",
+                autoplay=False,
+            )
+
+            switching_modes = button(
+                config_data.OtherMessages_SWITCHEHG_MODES_ONLINE[
                     config_data.AppSettings_DEFAULT_LANG_ID
                 ],
-                ", ".join(config_data.Settings_SUPPORTED_VIDEO_EXT),
-            ),
-            file_types=[f".{ext}" for ext in config_data.Settings_SUPPORTED_VIDEO_EXT],
-        )
+                True,
+                1,
+                "./images/webcam.ico",
+                True,
+                "switching_modes",
+            )
+
+            type_modes = gr.Radio(
+                choices=config_data.Settings_TYPE_MODES,
+                value=config_data.Settings_TYPE_MODES[0],
+                label=None,
+                info=None,
+                show_label=False,
+                container=False,
+                interactive=False,
+                visible=False,
+                render=True,
+                elem_classes="type_modes",
+            )
 
         video = video_create_ui()
 
@@ -87,6 +131,7 @@ def app_tab():
             config_data.AppSettings_DEFAULT_LANG_ID
         ],
         False,
+        "notifications",
     )
 
     pt_scores = dataframe(visible=False)
@@ -108,23 +153,42 @@ def app_tab():
         value=STEP_2[config_data.AppSettings_DEFAULT_LANG_ID], visible=False
     )
 
-    first_practical_task = next(iter(supported_practical_tasks))
+    first_practical_task = next(
+        iter(supported_practical_tasks[config_data.AppSettings_DEFAULT_LANG_ID])
+    )
 
     with gr.Column(scale=1, visible=False, render=True) as practical_tasks_column:
         practical_tasks = radio_create_ui(
             first_practical_task,
             config_data.Labels_PRACTICAL_TASKS_LABEL,
-            list(map(str, supported_practical_tasks.keys())),
-            config_data.InformationMessages_PRACTICAL_TASKS_INFO,
+            list(
+                map(
+                    str,
+                    supported_practical_tasks[
+                        config_data.AppSettings_DEFAULT_LANG_ID
+                    ].keys(),
+                )
+            ),
+            config_data.InformationMessages_PRACTICAL_TASKS_INFO[
+                config_data.AppSettings_DEFAULT_LANG_ID
+            ],
             True,
             True,
         )
 
         practical_subtasks = radio_create_ui(
-            supported_practical_tasks[first_practical_task][0],
-            config_data.Labels_PRACTICAL_SUBTASKS_LABEL,
-            supported_practical_tasks[first_practical_task],
-            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO,
+            supported_practical_tasks[config_data.AppSettings_DEFAULT_LANG_ID][
+                first_practical_task
+            ][0],
+            config_data.Labels_PRACTICAL_SUBTASKS_LABEL[
+                config_data.AppSettings_DEFAULT_LANG_ID
+            ],
+            supported_practical_tasks[config_data.AppSettings_DEFAULT_LANG_ID][
+                first_practical_task
+            ],
+            config_data.InformationMessages_PRACTICAL_SUBTASKS_INFO[
+                config_data.AppSettings_DEFAULT_LANG_ID
+            ],
             True,
             True,
         )
@@ -159,7 +223,7 @@ def app_tab():
             )
 
             threshold_professional_skills = number_create_ui(
-                value=0.45,
+                value=0.5,
                 minimum=0.0,
                 maximum=1.0,
                 step=0.01,
@@ -323,14 +387,6 @@ def app_tab():
                 elem_classes="dropdown-container",
             )
 
-            df_traits_priority_for_professions = read_csv_file(
-                config_data.Links_PROFESSIONS
-            )
-            weights_professions, interactive_professions = extract_profession_weights(
-                df_traits_priority_for_professions,
-                config_data.Settings_DROPDOWN_CANDIDATES[0],
-            )
-
             number_openness = number_create_ui(
                 value=weights_professions[0],
                 minimum=config_data.Values_0_100[0],
@@ -481,6 +537,7 @@ def app_tab():
                                 visible=False,
                                 show_download_button=False,
                                 elem_classes="metadata_name-logo",
+                                show_fullscreen_button=False,
                             )
 
                             name = textbox_create_ui(
@@ -512,6 +569,7 @@ def app_tab():
                                 visible=False,
                                 show_download_button=False,
                                 elem_classes="metadata_surname-logo",
+                                show_fullscreen_button=False,
                             )
 
                             surname = textbox_create_ui(
@@ -545,6 +603,7 @@ def app_tab():
                                 visible=False,
                                 show_download_button=False,
                                 elem_classes="metadata_email-logo",
+                                show_fullscreen_button=False,
                             )
 
                             email = textbox_create_ui(
@@ -576,6 +635,7 @@ def app_tab():
                                 visible=False,
                                 show_download_button=False,
                                 elem_classes="metadata_phone-logo",
+                                show_fullscreen_button=False,
                             )
 
                             phone = textbox_create_ui(
@@ -595,8 +655,9 @@ def app_tab():
 
     practical_subtasks_selected = gr.JSON(
         value={
-            str(task): supported_practical_tasks.get(task, [None])[0]
-            for task in supported_practical_tasks.keys()
+            str(task): supported_practical_tasks[index].get(task, [None])[0]
+            for index in range(len(supported_practical_tasks))
+            for task in supported_practical_tasks[index].keys()
         },
         visible=False,
         render=True,
@@ -611,6 +672,9 @@ def app_tab():
         step_1,
         notifications,
         files,
+        webcam,
+        switching_modes,
+        type_modes,
         video,
         examples,
         calculate_pt_scores,

app/utils.py

@@ -6,6 +6,8 @@ License: MIT License
 """
 
 import pandas as pd
+import subprocess
+from pathlib import Path
 
 # Importing necessary components for the Gradio app
 from app.config import config_data
@@ -84,3 +86,27 @@ def extract_profession_weights(df, dropdown_candidates):
         weights_professions = list(map(int, weights_professions))
 
     return weights_professions, interactive_professions
+
+
+def webm2mp4(input_file):
+    input_path = Path(input_file)
+    output_path = input_path.with_suffix(".mp4")
+
+    if not output_path.exists():
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-i",
+                str(input_path),
+                "-c:v",
+                "copy",
+                "-c:a",
+                "aac",
+                "-strict",
+                "experimental",
+                str(output_path),
+            ],
+            check=True,
+        )
+
+    return str(output_path)

config.toml

@@ -1,5 +1,7 @@
 [AppSettings]
-APP_VERSION = "0.9.2"
+APP_VERSION = "0.10.7"
+SERVER_NAME = "127.0.0.1"
+PORT = 7860
 CSS_PATH = "app.css"
 DEFAULT_LANG_ID = 0
 
@@ -9,8 +11,8 @@ DESCRIPTIONS = [
     "- библиотека с открытым исходным кодом для оценивания большой пятерки качеств личности человека и автоматизации HR-процессов",
 ]
 NOTI_VIDEOS = ["Select the video(s)", "Выберите видео"]
-PRACTICAL_TASKS_INFO = "Choose a practical task"
-PRACTICAL_SUBTASKS_INFO = "Choose a practical subtask"
+PRACTICAL_TASKS_INFO = ["Choose a practical task", "Выберите практическую задачу"]
+PRACTICAL_SUBTASKS_INFO = ["Choose a practical subtask", "Выберите практическую подзадачу"]
 NOTI_IN_DEV = "In development"
 DROPDOWN_MBTI_INFO = "What personality type indicator are you interested in?"
 DROPDOWN_PROFESSIONAL_SKILLS_INFO = "What professional skill are you interested in?"
@@ -31,11 +33,18 @@ STEP_2 = [
 [OtherMessages]
 VIDEO_FILES = ["Video Files", "Видеофайлы"]
 VIDEO_PLAYER = ["Video Player", "Видео проигрыватель"]
-CALCULATE_PT_SCORES = ["Calculation of Big Five personality traits scores", "Вычисление показателей Большой пятерки персональных качеств личности человека"]
-CALCULATE_PT_SCORES_ERR = "Personality traits scores have not been calculated. Try uploading a different file(s)"
+CALCULATE_PT_SCORES = [
+    "Calculation of Big Five personality traits scores",
+    "Вычисление показателей Большой пятерки персональных качеств личности человека"
+]
+CALCULATE_PT_SCORES_ERR = [
+    "Personality traits scores have not been calculated. Ensure that there are uncovered face and speech of person in the video",
+    "Оценки персональных качеств личностей человека не были вычислены. Убедитесь, что в видео присутствует не перекрытое лицо и речь человека"
+]
 CALCULATE_PRACTICAL_TASK = "Solving practical task"
 CLEAR_APP = ["Clear", "Сброс"]
 EXAMPLES_APP = ["Examples", "Примеры"]
+EXAMPLE_APP = ["Example", "Пример"]
 EXPORT_PT_SCORES = [
     "Export Big Five personality traits to a CSV file",
     "Экспорт показателей Большой пятерки персональных качеств личности человека в CSV файл"]
@@ -45,14 +54,16 @@ EXPORT_WT = "Export ranking effective work teams results to a CSV file"
 EXPORT_CP = "Export consumer preferences for industrial goods results to a CSV file"
 EXPORT_MBTI = "Export ranking personality type results to a CSV file"
 NOTI_CALCULATE = ["You can calculate Big Five personality traits scores", "Вы можете рассчитать показатели Большой пятерки персональных качеств личности человека"]
+SWITCHEHG_MODES_ONLINE = ["Webcam", "Веб-камера"]
+SWITCHEHG_MODES_OFFLINE = ["Video Files", "Видеофайлы"]
 
 [Labels]
 APP_LABEL = ["⭐ App", "⭐ Приложение"]
 ABOUT_APP_LABEL = ["💡 About the App", "💡 О приложении"]
 ABOUT_AUTHORS_LABEL = ["🎭 About the Authors", "🎭 Об авторах"]
 REQUIREMENTS_LABEL = ["📋 Requirements", "📋 Зависимости"]
-PRACTICAL_TASKS_LABEL = "Practical tasks"
-PRACTICAL_SUBTASKS_LABEL = "Practical subtasks"
+PRACTICAL_TASKS_LABEL = ["Practical tasks", "Практические задачи"]
+PRACTICAL_SUBTASKS_LABEL = ["Practical subtasks", "Практические подзадачи"]
 THRESHOLD_MBTI_LABEL = "Polarity traits threshold"
 THRESHOLD_PROFESSIONAL_SKILLS_LABEL = "Polarity traits threshold"
 TARGET_SCORE_OPE_LABEL = "Openness target score"
@@ -138,8 +149,10 @@ DROPDOWN_MBTI = [
     "The Commander (ENTJ): Construction Supervisor, Health Services Administrator, Financial Accountant, Auditor, Lawyer, School Principal, Chemical Engineer, Database Manager, etc.",
 ]
 DROPDOWN_MBTI_DEL_COLS = ["EI", "SN", "TF", "JP", "Match"]
+DROPDOWN_MBTI_DEL_COLS_WEBCAM = ["Path"]
 SHOW_VIDEO_METADATA = true
 SUPPORTED_VIDEO_EXT = ["mp4", "mov", "avi", "flv"]
+TYPE_MODES = ["Files", "Web"]
 
 [Values]
 TARGET_SCORES = [0.527886, 0.522337, 0.458468, 0.51761, 0.444649]

practical_tasks_ru.yaml

@@ -0,0 +1,14 @@
+- task: "Ранжирование потенциальных кандидатов по профессиональным обязанностям"
+  subtasks:
+    - "16 персональных типов личности MBTI"
+    - "Профессиональные группы"
+    - "Профессиональные навыки"
+- task: "Формирование эффективных рабочих коллективов"
+  subtasks:
+    - "Поиск подходящего младшего коллеги"
+    - "Поиск подходящего старшего коллеги"
+- task: "Прогнозирование потребительских предпочтений в отношении промышленных товаров"
+  subtasks:
+    - "Характеристики автомобиля"
+    - "Категории приложений для мобильных устройств"
+    - "Стиль одежды"

requirements.txt

@@ -1,5 +1,7 @@
-gradio==5.5.0
-PyYAML==6.0.1
+gradio==5.8.0
+PyYAML==6.0.2
 toml==0.10.2
-oceanai==1.0.0a43
-tf-keras
+oceanai==1.0.0a46
+torch==2.2.2
+psutil==6.1.0
+beautifulsoup4==4.12.3