feat: remove Slack notifications (#1646)

Slack notifications were not working since 31st of March, due to Slack
moving away from legacy bots.

It's a good opportunity to remove it entirely, as we now rely on
Nutripatrol for moderation, and as it generated (for other
notifications) many (unread) message.

Solves #1576.

Author: raphael0202

.env

@@ -19,7 +19,6 @@ TAG=latest
 # (`dev` by default).
 # If `prod` is used, openfoodfacts.org domain will be used by default,
 # and openfoodfacts.net if `dev` is used.
-# Messages to Slack are only enabled if `ROBOTOFF_INSTANCE=prod`.
 ROBOTOFF_INSTANCE=dev
 
 # Overwrites the Product Opener domain used. If empty, the domain will

.github/workflows/container-deploy.yml

@@ -150,7 +150,6 @@ jobs:
           echo "INFLUXDB_PORT=${{ env.INFLUXDB_PORT }}" >> .env
           echo "INFLUXDB_BUCKET=off_metrics" >> .env
           echo "INFLUXDB_AUTH_TOKEN=${{ secrets.INFLUXDB_AUTH_TOKEN }}" >> .env
-          echo "SLACK_TOKEN=${{ secrets.SLACK_TOKEN }}" >> .env
           echo "GUNICORN_NUM_WORKERS=4" >> .env
           echo "EVENTS_API_URL=https://event.openfoodfacts.${{ env.ROBOTOFF_TLD }}" >> .env
           echo "IMAGE_MODERATION_SERVICE_URL=${{ env.IMAGE_MODERATION_SERVICE_URL }}" >> .env

data/ocr/store_notify.txt

@@ -64,8 +64,6 @@ Remember to put quotes especially if you have multiple arguments.
 
 Write test cases every time you write a new feature, to test a feature or to understand the working of an existing function. Automated testing really helps to prevent future bugs as we introduce new features or refactor the code.
 
-There are even cases where automated tests are your only chance to test you code. For example: when you write code to post notifications on Slack channel you can only test them  by writing a unit test case. 
-
 There are instances when Robotoff tries to connect to MongoDB via Open Food Facts server. To disable this
 feature (this is disabled by default on local environments), set `ENABLE_MONGODB_ACCESS=0` in your `.env`.
 

doc/how-to-guides/test-and-debug.md

@@ -41,7 +41,6 @@ x-robotoff-base-env:
   INFLUXDB_PORT:
   INFLUXDB_BUCKET:
   INFLUXDB_AUTH_TOKEN:
-  SLACK_TOKEN:
   SENTRY_DSN:
   ELASTIC_HOST:
   ELASTIC_PASSWORD:

doc/introduction/notifications.md

@@ -22,7 +22,6 @@
 )
 from robotoff.models import Prediction as PredictionModel
 from robotoff.models import ProductInsight, db
-from robotoff.notifier import NotifierFactory
 from robotoff.off import OFFAuthentication
 from robotoff.types import (
     ElasticSearchIndex,
@@ -362,7 +361,6 @@ def import_logo_insights(
     thresholds: dict[LogoLabelType, float],
     server_type: ServerType,
     default_threshold: float = 0.2,
-    notify: bool = True,
 ) -> InsightImportResult:
     """Generate and import insights from logos.
 
@@ -377,8 +375,6 @@ class is not defined, default threshold is used
     :param server_type: the server type (project) associated with the logos
     :param default_threshold: the default confidence threshold to use,
         defaults to 0.2
-    :param notify: whether to send a notification for each logo selected to
-        generate an insight, defaults to True
     :return: the result from the insight import
     """
     selected_logos = []
@@ -420,10 +416,6 @@ class is not defined, default threshold is used
     predictions = predict_logo_predictions(selected_logos, logo_probs, server_type)
     import_result = import_insights(predictions, server_type)
 
-    if notify:
-        for logo, probs in zip(selected_logos, logo_probs):
-            NotifierFactory.get_notifier().send_logo_notification(logo, probs)
-
     return import_result
 
 
@@ -632,7 +624,7 @@ def refresh_nearest_neighbors(
             else:
                 logos = [embedding.logo for embedding in logo_embeddings]
                 import_logo_insights(
-                    logos, thresholds=thresholds, server_type=server_type, notify=False
+                    logos, thresholds=thresholds, server_type=server_type
                 )
 
     logger.info("refresh of logo nearest neighbors finished")

docker-compose.yml

@@ -102,7 +102,7 @@ class ProductInsight(BaseModel):
     # above.
     # NOTE: there is no 1:1 mapping between the type and the JSON format
     # provided here, for example for type==label, the data here could be:
-    # {"logo_id":X,"bounding_box":Y}, or {"text":X,"notify":Y}
+    # {"logo_id":X,"bounding_box":Y}, or {"text":X}
     data = BinaryJSONField(default=dict)
 
     # Timestamp is the timestamp of when this insight was imported into the DB.

robotoff/logos.py

@@ -1,34 +1,13 @@
-import json
-import operator
-
-import requests
-from requests.exceptions import ConnectionError as RequestConnectionError
-from requests.exceptions import JSONDecodeError
-
 from robotoff import settings
-from robotoff.models import ImageModel, LogoAnnotation, ProductInsight, crop_image_url
-from robotoff.types import (
-    InsightType,
-    JSONType,
-    LogoLabelType,
-    Prediction,
-    ProductIdentifier,
-    ServerType,
-)
+from robotoff.types import Prediction, ProductIdentifier
 from robotoff.utils import get_logger, http_session
 
 logger = get_logger(__name__)
 
 
-class SlackException(Exception):
-    pass
-
-
 class NotifierInterface:
-    """NotifierInterface is an interface for posting
-    Robotoff-related alerts and notifications
-    to various channels.
-    """
+    """NotifierInterface is an interface for sending notifications
+    to external services."""
 
     # Note: we do not use abstract methods,
     # for a notifier might choose to only implements a few
@@ -41,14 +20,6 @@ def notify_image_flag(
     ):
         pass
 
-    def notify_automatic_processing(self, insight: ProductInsight):
-        pass
-
-    def send_logo_notification(
-        self, logo: LogoAnnotation, probs: dict[LogoLabelType, float]
-    ):
-        pass
-
 
 class NotifierFactory:
     """NotifierFactory is responsible for creating a notifier to post
@@ -57,12 +28,6 @@ class NotifierFactory:
     @staticmethod
     def get_notifier() -> NotifierInterface:
         notifiers: list[NotifierInterface] = []
-        token = settings.slack_token()
-        if token == "":
-            # use a Noop notifier to get logs for tests and dev
-            notifiers.append(NoopSlackNotifier())
-        else:
-            notifiers.append(SlackNotifier(token))
         moderation_service_url: str | None = settings.IMAGE_MODERATION_SERVICE_URL
         if moderation_service_url:
             notifiers.append(ImageModerationNotifier(moderation_service_url))
@@ -92,36 +57,6 @@ def get_notifier() -> NotifierInterface:
 }
 
 
-def _sensitive_image(flag_type: str, flagged_label: str) -> bool:
-    """Determines whether the given flagged image should be considered as
-    sensitive."""
-    is_human = flagged_label in HUMAN_FLAG_LABELS
-    return (
-        is_human and flag_type == "label_annotation"
-    ) or flag_type == "safe_search_annotation"
-
-
-def _slack_message_block(
-    message_text: str, with_image: str | None = None
-) -> list[dict]:
-    """Formats given parameters into a Slack message block."""
-    block = {
-        "type": "section",
-        "text": {
-            "type": "mrkdwn",
-            "text": message_text,
-        },
-    }
-
-    if with_image:
-        block["accessory"] = {
-            "type": "image",
-            "image_url": with_image,
-            "alt_text": "-",
-        }
-    return [block]
-
-
 class MultiNotifier(NotifierInterface):
     """Aggregate multiple notifiers in one instance
 
@@ -147,14 +82,6 @@ def notify_image_flag(
     ):
         self._dispatch("notify_image_flag", predictions, source_image, product_id)
 
-    def notify_automatic_processing(self, insight: ProductInsight):
-        self._dispatch("notify_automatic_processing", insight)
-
-    def send_logo_notification(
-        self, logo: LogoAnnotation, probs: dict[LogoLabelType, float]
-    ):
-        self._dispatch("send_logo_notification", logo, probs)
-
 
 class ImageModerationNotifier(NotifierInterface):
     """Notifier to dispatch to image moderation server
@@ -230,152 +157,3 @@ def notify_image_flag(
                         "barcode": product_id.barcode,
                     },
                 )
-
-
-class SlackNotifier(NotifierInterface):
-    """Notifier to send messages on specific slack channels"""
-
-    # Slack channel IDs.
-    ROBOTOFF_ALERT_CHANNEL = "CGKPALRCG"  # robotoff-alerts-annotations
-
-    BASE_URL = "https://slack.com/api"
-    POST_MESSAGE_URL = BASE_URL + "/chat.postMessage"
-    COLLAPSE_LINKS_PARAMS = {
-        "unfurl_links": False,
-        "unfurl_media": False,
-    }
-
-    def __init__(self, slack_token: str):
-        """Should not be called directly, use the NotifierFactory instead."""
-        self.slack_token = slack_token
-
-    def notify_automatic_processing(self, insight: ProductInsight):
-        server_type = ServerType[insight.server_type]
-        product_url = (
-            f"{settings.BaseURLProvider.world(server_type)}/product/{insight.barcode}"
-        )
-
-        if insight.source_image:
-            if insight.data and "bounding_box" in insight.data:
-                image_url = crop_image_url(
-                    server_type,
-                    insight.source_image,
-                    insight.data.get("bounding_box"),
-                )
-            else:
-                image_url = settings.BaseURLProvider.image_url(
-                    server_type, insight.source_image
-                )
-            metadata_text = f"(<{product_url}|product>, <{image_url}|source image>)"
-        else:
-            metadata_text = f"(<{product_url}|product>)"
-
-        value = insight.value or insight.value_tag
-
-        if insight.type in {
-            InsightType.product_weight.name,
-            InsightType.expiration_date.name,
-        }:
-            text = f"The {insight.type} `{value}` (match: `{insight.data['raw']}`) was automatically added to product {insight.barcode}"
-        else:
-            text = f"The `{value}` {insight.type} was automatically added to product {insight.barcode}"
-
-        message = _slack_message_block(f"{text} {metadata_text}")
-        self._post_message(
-            message, self.ROBOTOFF_ALERT_CHANNEL, **self.COLLAPSE_LINKS_PARAMS
-        )
-
-    def _get_base_params(self) -> JSONType:
-        return {
-            "username": "robotoff-bot",
-            "token": self.slack_token,
-            "icon_url": "https://s3-us-west-2.amazonaws.com/slack-files2/"
-            "bot_icons/2019-03-01/565595869687_48.png",
-        }
-
-    def send_logo_notification(
-        self, logo: LogoAnnotation, probs: dict[LogoLabelType, float]
-    ):
-        crop_url = logo.get_crop_image_url()
-        prob_text = "\n".join(
-            (
-                f"{label[0]} - {label[1]}: {prob:.2g}"
-                for label, prob in sorted(
-                    probs.items(), key=operator.itemgetter(1), reverse=True
-                )
-            )
-        )
-        image_model: ImageModel = logo.image_prediction.image
-        product_id = image_model.get_product_id()
-        base_off_url = settings.BaseURLProvider.world(product_id.server_type)
-        text = (
-            f"Prediction for <{crop_url}|image> "
-            f"(<https://hunger.openfoodfacts.org/logos?logo_id={logo.id}|annotate logo>, "
-            f"<{base_off_url}/product/{product_id.barcode}|product>):\n{prob_text}"
-        )
-        self._post_message(_slack_message_block(text), self.ROBOTOFF_ALERT_CHANNEL)
-
-    def _post_message(
-        self,
-        blocks: list[dict],
-        channel: str,
-        **kwargs,
-    ):
-        try:
-            params: JSONType = {
-                **(self._get_base_params()),
-                "channel": channel,
-                "blocks": json.dumps(blocks),
-                **kwargs,
-            }
-
-            r = http_session.post(self.POST_MESSAGE_URL, data=params)
-            response_json = _get_slack_json(r)
-            return response_json
-        except (RequestConnectionError, JSONDecodeError) as e:
-            logger.info(
-                "An exception occurred when sending a Slack notification", exc_info=e
-            )
-        except Exception as e:
-            logger.error(
-                "An exception occurred when sending a Slack notification", exc_info=e
-            )
-
-
-class NoopSlackNotifier(SlackNotifier):
-    """NoopSlackNotifier is a NOOP SlackNotifier used in dev/local executions
-    of Robotoff."""
-
-    def __init__(self):
-        super().__init__("")
-
-    def _post_message(
-        self,
-        blocks: list[dict],
-        channel: str,
-        **kwargs,
-    ):
-        """Overrides the actual posting to Slack with logging of the args that
-        would've been posted."""
-        logger.info(
-            "Alerting on slack channel '%s', with message:\n%s\nand additional args:\n%s",
-            channel,
-            blocks,
-            kwargs,
-        )
-
-
-def _get_slack_json(response: requests.Response) -> JSONType:
-    json_data = response.json()
-
-    if not response.ok:
-        raise SlackException(
-            "Non-200 status code from Slack: "
-            "{}, response: {}"
-            "".format(response.status_code, json_data)
-        )
-
-    if not json_data.get("ok", False):
-        raise SlackException("Non-ok response: {}".format(json_data))
-
-    return json_data

robotoff/models.py

@@ -5,7 +5,7 @@
 
 from robotoff import settings
 from robotoff.brands import get_brand_blacklist, keep_brand_from_taxonomy
-from robotoff.types import Prediction, PredictionType
+from robotoff.types import JSONType, Prediction, PredictionType
 from robotoff.utils import get_logger, text_file_iter
 from robotoff.utils.cache import function_cache_register
 from robotoff.utils.text import KeywordProcessor, get_tag
@@ -78,7 +78,7 @@ def extract_brands(
         text, span_info=True
     ):
         match_str = text[span_start:span_end]
-        data = {"text": match_str, "notify": False}
+        data: JSONType = {"text": match_str}
         if (
             bounding_box := get_match_bounding_box(content, span_start, span_end)
         ) is not None:
@@ -113,7 +113,6 @@ def extract_brands_google_cloud_vision(ocr_result: OCRResult) -> list[Prediction
                     value_tag=get_tag(brand),
                     automatic_processing=False,
                     predictor="google-cloud-vision",
-                    data={"notify": False},
                     confidence=logo_annotation.score,
                     predictor_version=PREDICTOR_VERSION,
                 )