wbnews 1.58.3__py2.py3-none-any.whl

wbnews/models/news.py

@@ -0,0 +1,131 @@
+from datetime import date
+from typing import Any
+
+from celery import chord, shared_task
+from celery.canvas import Signature
+from django.conf.global_settings import LANGUAGES
+from django.contrib.postgres.fields import ArrayField
+from django.db import models
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+from slugify import slugify
+from wbcore.contrib.ai.llm.decorators import llm
+from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.models import WBModel
+
+from wbnews.import_export.handlers.news import NewsImportHandler
+from wbnews.models.llm.cleaned_news import clean_news_config, summarized_news_config
+from wbnews.models.relationships import NewsRelationship
+from wbnews.signals import create_news_relationships
+
+from ..utils import detect_near_duplicates
+
+
+@shared_task
+def create_relationship(chain_results: list[list[dict[str, Any]]], news_id: int):
+    objs = []
+    for relationships in chain_results:
+        for relationship in relationships:
+            objs.append(NewsRelationship(news_id=news_id, **relationship))
+    NewsRelationship.objects.bulk_create(
+        objs,
+        ignore_conflicts=True,
+        unique_fields=["content_type", "object_id", "news"],
+    )
+
+
+class DefaultObjectManager(models.Manager):
+    def get_queryset(self):
+        return super().get_queryset().filter(mark_as_duplicate=False)
+
+
+@llm([clean_news_config, summarized_news_config])
+class News(ImportMixin, WBModel):
+    errors = {
+        "relationship_signal": "using the fetch_new_relationships signal must return a list of tuples, sender: {0} did not."
+    }
+    import_export_handler_class = NewsImportHandler
+
+    datetime = models.DateTimeField(verbose_name=_("Datetime"), default=timezone.now)
+    title = models.CharField(max_length=500, verbose_name=_("Title"))
+    guid = models.CharField(max_length=1024, unique=True)
+    description = models.TextField(blank=True, verbose_name=_("Description"))
+    summary = models.TextField(blank=True, verbose_name=_("Summary"))
+    language = models.CharField(max_length=16, choices=LANGUAGES, blank=True, null=True, verbose_name=_("Language"))
+    link = models.URLField(max_length=1024, blank=True, null=True, verbose_name=_("Link"))
+    tags = ArrayField(models.CharField(max_length=16), default=list)
+    enclosures = ArrayField(models.URLField(), default=list)
+    source = models.ForeignKey(
+        "wbnews.NewsSource", on_delete=models.CASCADE, related_name="news", verbose_name=_("Source")
+    )
+    image_url = models.URLField(blank=True, null=True)
+    mark_as_duplicate = models.BooleanField(default=False, verbose_name=_("Mark as duplicate"))
+
+    objects = DefaultObjectManager()
+    all_objects = models.Manager()
+
+    def save(self, *args, **kwargs):
+        self.datetime = min(self.datetime, timezone.now())  # we ensure a news is never in the future
+        if self.guid is None:
+            self.guid = self.get_default_guid(self.title, self.link)
+        super().save(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return f"{self.title} ({self.source.title})"
+
+    def update_and_create_news_relationships(self, synchronous: bool = False):
+        """
+        This methods fires the signal to fetch the possible relationship to be linked to the news
+        """
+        tasks = []
+        for sender, task_signature in create_news_relationships.send(sender=News, instance=self):
+            if not isinstance(task_signature, Signature):
+                raise AssertionError(self.errors["relationship_signal"].format(sender))
+            tasks.append(task_signature)
+        if tasks:
+            res = chord(tasks, create_relationship.s(self.id))
+            if synchronous:
+                res.apply()
+            else:
+                res.apply_async()
+
+    @classmethod
+    def get_default_guid(cls, title: str, link: str | None, max_length: int = 1024) -> str:
+        if link:
+            return link
+        return slugify(title)[0:max_length]
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbnews:news-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{title}} ({{datetime}})"
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbnews:news"
+
+    @classmethod
+    def handle_duplicates(cls, start: date, end: date, content_label: str = "description", threshold: float = 0.9):
+        qs = News.objects.filter(datetime__gte=start, datetime__lte=end)
+        data = dict(qs.values_list("id", content_label))
+        duplicate_ids = detect_near_duplicates(data, threshold=threshold)
+        qs.filter(id__in=duplicate_ids).update(mark_as_duplicate=True)
+
+
+@receiver(post_save, sender="wbnews.News")
+def post_save_create_news_relationships(sender: type, instance: "News", raw: bool, created: bool, **kwargs):
+    """
+    Post save to lazy create relationship between an instrument and a news upon creation
+    """
+
+    if not raw and created:
+        instance.update_and_create_news_relationships()

wbnews/models/relationships.py

@@ -0,0 +1,45 @@
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.utils.translation import gettext as _
+
+
+class NewsRelationship(models.Model):
+    class SentimentChoices(models.IntegerChoices):
+        POSITIVE = 4, _("Positive")
+        SLIGHTLY_POSITIVE = 3, _("Slightly Positive")
+        SLIGHTLY_NEGATIVE = 2, _("Slightly Negative")
+        NEGATIVE = 1, _("Negative")
+
+        def get_color(self):
+            colors = {
+                "POSITIVE": "#96DD99",
+                "SLIGHTLY_POSITIVE": "#FFEE8C",
+                "SLIGHTLY_NEGATIVE": "#FF964F",
+                "NEGATIVE": "#FF6961",
+            }
+            return colors[self.name]
+
+    news = models.ForeignKey(to="wbnews.News", related_name="relationships", on_delete=models.CASCADE)
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    object_id = models.PositiveIntegerField()
+    content_object = GenericForeignKey("content_type", "object_id")
+    content_object_repr = models.CharField(max_length=512, default="")
+
+    important = models.BooleanField(null=True, blank=True)
+    sentiment = models.PositiveIntegerField(null=True, blank=True, choices=SentimentChoices.choices)
+    analysis = models.TextField(null=True, blank=True)
+
+    def save(self, *args, **kwargs):
+        self.content_object_repr = str(self.content_object)
+        super().save(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return f"{self.news.title} -> {self.content_object}"
+
+    class Meta:
+        verbose_name = "News Relationship"
+        indexes = [models.Index(fields=["content_type", "object_id"])]
+        constraints = [
+            models.UniqueConstraint(name="unique_news_relationship", fields=["content_type", "object_id", "news"])
+        ]

wbnews/models/sources.py

@@ -0,0 +1,73 @@
+import re
+
+from django.contrib.postgres.fields import ArrayField
+from django.db import models
+from wbcore.models import WBModel
+
+from wbnews.models.utils import endpoint_to_author
+
+
+class NewsSource(WBModel):
+    class Type(models.TextChoices):
+        RSS = "RSS", "RSS"
+        EMAIL = "EMAIL", "EMAIL"
+
+    type = models.CharField(default=Type.RSS, choices=Type.choices, max_length=6)
+    title = models.CharField(max_length=255)
+    identifier = models.CharField(max_length=255, unique=True, blank=True, null=True)
+    tags = ArrayField(models.CharField(max_length=16), default=list, blank=True)
+    image = models.URLField(blank=True, null=True)
+    description = models.TextField(default="", blank=True)
+    author = models.CharField(max_length=255, default="")
+    clean_content = models.BooleanField(default=False)
+    endpoint = models.CharField(max_length=1024, unique=True)
+    is_active = models.BooleanField(default=True)
+
+    def __str__(self):
+        return f"{self.title}"
+
+    def save(self, *args, **kwargs):
+        if not self.author and self.endpoint:
+            self.author = endpoint_to_author(self.endpoint)
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbnews:sourcerepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{title}}"
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbnews:source"
+
+    @classmethod
+    def source_dict_to_model(cls, data: dict):
+        sources = NewsSource.objects.all()
+        endpoint = data.pop("endpoint", None)
+        if "id" in data:
+            return sources.get(id=data["id"])
+        if type := data.get("type"):
+            sources = sources.filter(type=type)
+        if identifier := data.get("identifier"):
+            sources = sources.filter(identifier=identifier)
+        elif endpoint:
+            for source in sources:
+                match = re.search(source.endpoint, endpoint)
+                if source.endpoint == endpoint or match:
+                    return source
+        if sources.count() == 1:
+            return sources.first()
+        else:
+            if endpoint:
+                # Pattern to capture and replace the local part of an email
+                pattern = r"^[^@]+"
+                # Replace the local part of an email with a wildcard regex
+                endpoint = re.sub(pattern, ".*", re.escape(endpoint))
+            return NewsSource.objects.create(**data, endpoint=endpoint)

wbnews/models/utils.py

@@ -0,0 +1,15 @@
+from contextlib import suppress
+from urllib.parse import urlparse
+
+
+def endpoint_to_author(endpoint: str) -> str:
+    author = endpoint
+    if "@" in endpoint:  # simplist way to check if the endpoint is an email address
+        author = author.replace("\\", "").split("@")[-1].split(".")
+        if len(author) > 1:
+            author = ".".join(author[:-1])
+    else:  # otherwise we consider it's a valid url and we extract only the domain part
+        with suppress(ValueError, IndexError):
+            author = urlparse(author).netloc.split(".")[-2]
+
+    return author.replace("_", " ").title()

wbnews/serializers.py

@@ -0,0 +1,134 @@
+from django.utils.translation import gettext_lazy as _
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.content_type.serializers import (
+    ContentTypeRepresentationSerializer,
+    DynamicObjectIDRepresentationSerializer,
+)
+
+from .models import News, NewsRelationship, NewsSource
+
+
+class SourceRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbnews:source-detail")
+
+    class Meta:
+        model = NewsSource
+        fields = ("id", "title", "_detail")
+
+
+class SourceModelSerializer(wb_serializers.ModelSerializer):
+    title = wb_serializers.CharField(read_only=True, label=_("Title"))
+    identifier = wb_serializers.CharField(read_only=True, label=_("Identifier"))
+    image = wb_serializers.CharField(read_only=True)
+    description = wb_serializers.CharField(read_only=True, label=_("Description"))
+    author = wb_serializers.CharField(read_only=True, label=_("Author"))
+    updated = wb_serializers.DateTimeField(read_only=True, label=_("Updated"))
+
+    @wb_serializers.register_resource()
+    def news(self, instance, request, user):
+        return {"news": reverse("wbnews:source-news-list", args=[instance.id], request=request)}
+
+    class Meta:
+        model = NewsSource
+        fields = ("id", "title", "identifier", "image", "description", "author", "updated", "_additional_resources")
+
+
+class NewsRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbnews:news-detail")
+
+    class Meta:
+        model = News
+        fields = ("id", "datetime", "title", "_detail")
+
+
+class NewsModelSerializer(wb_serializers.ModelSerializer):
+    _source = SourceRepresentationSerializer(source="source")
+    image_url = wb_serializers.ImageURLField()
+
+    @wb_serializers.register_resource()
+    def open_link(self, instance, request, user):
+        if instance.link:
+            return {"open_link": instance.link}
+        return {}
+
+    # link = wb_serializers.URL()
+    class Meta:
+        model = News
+        fields = (
+            "id",
+            "datetime",
+            "title",
+            "description",
+            "summary",
+            "link",
+            "language",
+            "image_url",
+            "source",
+            "_source",
+            "_additional_resources",
+        )
+
+
+class NewsRelationshipModelSerializer(wb_serializers.ModelSerializer):
+    source = wb_serializers.PrimaryKeyCharField(read_only=True)
+    _source = SourceRepresentationSerializer(source="source")
+    title = wb_serializers.TextField(read_only=True, label=_("Title"))
+    description = wb_serializers.TextField(read_only=True, label=_("Description"))
+    summary = wb_serializers.TextField(read_only=True, label=_("Summary"))
+    datetime = wb_serializers.DateTimeField(read_only=True, label=_("Date"))
+    _content_type = ContentTypeRepresentationSerializer(source="content_type")
+    object_id = wb_serializers.CharField(label="Linked Object", required=False)
+    _object_id = DynamicObjectIDRepresentationSerializer(
+        content_type_field_name="content_type",
+        source="object_id",
+        optional_get_parameters={"content_type": "content_type"},
+        depends_on=[{"field": "content_type", "options": {}}],
+        filter_params={
+            "is_security": True
+        },  # TODO needs to find a way to not create a dependency to the wbfdm module here
+    )
+    news = wb_serializers.PrimaryKeyRelatedField(
+        queryset=News.objects.all(), read_only=lambda view: not view.new_mode, label=_("News")
+    )
+    _news = NewsRepresentationSerializer(source="news")
+
+    def validate(self, data):
+        if view := self.context["view"]:
+            if view.object_id:
+                data["object_id"] = view.object_id
+            if view.content_type:
+                data["content_type"] = view.content_type
+        return super().validate(data)
+
+    class Meta:
+        model = NewsRelationship
+        read_only_fields = (
+            "content_object_repr",
+            "datetime",
+            "title",
+            "description",
+            "summary",
+            "content_type",
+            "_content_type",
+        )
+        fields = (
+            "id",
+            "news",
+            "_news",
+            "content_object_repr",
+            "datetime",
+            "sentiment",
+            "analysis",
+            "important",
+            "title",
+            "description",
+            "summary",
+            "source",
+            "_source",
+            "content_type",
+            "_content_type",
+            "object_id",
+            "_object_id",
+            "_additional_resources",
+        )

wbnews/signals.py

@@ -0,0 +1,4 @@
+from django.db.models.signals import ModelSignal
+
+# this signal is gather the news relationship to efficiently handle the insertion.
+create_news_relationships = ModelSignal(use_caching=False)

wbnews/tasks.py

@@ -0,0 +1,16 @@
+from datetime import date, timedelta
+
+from celery import shared_task
+
+from wbnews.models import News
+
+
+@shared_task()
+def handle_daily_news_duplicates(
+    task_date: date | None = None,
+    day_interval: int = 7,
+):
+    if not task_date:
+        task_date = date.today()
+
+    News.handle_duplicates(task_date - timedelta(days=day_interval), task_date + timedelta(days=day_interval))

wbnews/tests/conftest.py

@@ -0,0 +1,6 @@
+from pytest_factoryboy import register
+from wbcore.tests.conftest import *
+from wbnews.factories import NewsFactory, NewsSourceFactory
+
+register(NewsSourceFactory)
+register(NewsFactory)

wbnews/tests/parsers/test_emails.py

@@ -0,0 +1,25 @@
+from unittest.mock import PropertyMock, patch
+
+import pytest
+
+from wbnews.import_export.parsers.emails.utils import EmlContentParser
+
+
+class TestEmlContentParser:
+    @pytest.fixture
+    def content_parser(self):
+        parser = EmlContentParser(b"")
+        parser.message = {"From": "main@acme.com"}
+        return parser
+
+    @patch.object(EmlContentParser, "text", new_callable=PropertyMock)
+    def test_source_from_in_text(self, mock_text, content_parser):
+        mock_text.return_value = (
+            "some random email content with a From field From: source name <email@test.com> and the rest of the email"
+        )
+        assert content_parser.source == {"title": "Source Name", "endpoint": "email@test.com", "type": "EMAIL"}
+
+    @patch.object(EmlContentParser, "text", new_callable=PropertyMock)
+    def test_source_from_in_text_alt(self, mock_text, content_parser):
+        mock_text.return_value = "some random email content without a From field"
+        assert content_parser.source == {"title": "Acme.Com", "endpoint": "main@acme.com", "type": "EMAIL"}

wbnews/tests/test_models.py

@@ -0,0 +1,80 @@
+from datetime import timedelta, timezone
+from unittest.mock import patch
+
+import pytest
+from django.utils import timezone as django_timezone
+from faker import Faker
+
+from wbnews.models import News, NewsSource
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestSource:
+    @pytest.mark.parametrize("news_source__title", ["source1"])
+    def test_str(self, news_source):
+        assert str(news_source) == f"{news_source.title}"
+
+    def test_source_dict_to_model(self, news_source_factory):
+        ns1 = news_source_factory.create()
+        ns2 = news_source_factory.create()
+
+        assert NewsSource.source_dict_to_model({"id": ns1.id, "identifier": ns2.identifier}) == ns1  # priority to "id"
+        assert (
+            NewsSource.source_dict_to_model({"endpoint": ns1.endpoint, "identifier": ns2.identifier}) == ns2
+        )  # priority to "identifier"
+        assert NewsSource.source_dict_to_model({"endpoint": ns2.endpoint}) == ns2  # exact match on endpoint
+
+        ns1.endpoint = ".*@test.com"
+        ns1.save()
+        assert NewsSource.source_dict_to_model({"endpoint": "abc@test.com"}) == ns1  # regex match on endpoint
+
+        new_source = NewsSource.source_dict_to_model({"endpoint": "abc@main_source.com", "title": "New Source"})
+        assert new_source not in [ns1, ns2]
+        assert new_source.endpoint == r".*@main_source\.com"
+        assert new_source.title == "New Source"
+        assert new_source.author == "Main Source"
+
+
+@pytest.mark.django_db
+class TestNews:
+    @pytest.mark.parametrize("news__title", ["new1"])
+    def test_str(self, news):
+        assert str(news) == f"{news.title} ({news.source.title})"
+
+    def test_mark_as_deplicates_not_in_default_queryset(self, news):
+        assert set(News.objects.all()) == {news}
+
+    def test_get_default_guid(self):
+        assert News.get_default_guid("This is a title", None) == "this-is-a-title"
+        assert (
+            News.get_default_guid("This is a title", "http://mylink.com") == "http://mylink.com"
+        )  # link takes precendence
+        assert News.get_default_guid("a" * 24, None, max_length=20) == "a" * 20
+
+    def test_future_news(self, news_factory):
+        # ensure a future datetime always default to now
+        now = django_timezone.now()
+        future_news = news_factory.create(datetime=now + timedelta(days=1))
+        assert (future_news.datetime - now).seconds < 1  # we do that to account for clock difference
+
+    @patch("wbnews.models.news.detect_near_duplicates")
+    def test_handle_duplicates(self, mock_fct, news_factory):
+        val_date = fake.date_time(tzinfo=timezone.utc)
+        n0 = news_factory.create(
+            datetime=val_date - timedelta(days=1)
+        )  # we exclude this news from the duplicate search
+        n1 = news_factory.create(datetime=val_date)
+        n2 = news_factory.create(datetime=val_date)
+        n3 = news_factory.create(datetime=val_date)
+
+        mock_fct.return_value = [
+            n0.id,
+            n3.id,
+        ]  # n0 is considered as duplicate but does not fall within the specified daterange so it will not be marked
+        News.handle_duplicates(val_date, val_date)
+
+        n3.refresh_from_db()
+        assert n3.mark_as_duplicate is True
+        assert set(News.objects.all()) == {n0, n1, n2}

wbnews/tests/test_utils.py

@@ -0,0 +1,7 @@
+from wbnews.models.utils import endpoint_to_author
+
+
+def test_endpoint_to_author():
+    assert endpoint_to_author("test@test_test\\.com") == "Test Test"
+    assert endpoint_to_author("http://somesubdomain.domain.com") == "Domain"
+    assert endpoint_to_author("test") == "Test"

wbnews/tests/tests.py

@@ -0,0 +1,12 @@
+import pytest
+from wbcore.test import GenerateTest, default_config
+
+config = {}
+for key, value in default_config.items():
+    config[key] = list(filter(lambda x: x.__module__.startswith("wbnews"), value))
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass

wbnews/urls.py

@@ -0,0 +1,25 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from wbnews.viewsets import views
+
+router = WBCoreRouter()
+router.register(r"newsrepresentation", views.NewsRepresentationViewSet, basename="newsrepresentation")
+router.register(r"newssourcerepresentation", views.SourceRepresentationViewSet, basename="sourcerepresentation")
+router.register(r"news", views.NewsModelViewSet, basename="news")
+router.register(r"newssource", views.SourceModelViewSet, basename="source")
+router.register(r"newsrelationship", views.NewsRelationshipModelViewSet, basename="newsrelationship")
+
+
+source_router = WBCoreRouter()
+source_router.register(r"news", views.NewsSourceModelViewSet, basename="source-news")
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("source/<int:source_id>/", include(source_router.urls)),
+    path(
+        "contentnews/<int:content_type>/<int:content_id>/",
+        views.NewsModelViewSet.as_view({"get": "list"}),
+        name="news_content_object",
+    ),
+]

wbnews/utils.py

@@ -0,0 +1,57 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from django.utils.html import strip_tags
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+logger = logging.getLogger("news")
+
+
+def _get_similarity_matrix_df(data: dict[int, str]) -> pd.DataFrame:
+    # Convert texts to TF-IDF vectors
+    ids, texts = zip(*data.items(), strict=False)
+    vectorizer = TfidfVectorizer()
+    tfidf_matrix = vectorizer.fit_transform(texts)
+    # Compute pairwise cosine similarity...
+    similarity_matrix = cosine_similarity(tfidf_matrix)
+    # convert the matrix into a proper dataframe
+    return pd.DataFrame(similarity_matrix, index=ids, columns=ids)
+
+
+def detect_near_duplicates(data: dict[int, str], threshold: float = 0.9) -> list[int]:
+    """
+    Detects near-duplicate articles based on TF-IDF & Cosine Similarity.
+
+    Parameters:
+    - data (dict[int, str]): dictionary of new id with their respective content
+    - threshold (float): Similarity threshold (default = 0.9).
+
+    Returns:
+    - List of duplicated ids
+    """
+    if len(data.keys()) < 2:
+        return []
+    logger.info(f"Processing {len(data.keys())} news")
+    # Cleanup step
+    clean_data = {}
+    for _id, text in data.items():
+        clean_data[_id] = strip_tags(text)
+
+    # get similarity matrix
+    df = _get_similarity_matrix_df(data)
+
+    # Replace the lower matrix triangle with NaN
+    df = df.where(np.triu(np.ones(df.shape)).astype(bool))
+    # melt the symmetrical matrix into a key value store
+    df = df.stack().reset_index(name="value")
+    # remove duplicate pair with same id (expected to be 1.0)
+    df = df[df["level_0"] != df["level_1"]]
+    # get duplicates candidates
+    df = df[df["value"] > threshold]
+    # return only one side of the duplicate pair
+    duplicate_ids = df["level_1"].unique().tolist()
+    logger.info(f"{len(duplicate_ids)} duplicated news found")
+
+    return duplicate_ids

wbnews/viewsets/__init__.py

@@ -0,0 +1,12 @@
+from .buttons import NewsButtonConfig
+from .display import NewsDisplayConfig, NewsSourceDisplayConfig, SourceDisplayConfig
+from .endpoints import NewsEndpointConfig, NewsSourceEndpointConfig, NewsRelationshipEndpointConfig
+from .menu import NEWS_MENUITEM, NEWSSOURCE_MENUITEM
+from .titles import NewsSourceModelTitleConfig, NewsTitleConfig, SourceModelTitleConfig
+from .views import (
+    NewsModelViewSet,
+    NewsRepresentationViewSet,
+    SourceModelViewSet,
+    SourceRepresentationViewSet,
+    NewsRelationshipModelViewSet,
+)