django-camomilla-cms 6.0.0b13__py2.py3-none-any.whl → 6.0.0b15__py2.py3-none-any.whl

camomilla/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "6.0.0-beta.13"
+__version__ = "6.0.0-beta.15"
 
 
 def get_core_apps():

camomilla/dynamic_pages_urls.py

@@ -7,7 +7,8 @@ from .models import Page
 
 
 def fetch(request, *args, **kwargs):
-    preview = request.user.is_staff and request.GET.get("preview", False)
+    can_preview = request.user.is_staff or settings.DEBUG
+    preview = can_preview and request.GET.get("preview", False)
     append_slash = getattr(django_settings, "APPEND_SLASH", True)
     if append_slash and not request.path.endswith("/"):
         return redirect(request.path + "/")

camomilla/fields/__init__.py

@@ -1,7 +1,5 @@
 from django.db import models
 
-from camomilla.structured import StructuredJSONField
-
 from .json import ArrayField, JSONField
 
 ORDERING_ACCEPTED_FIELDS = (
@@ -12,4 +10,4 @@ ORDERING_ACCEPTED_FIELDS = (
     models.SmallIntegerField,
 )
 
-__all__ = ["StructuredJSONField", "JSONField", "ArrayField", "ORDERING_ACCEPTED_FIELDS"]
+__all__ = ["JSONField", "ArrayField", "ORDERING_ACCEPTED_FIELDS"]

camomilla/managers/pages.py

@@ -1,31 +1,31 @@
-from typing import Any, Tuple
 from django.db.models.query import QuerySet
-from django.db import transaction
+from django.core.exceptions import ObjectDoesNotExist
 from django.apps import apps
 
 URL_NODE_RELATED_NAME = "%(app_label)s_%(class)s"
 
 
 class PageQuerySet(QuerySet):
-    def get_or_create(self, defaults=None, **kwargs) -> Tuple[Any, bool]:
-        if "permalink" in kwargs:
-            with transaction.atomic():
-                UrlNode = apps.get_model("camomilla", "UrlNode")
-                url_node, created = UrlNode.objects.get_or_create(
-                    permalink=kwargs.pop("permalink"),
-                    related_name=URL_NODE_RELATED_NAME % self.model_info
+    
+    __UrlNodeModel = None
+    
+    @property
+    def UrlNodeModel(self):
+        if not self.__UrlNodeModel:
+            self.__UrlNodeModel = apps.get_model("camomilla", "UrlNode")
+        return self.__UrlNodeModel 
+    
+    def get_permalink_kwargs(self, kwargs):
+        return list(set(kwargs.keys()).intersection(set(self.UrlNodeModel.LANG_PERMALINK_FIELDS + ["permalink"])))
+    
+    def get(self, *args, **kwargs):
+        permalink_args = self.get_permalink_kwargs(kwargs)
+        if len(permalink_args):
+            try:
+                node = self.UrlNodeModel.objects.get(**{arg:kwargs.pop(arg) for arg in permalink_args})
+                kwargs["url_node"] = node
+            except ObjectDoesNotExist:
+                raise self.model.DoesNotExist(
+                    "%s matching query does not exist." % self.model._meta.object_name
                 )
-                if created is False and url_node.page is not None:
-                    page = self.get(**kwargs)
-                    if page.pk != url_node.page.pk:
-                        raise self.model.MultipleObjectsReturned(
-                            "got more than one %s object for the same permalink: %s"
-                            % (
-                                self.model._meta.object_name,
-                                kwargs["permalink"],
-                            )
-                        )
-                    return url_node.page, False
-                kwargs["url_node"] = url_node
-                return super().get_or_create(defaults, **kwargs)
-        return super().get_or_create(defaults, **kwargs)
+        return super(PageQuerySet, self).get(*args, **kwargs)

camomilla/models/menu.py

@@ -12,9 +12,12 @@ from pydantic import (
     computed_field,
     model_serializer,
 )
-from camomilla import structured
-from camomilla.models.page import UrlNode
+from structured.pydantic.models import BaseModel
+from structured.fields import StructuredJSONField
+from structured.pydantic.fields import QuerySet
+from camomilla.models.page import UrlNode, AbstractPage
 from typing import Optional, Union, Callable, List
+from django.db.models.base import Model as DjangoModel
 
 
 class LinkTypes(str, Enum):
@@ -22,21 +25,29 @@ class LinkTypes(str, Enum):
     static = "ST"
 
 
-class MenuNodeLink(structured.BaseModel):
+class MenuNodeLink(BaseModel):
     link_type: LinkTypes = LinkTypes.static
     static: str = None
-    content_type: int = None
-    page_id: int = None
+    content_type: ContentType = None
+    page: AbstractPage = None
     url_node: UrlNode = None
 
     @model_serializer(mode="wrap", when_used="json")
     def update_relational(self, handler: Callable, info: SerializationInfo):
         if self.link_type == LinkTypes.relational:
-            if self.content_type and self.page_id:
-                c_type = ContentType.objects.filter(pk=self.content_type).first()
+            if self.content_type and self.page:
+                if isinstance(self.page, DjangoModel) and not self.page._meta.abstract:
+                    self.content_type = ContentType.objects.get_for_model(self.page.__class__)
+                ctype_id = getattr(self.content_type, "pk", self.content_type)
+                page_id = getattr(self.page, "pk", self.page)
+                c_type = ContentType.objects.filter(pk=ctype_id).first()
                 model = c_type and c_type.model_class()
-                page = model and model.objects.filter(pk=self.page_id).first()
+                page = model and model.objects.filter(pk=page_id).first()
                 self.url_node = page and page.url_node
+            elif self.url_node:
+                url_node_id = getattr(self.url_node, "pk", self.url_node)
+                self.page = UrlNode.objects.filter(pk=url_node_id).first().page
+                self.content_type = ContentType.objects.get_for_model(self.page.__class__)
         return handler(self)
 
     def get_url(self, request=None):
@@ -51,7 +62,7 @@ class MenuNodeLink(structured.BaseModel):
         return self.get_url()
 
 
-class MenuNode(structured.BaseModel):
+class MenuNode(BaseModel):
     id: str = Field(default_factory=uuid4)
     meta: dict = {}
     nodes: List["MenuNode"] = []
@@ -63,7 +74,7 @@ class Menu(models.Model):
     key = models.CharField(max_length=200, unique=True, editable=False)
     available_classes = models.JSONField(default=dict, editable=False)
     enabled = models.BooleanField(default=True)
-    nodes = structured.StructuredJSONField(default=list, schema=MenuNode)
+    nodes = StructuredJSONField(default=list, schema=MenuNode)
 
     class Meta:
         verbose_name = _("menu")

camomilla/models/page.py

@@ -2,7 +2,6 @@ from typing import Sequence, Tuple
 from uuid import uuid4
 
 from django.core.exceptions import ObjectDoesNotExist
-from django.core.validators import RegexValidator
 
 from django.db import ProgrammingError, OperationalError, models, transaction
 from django.db.models.signals import post_delete
@@ -13,6 +12,7 @@ from django.utils import timezone
 from django.utils.functional import lazy
 from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
+from django.utils.translation import get_language
 
 from camomilla.managers.pages import PageQuerySet
 from camomilla.models.mixins import MetaMixin, SeoMixin
@@ -29,8 +29,13 @@ from camomilla.utils.getters import pointed_getter
 from camomilla import settings
 from camomilla.templates_context.rendering import ctx_registry
 from django.conf import settings as django_settings
+from modeltranslation.settings import AVAILABLE_LANGUAGES
+from modeltranslation.utils import build_localized_fieldname
 
 
+class UrlPathValidator():
+    pass
+
 def GET_TEMPLATE_CHOICES():
     return [(t, t) for t in get_all_templates_files()]
 
@@ -111,6 +116,14 @@ class UrlNodeManager(models.Manager):
 
 
 class UrlNode(models.Model):
+    
+    LANG_PERMALINK_FIELDS = [
+        build_localized_fieldname("permalink", lang)
+        for lang in AVAILABLE_LANGUAGES
+        if settings.ENABLE_TRANSLATIONS
+    ]
+    
+    
     permalink = models.CharField(max_length=400, unique=True, null=True)
     related_name = models.CharField(max_length=200)
     objects = UrlNodeManager()
@@ -140,6 +153,23 @@ class UrlNode(models.Model):
         if self.routerlink == "/":
             return ""
         return self.routerlink
+    
+    @staticmethod
+    def sanitize_permalink(permalink):
+        if isinstance(permalink, str):
+            p_parts = permalink.split("/")
+            permalink = "/".join([slugify(p, allow_unicode=True).strip() for p in p_parts])
+            if not permalink.startswith("/"):
+                permalink = f"/{permalink}"
+        return permalink
+    
+    def save(self, *args, **kwargs) -> None:
+        for lang_p_field in UrlNode.LANG_PERMALINK_FIELDS:
+            setattr(self, lang_p_field, UrlNode.sanitize_permalink(getattr(self, lang_p_field)))
+        super().save(*args, **kwargs)
+        
+    def __str__(self) -> str:
+        return self.permalink
 
 
 PAGE_CHILD_RELATED_NAME = "%(app_label)s_%(class)s_child_pages"
@@ -154,11 +184,28 @@ PAGE_STATUS = (
 
 
 class PageBase(models.base.ModelBase):
+    """
+        This models comes to implement a language based permalink logic
+    """
+    def perm_prop_factory(permalink_field):
+        def getter(_self):
+            return getattr(_self, f"__{permalink_field}", getattr(_self.url_node or object(), permalink_field, None))
+        def setter(_self, value:str):
+            setattr(_self, f"__{permalink_field}", value)
+        return getter, setter
+    
     def __new__(cls, name, bases, attrs, **kwargs):
         attr_meta = attrs.pop("PageMeta", None)
         new_class = super().__new__(cls, name, bases, attrs, **kwargs)
         page_meta = attr_meta or getattr(new_class, "PageMeta", None)
         base_page_meta = getattr(new_class, "_page_meta", None)
+        for lang_p_field in UrlNode.LANG_PERMALINK_FIELDS:
+            computed_prop = property(*cls.perm_prop_factory(lang_p_field))
+            setattr(new_class, lang_p_field, computed_prop)
+        setattr(new_class, "permalink", property(
+            lambda _self: getattr(_self, build_localized_fieldname("permalink", get_language()), None),
+            lambda _self, value: setattr(_self, f"__{build_localized_fieldname('permalink', get_language())}", value)
+        ))
         if page_meta:
             for name, value in getattr(base_page_meta, "__dict__", {}).items():
                 if name not in page_meta.__dict__:
@@ -167,16 +214,6 @@ class PageBase(models.base.ModelBase):
         return new_class
 
 
-class UrlPathValidator(RegexValidator):
-    
-    regex = r"^[a-zA-Z0-9_\-\/]+[^\/]$"
-    message = _(
-        "Enter a valid 'slug' consisting of lowercase letters, numbers, "
-        "underscores, hyphens and slashes."
-    )
-    flags = 0
-
-
 class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     date_created = models.DateTimeField(auto_now_add=True)
     date_updated_at = models.DateTimeField(auto_now=True)
@@ -188,9 +225,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         editable=False,
     )
     breadcrumbs_title = models.CharField(max_length=128, null=True, blank=True)
-    slug = models.CharField(
-        max_length=150, null=True, blank=True, validators=[UrlPathValidator()]
-    )
+    autopermalink = models.BooleanField(default=True)
     status = models.CharField(
         max_length=3,
         choices=PAGE_STATUS,
@@ -211,6 +246,19 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     )
 
     objects = PageQuerySet.as_manager()
+    
+    __cached_db_instance: "AbstractPage" = None
+
+    @property
+    def db_instance(self):
+        if self.__cached_db_instance is None:
+            self.__cached_db_instance = self.get_db_instance()
+        return self.__cached_db_instance
+    
+    def get_db_instance(self):
+        if self.pk:
+            return self.__class__.objects.get(pk=self.pk)
+        return None
 
     def __init__(self, *args, **kwargs):
         super(AbstractPage, self).__init__(*args, **kwargs)
@@ -240,10 +288,6 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def model_info(self) -> dict:
         return {"app_label": self._meta.app_label, "class": self._meta.model_name}
 
-    @property
-    def permalink(self) -> str:
-        return self.url_node and self.url_node.permalink
-
     @property
     def routerlink(self) -> str:
         return self.url_node and self.url_node.routerlink
@@ -252,7 +296,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def breadcrumbs(self) -> Sequence[dict]:
         breadcrumb = {
             "permalink": self.permalink,
-            "title": self.breadcrumbs_title or self.title or self.slug,
+            "title": self.breadcrumbs_title or self.title or "",
         }
         if self.parent:
             return self.parent.breadcrumbs + [breadcrumb]
@@ -291,8 +335,10 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def _update_url_node(self, force: bool = False) -> UrlNode:
         self.url_node = self._get_or_create_url_node()
         for __ in activate_languages():
-            old_permalink = self.permalink
-            new_permalink = self.generate_permalink()
+            old_permalink = self.db_instance and self.db_instance.permalink
+            new_permalink = self.permalink
+            if self.autopermalink:            
+                new_permalink = self.generate_permalink()
             force = force or old_permalink != new_permalink
             set_nofallbacks(self.url_node, "permalink", new_permalink)
         if force:
@@ -301,22 +347,10 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         return self.url_node
 
     def generate_permalink(self, safe: bool = True) -> str:
-        slug = get_nofallbacks(self, "slug")
-        if slug is None and not self.permalink:
-            translations = get_field_translations(self, "slug").values()
-            fallback_slug = next((t for t in translations if t is not None), None)
-            slug = (
-                slugify(self.title or uuid4(), allow_unicode=True)
-                if fallback_slug is None
-                else fallback_slug
-            )
-            set_nofallbacks(self, "slug", slug)
-        slug_parts = (slug or "").split("/")
-        for i, part in enumerate(slug_parts):
-            slug_parts[i] = slugify(part, allow_unicode=True)            
-        permalink = "/%s" % "/".join(slug_parts)
+        permalink = f"/{slugify(self.title or '', allow_unicode=True)}"
         if self.parent:
-            permalink = f"{self.parent.permalink}{permalink}"
+            permalink = f"/{self.parent.permalink}{permalink}"
+        set_nofallbacks(self, "permalink", permalink)
         qs = UrlNode.objects.exclude(pk=getattr(self.url_node or object, "pk", None))
         if safe and qs.filter(permalink=permalink).exists():
             permalink = "/".join(
@@ -333,7 +367,10 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def save(self, *args, **kwargs) -> None:
         with transaction.atomic():
             self._update_url_node()
-            return super().save(*args, **kwargs)
+            super().save(*args, **kwargs)
+            self.__cached_db_instance = None
+            for lang_p_field in UrlNode.LANG_PERMALINK_FIELDS:
+                hasattr(self, f"__{lang_p_field}") and delattr(self, f"__{lang_p_field}")
 
     @classmethod
     def get(cls, request, *args, **kwargs) -> "AbstractPage":
@@ -386,7 +423,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
                 node = UrlNode.objects.get(permalink="/")
             return node.page, False
         except UrlNode.DoesNotExist:
-            return cls.get_or_create(None, slug="")
+            return cls.get_or_create(None, permalink="/")
 
     @classmethod
     def get_or_404(cls, request, *args, **kwargs) -> "AbstractPage":

camomilla/serializers/fields/__init__.py

@@ -1,7 +1,7 @@
 from django.db import models
 from rest_framework import serializers
 
-from camomilla import structured
+from structured.fields import StructuredJSONField as ModelStructuredJSONField
 
 from .json import StructuredJSONField
 from .file import FileField, ImageField
@@ -16,6 +16,6 @@ class FieldsOverrideMixin:
         **serializers.ModelSerializer.serializer_field_mapping,
         models.FileField: FileField,
         models.ImageField: ImageField,
-        structured.StructuredJSONField: StructuredJSONField,
+        ModelStructuredJSONField: StructuredJSONField,
     }
     serializer_related_field = RelatedField

camomilla/serializers/fields/json.py

@@ -3,10 +3,11 @@ from rest_framework import serializers
 from rest_framework.utils import model_meta
 from typing import TYPE_CHECKING, Any, Union, Dict, List
 
-from camomilla.structured.utils import pointed_setter
+from camomilla.utils.setters import pointed_setter
 
 if TYPE_CHECKING:
-    from camomilla.structured import BaseModel
+    from structured.pydantic.models import BaseModel
+
 
 
 class StructuredJSONField(serializers.JSONField):

camomilla/serializers/mixins/__init__.py

@@ -3,11 +3,10 @@ from django.conf import settings as django_settings
 from django.db.models.aggregates import Max
 from django.db.models.functions import Coalesce
 from django.utils import translation
-from modeltranslation.settings import AVAILABLE_LANGUAGES
-from modeltranslation.utils import build_localized_fieldname
 from rest_framework import serializers
 from rest_framework.utils import model_meta
 
+from camomilla.models import UrlNode
 from camomilla.fields import ORDERING_ACCEPTED_FIELDS
 from camomilla.serializers.fields.related import RelatedField
 from camomilla.serializers.utils import build_standard_model_serializer
@@ -169,12 +168,6 @@ class AbstractPageMixin(serializers.ModelSerializer):
     def get_breadcrumbs(self, instance: "AbstractPage"):
         return instance.breadcrumbs
 
-    LANG_PERMALINK_FIELDS = [
-        build_localized_fieldname("permalink", lang)
-        for lang in AVAILABLE_LANGUAGES
-        if settings.ENABLE_TRANSLATIONS
-    ]
-
     @property
     def translation_fields(self):
         return super().translation_fields + ["permalink"]
@@ -186,15 +179,15 @@ class AbstractPageMixin(serializers.ModelSerializer):
             return super().get_default_field_names(*args)
         return (
             [f for f in super().get_default_field_names(*args) if f != "url_node"]
-            + self.LANG_PERMALINK_FIELDS
+            + UrlNode.LANG_PERMALINK_FIELDS
             + ["permalink"]
         )
 
     def build_field(self, field_name, info, model_class, nested_depth):
-        if field_name in self.LANG_PERMALINK_FIELDS + ["permalink"]:
+        if field_name in UrlNode.LANG_PERMALINK_FIELDS + ["permalink"]:
             return serializers.CharField, {
-                "source": "url_node.%s" % field_name,
-                "read_only": True,
+                "required": False,
+                "allow_blank": True,
             }
         return super().build_field(field_name, info, model_class, nested_depth)
 

camomilla/serializers/validators.py

@@ -8,7 +8,7 @@ from camomilla.utils.translation import get_nofallbacks, set_nofallbacks
 
 
 class UniquePermalinkValidator:
-    message = _("This slug generates a non-unique permalink.")
+    message = _("There is an other page with same permalink.")
 
     requires_context = True
 
@@ -29,13 +29,17 @@ class UniquePermalinkValidator:
             instance, parent_page_field, None
         )
         for language in activate_languages():
-            f_name = build_localized_fieldname("slug", language)
-            slug = value.get(f_name, instance and get_nofallbacks(instance, "slug"))
+            autopermalink_f = build_localized_fieldname("autopermalink", language)
+            f_name = build_localized_fieldname("permalink", language)
+            permalink = value.get(f_name, instance and get_nofallbacks(instance, "permalink"))
+            permalink = UrlNode.sanitize_permalink(permalink)
+            autopermalink = value.get(autopermalink_f, instance and get_nofallbacks(instance, "autopermalink"))
+            if autopermalink:
+                continue
             fake_instance = serializer.Meta.model()
-            set_nofallbacks(fake_instance, "slug", slug)
+            set_nofallbacks(fake_instance, "permalink", permalink)
             if parent_page:
                 set_nofallbacks(fake_instance, parent_page_field, parent_page)
-            permalink = fake_instance.generate_permalink(safe=False)
             qs = UrlNode.objects.exclude(**exclude_kwargs)
             if qs.filter(permalink=permalink).exists():
                 errors[f_name] = self.message

camomilla/settings.py

@@ -79,10 +79,6 @@ TEMPLATE_CONTEXT_FILES = pointed_getter(
     django_settings, "CAMOMILLA.RENDER.TEMPLATE_CONTEXT_FILES", []
 )
 
-STRUCTURED_FIELD_CACHE_ENABLED = pointed_getter(
-    django_settings, "CAMOMILLA.STRUCTURED_FIELD.CACHE_ENABLED", True
-)
-
 DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG)
 
 # camomilla settings example

camomilla/theme/__init__.py

@@ -1 +1 @@
-__version__ = "6.0.0-beta.13"
+__version__ = "6.0.0-beta.15"

camomilla/theme/admin.py

@@ -26,7 +26,7 @@ class UserProfileAdmin(admin.ModelAdmin):
 class ArticleAdminForm(forms.ModelForm):
     class Meta:
         model = Article
-        exclude = ("slug",)
+        fields = "__all__"
         widgets = {"content": CKEditorUploadingWidget}
 
 

camomilla/translation.py

@@ -16,7 +16,7 @@ class SeoMixinTranslationOptions(TranslationOptions):
 
 
 class AbstractPageTranslationOptions(SeoMixinTranslationOptions):
-    fields = ("breadcrumbs_title", "slug", "status", "indexable", "template_data")
+    fields = ("breadcrumbs_title", "autopermalink", "status", "indexable", "template_data")
 
 
 @register(Article)

camomilla/utils/setters.py

@@ -0,0 +1,37 @@
+from typing import Sequence
+from .getters import pointed_getter
+
+
+def set_key(data, key, val):
+    if isinstance(data, Sequence):
+        key = int(key)
+        if key < len(data):
+            data[key] = val
+        else:
+            data.append(val)
+        return data
+    elif isinstance(data, dict):
+        data[key] = val
+    else:
+        setattr(data, key, val)
+    return data
+
+
+def get_key(data, key, default):
+    if isinstance(data, Sequence):
+        try:
+            return data[int(key)]
+        except IndexError:
+            return default
+    return pointed_getter(data, key, default)
+
+
+def pointed_setter(data, path, value):
+    path = path.split(".")
+    key = path.pop(0)
+    if not len(path):
+        return set_key(data, key, value)
+    default = [] if path[0].isdigit() else {}
+    return set_key(
+        data, key, pointed_setter(get_key(data, key, default), ".".join(path), value)
+    )

camomilla/views/menus.py

@@ -80,5 +80,4 @@ class MenuViewSet(BaseModelViewset):
     def search_urlnode(self, request, *args, **kwargs):
         url_node = request.GET.get("q", "")
         qs = UrlNode.objects.filter(permalink__icontains=url_node).order_by("permalink")
-        print(get_language())
         return Response(BasicUrlNodeSerializer(qs, many=True).data)

{django_camomilla_cms-6.0.0b13.dist-info → django_camomilla_cms-6.0.0b15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-camomilla-cms
-Version: 6.0.0b13
+Version: 6.0.0b15
 Summary: Django powered cms
 Author-email: Lotrèk <dimmitutto@lotrek.it>
 License: MIT
@@ -20,10 +20,9 @@ Requires-Dist: djangorestframework <4.0.0,>=3.10.0
 Requires-Dist: django-admin-interface <1.0.0,>=0.26.0
 Requires-Dist: Pillow <10.0.0,>=6.2.0
 Requires-Dist: django-ckeditor <7.0.0,>=5.7.1
+Requires-Dist: django-structured-json-field ==0.2.0
 Requires-Dist: python-magic <0.5,>=0.4
-Requires-Dist: django-jsonform ~=2.19.0
 Requires-Dist: Django >=3.2
-Requires-Dist: pydantic ~=2.2.1
 
 # camomilla django cms [![PyPI](https://img.shields.io/pypi/v/django-camomilla-cms?style=flat-square)](https://pypi.org/project/django-camomilla-cms) ![Codecov](https://img.shields.io/codecov/c/github/lotrekagency/camomilla?style=flat-square) ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/lotrekagency/camomilla/Test,%20Coverage%20and%20Release?style=flat-square) [![GitHub](https://img.shields.io/github/license/lotrekagency/camomilla?style=flat-square)](./LICENSE)