Different Bugs and small issues collector (#81)

* Adds check for crowd heuristic on run

* Submodule change

* Adds label rename logic

* Removes required falg for project id on recommendations for zero shot and embedders

* Submodule change

* PR comments

* Submodule change

Co-authored-by: JWittmeyer <[email protected]>

Author: JWittmeyer

controller/labeling_task_label/manager.py

@@ -3,9 +3,18 @@
     labeling_task_label,
     labeling_task,
     general,
+    knowledge_base,
+    information_source,
+    record_label_association,
 )
 from controller.knowledge_base.util import create_knowledge_base_if_not_existing
 from submodules.model.enums import LabelingTaskType
+from submodules.model import enums
+from util import notification
+
+
+from typing import List, Any, Dict
+import re
 
 
 def get_label(project_id: str, label_id: str) -> LabelingTaskLabel:
@@ -24,6 +33,33 @@ def update_label_hotkey(project_id: str, label_id: str, hotkey: str) -> None:
     general.commit()
 
 
+def update_label_name(project_id: str, label_id: str, new_name: str) -> None:
+    label = get_label(project_id, label_id)
+    label.name = new_name
+    general.commit()
+
+
+def handle_label_rename_warning(project_id: str, warning_data: Dict[str, str]) -> None:
+    if warning_data["key"] == enums.CommentCategory.KNOWLEDGE_BASE.value:
+        knowledge_base_item = knowledge_base.get_by_name(
+            project_id, warning_data["old"]
+        )
+        knowledge_base_item.name = warning_data["new"]
+        general.commit()
+
+        notification.send_organization_update(
+            project_id, f"knowledge_base_updated:{str(knowledge_base_item.id)}"
+        )
+    elif warning_data["key"] == enums.CommentCategory.HEURISTIC.value:
+        information_source_item = information_source.get(project_id, warning_data["id"])
+        information_source_item.source_code = warning_data["new"]
+        general.commit()
+
+        notification.send_organization_update(
+            project_id, f"information_source_updated:{str(information_source_item.id)}"
+        )
+
+
 def create_label(
     project_id: str, name: str, labeling_task_id: str, label_color: str
 ) -> LabelingTaskLabel:
@@ -39,3 +75,81 @@ def create_label(
 
 def delete_label(project_id: str, label_id: str) -> None:
     labeling_task_label.delete(project_id, label_id, with_commit=True)
+
+
+def check_rename_label(project_id: str, label_id: str, new_name: str) -> List[Any]:
+    label_item = labeling_task_label.get(project_id, label_id)
+    if not label_item or label_item.name == new_name:
+        return []
+    return __get_change_dict(project_id, label_item, new_name)
+
+
+def __get_change_dict(
+    project_id: str, label: LabelingTaskLabel, new_name: str
+) -> Dict[str, str]:
+    return_values = {
+        "errors": __check_errors_label_rename(project_id, label, new_name),
+        "warnings": __check_warnings_label_rename(project_id, label, new_name),
+        "infos": [],
+    }
+    __check_label_rename_knowledge_base(project_id, label, new_name, return_values)
+    if len(return_values["errors"]) == 0 and len(return_values["warnings"]) == 0:
+        return_values["infos"].append(__get_msg_dict("No issues detected"))
+    return return_values
+
+
+def __get_msg_dict(msg: str) -> Dict[str, str]:
+    return {"msg": msg}
+
+
+def __check_errors_label_rename(
+    project_id: str, label: LabelingTaskLabel, new_name: str
+) -> List[Dict[str, Any]]:
+    append_me = []
+    existing_with_name = labeling_task_label.get_by_name(
+        project_id, str(label.labeling_task_id), new_name
+    )
+    if existing_with_name:
+        append_me.append(__get_msg_dict("Label with name already exists"))
+    return append_me
+
+
+def __check_warnings_label_rename(
+    project_id: str, label: LabelingTaskLabel, new_name: str
+) -> List[Dict[str, Any]]:
+    append_me = []
+
+    information_sources = information_source.get_all(project_id)
+    for information_source_item in information_sources:
+        current_code = information_source_item.source_code
+        new_code = re.sub(r"\b%s\b" % label.name, new_name, current_code)
+        if current_code != new_code:
+            entry = __get_msg_dict(
+                "Information source with matching word was detected."
+            )
+            entry["key"] = enums.CommentCategory.HEURISTIC.value
+            entry["id"] = str(information_source_item.id)
+            entry["old"] = current_code
+            entry["new"] = new_code
+            entry["old_name"] = label.name
+            entry["new_name"] = new_name
+            append_me.append(entry)
+
+    return append_me
+
+
+def __check_label_rename_knowledge_base(
+    project_id: str, label: LabelingTaskLabel, new_name: str, append_to
+) -> None:
+    knowledge_base_item = knowledge_base.get_by_name(project_id, label.name)
+    if knowledge_base_item:
+        entry = __get_msg_dict("Lookup list with same name as label exists.")
+        entry["key"] = enums.CommentCategory.KNOWLEDGE_BASE.value
+        entry["old"] = knowledge_base_item.name
+        entry["new"] = new_name
+        knowledge_base_item_new = knowledge_base.get_by_name(project_id, new_name)
+        if knowledge_base_item_new:
+            entry["msg"] += "\n\tNew label name however, already exists as lookup list."
+            append_to["errors"].append(entry)
+        else:
+            append_to["warnings"].append(entry)

controller/payload/manager.py

@@ -19,6 +19,9 @@ def create_payload(
     user_id: str,
     asynchronous: Optional[bool] = True,
 ) -> InformationSourcePayload:
+    information_source_item = information_source.get(project_id, information_source_id)
+    if information_source_item.type == enums.InformationSourceType.CROWD_LABELER:
+        return None
     return payload_scheduler.create_payload(
         info, project_id, information_source_id, user_id, asynchronous
     )
@@ -75,7 +78,9 @@ def get_labeling_function_on_10_records(
     )
 
 
-def fill_missing_record_ids(sample_records: List[str], calculated_labels: Dict[str, List[Any]]) -> List[str]:
+def fill_missing_record_ids(
+    sample_records: List[str], calculated_labels: Dict[str, List[Any]]
+) -> List[str]:
     for record_item in sample_records:
         record_id = record_item[0]
         if record_id not in calculated_labels:

controller/zero_shot/manager.py

@@ -46,8 +46,10 @@ def get_zero_shot_recommendations(
     project_id: Optional[str] = None,
 ) -> List[Dict[str, str]]:
     recommendations = zs_service.get_recommended_models()
-    project_item = project.get(project_id)
+    if not project_id:
+        return recommendations
 
+    project_item = project.get(project_id)
     if project_item and project_item.tokenizer_blank:
         recommendations = [
             r for r in recommendations if r["language"] == project_item.tokenizer_blank

graphql_api/mutation/labeling_task_label.py

@@ -7,6 +7,7 @@
 from controller.auth import manager as auth
 from controller.project import manager as project_manager
 from util import doc_ock, notification
+from typing import Dict
 
 
 class CreateLabelingTaskLabel(graphene.Mutation):
@@ -83,6 +84,35 @@ def mutate(
         return UpdateLabelingTaskLabelColor(ok=True)
 
 
+class UpdateLabelingTaskLabelName(graphene.Mutation):
+    class Arguments:
+        project_id = graphene.ID(required=True)
+        labeling_task_label_id = graphene.ID(required=True)
+        new_name = graphene.String(required=True)
+
+    ok = graphene.Boolean()
+
+    def mutate(self, info, project_id: str, labeling_task_label_id: str, new_name: str):
+        auth.check_demo_access(info)
+        auth.check_project_access(info, project_id)
+        manager.update_label_name(project_id, labeling_task_label_id, new_name)
+        return UpdateLabelingTaskLabelColor(ok=True)
+
+
+class HandleLabelRenameWarnings(graphene.Mutation):
+    class Arguments:
+        project_id = graphene.ID(required=True)
+        warning_data = graphene.JSONString(required=True)
+
+    ok = graphene.Boolean()
+
+    def mutate(self, info, project_id: str, warning_data: Dict[str, str]):
+        auth.check_demo_access(info)
+        auth.check_project_access(info, project_id)
+        manager.handle_label_rename_warning(project_id, warning_data)
+        return UpdateLabelingTaskLabelColor(ok=True)
+
+
 class DeleteLabelingTaskLabel(graphene.Mutation):
     class Arguments:
         project_id = graphene.ID(required=True)
@@ -107,3 +137,5 @@ class LabelingTaskLabelMutation(graphene.ObjectType):
     delete_label = DeleteLabelingTaskLabel.Field()
     update_label_color = UpdateLabelingTaskLabelColor.Field()
     update_label_hotkey = UpdateLabelingTaskLabelHotkey.Field()
+    update_label_name = UpdateLabelingTaskLabelName.Field()
+    handle_label_rename_warnings = HandleLabelRenameWarnings.Field()

graphql_api/query/embedding.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Optional
 
 import graphene
 
@@ -13,7 +13,7 @@
 class EmbeddingQuery(graphene.ObjectType):
     recommended_encoders = graphene.Field(
         graphene.List(Encoder),
-        project_id=graphene.ID(required=True),
+        project_id=graphene.ID(required=False),
     )
 
     language_models = graphene.Field(graphene.List(LanguageModel))
@@ -22,9 +22,12 @@ class EmbeddingQuery(graphene.ObjectType):
         RecordTokenizationTask, project_id=graphene.ID(required=True)
     )
 
-    def resolve_recommended_encoders(self, info, project_id: str) -> List[Encoder]:
+    def resolve_recommended_encoders(
+        self, info, project_id: Optional[str] = None
+    ) -> List[Encoder]:
         auth.check_demo_access(info)
-        auth.check_project_access(info, project_id)
+        if project_id:
+            auth.check_project_access(info, project_id)
         return manager.get_recommended_encoders()
 
     def resolve_language_models(self, info) -> List[LanguageModel]:

graphql_api/query/labeling_task_label.py

@@ -0,0 +1,21 @@
+import graphene
+
+from controller.auth import manager as auth
+from graphql_api.types import LabelingTask
+from controller.labeling_task_label import manager
+
+
+class LabelingTaskLabelQuery(graphene.ObjectType):
+    check_rename_label = graphene.Field(
+        graphene.JSONString,
+        project_id=graphene.ID(required=True),
+        label_id=graphene.ID(required=True),
+        new_name=graphene.String(required=True),
+    )
+
+    def resolve_check_rename_label(
+        self, info, project_id: str, label_id: str, new_name: str
+    ) -> LabelingTask:
+        auth.check_demo_access(info)
+        auth.check_project_access(info, project_id)
+        return manager.check_rename_label(project_id, label_id, new_name)

graphql_api/query/zero_shot.py

@@ -22,7 +22,7 @@ class ZeroShotQuery(graphene.ObjectType):
 
     zero_shot_recommendations = graphene.Field(
         graphene.JSONString,
-        project_id=graphene.ID(),
+        project_id=graphene.ID(required=False),
     )
 
     zero_shot_10_records = graphene.Field(
@@ -58,7 +58,8 @@ def resolve_zero_shot_recommendations(
         self, info, project_id: Optional[str] = None
     ) -> List[Dict[str, str]]:
         auth_manager.check_demo_access(info)
-        auth_manager.check_project_access(info, project_id)
+        if project_id:
+            auth_manager.check_project_access(info, project_id)
         return manager.get_zero_shot_recommendations(project_id)
 
     def resolve_zero_shot_10_records(

graphql_api/schema.py

@@ -11,6 +11,7 @@
 from graphql_api.query.knowledge_base import KnowledgeBaseQuery
 from graphql_api.query.knowledge_term import KnowledgeTermQuery
 from graphql_api.query.labeling_task import LabelingTaskQuery
+from graphql_api.query.labeling_task_label import LabelingTaskLabelQuery
 from graphql_api.query.misc import MiscQuery
 from graphql_api.query.notification import NotificationQuery
 from graphql_api.query.organization import OrganizationQuery
@@ -58,6 +59,7 @@ class Query(
     KnowledgeBaseQuery,
     KnowledgeTermQuery,
     LabelingTaskQuery,
+    LabelingTaskLabelQuery,
     MiscQuery,
     ModelProviderQuery,
     OrganizationQuery,