lino 24.11.1__py3-none-any.whl → 25.1.0__py3-none-any.whl

lino/modlib/memo/parser.py

@@ -159,7 +159,7 @@ class Parser:
                 )
         self.commands[cmdname] = func
 
-    def register_django_model(self, name, model, cmd=None):
+    def register_django_model(self, name, model, cmd=None, rnd=None):
         """
         Register the given string `name` as command for referring to
         database rows of the given Django database model `model`.
@@ -172,6 +172,8 @@ class Parser:
         # if rnd is None:
         #     def rnd(obj):
         #         return "[{} {}] ({})".format(name, obj.id, title(obj))
+        if rnd is None:
+            rnd = model.memo2html
         if cmd is None:
 
             def cmd(ar, s, cmdname, mentions, context):
@@ -200,7 +202,8 @@ class Parser:
                 #     caption = obj.get_memo_title()
                 # txt = "#{0}".format(obj.id)
                 # kw.update(title=title(obj))
-                return obj.memo2html(ar, text)
+                # return obj.memo2html(ar, text)
+                return rnd(obj, ar, text)
                 # e = ar.obj2html(obj, txt, **kw)
                 # # return str(ar)
                 # return etree.tostring(e)
@@ -210,7 +213,8 @@ class Parser:
         #         pass
 
         cmd._for_model = model
-        cmd.__doc__ = """
+        if cmd.__doc__ is None:
+            cmd.__doc__ = rnd.__doc__ or """
 Insert a reference to the specified {}.
 
 The first argument is mandatory and specifies the primary key.

lino/modlib/notify/mixins.py

@@ -1,7 +1,7 @@
-# Copyright 2016-2022 Rumma & Ko Ltd
+# Copyright 2016-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
-from lino.utils.html import E, tostring
+from lino.utils.html import E, tostring, format_html, mark_safe
 from lino.api import dd, rt, _
 
 # PUBLIC_GROUP = "all_users_channel"
@@ -27,21 +27,21 @@ class ChangeNotifier(dd.Model):
     def get_change_body(self, ar, cw):
         ctx = dict(user=ar.user, what=ar.obj2htmls(self))
         if cw is None:
-            html = _("{user} created {what}").format(**ctx)
+            html = format_html(_("{user} created {what}"), **ctx)
             html += self.get_change_info(ar, cw)
-            html = "<p>{}</p>.".format(html)
+            html = format_html("<p>{}</p>.", html)
         else:
             items = list(cw.get_updates_html(["_user_cache"]))
             if len(items) == 0:
                 return
-            html = _("{user} modified {what}").format(**ctx)
-            html = "<p>{}:</p>".format(html)
+            txt = format_html(_("{user} modified {what}"), **ctx)
+            html = format_html("<p>{}:</p>", txt)
             html += tostring(E.ul(*items))
             html += self.get_change_info(ar, cw)
-        return "<div>{}</div>".format(html)
+        return format_html("<div>{}</div>", html)
 
     def get_change_info(self, ar, cw):
-        return ""
+        return mark_safe("")
 
     if dd.is_installed("notify"):
 

lino/modlib/periods/choicelists.py

@@ -0,0 +1,46 @@
+# -*- coding: UTF-8 -*-
+# Copyright 2008-2024 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+
+from django.utils.translation import gettext_lazy as _
+
+from lino.api import dd
+from lino.utils import ONE_DAY
+
+
+class PeriodType(dd.Choice):
+    ref_template = None
+
+    def __init__(self, value, text, duration, ref_template):
+        super().__init__(value, text, value)
+        self.ref_template = ref_template
+        self.duration = duration
+
+class PeriodTypes(dd.ChoiceList):
+    item_class = PeriodType
+    verbose_name = _("Period type")
+    verbose_name_plural = _("Period types")
+    column_names = "value text duration ref_template"
+
+    @dd.displayfield(_("Duration"))
+    def duration(cls, p, ar):
+        return str(p.duration)
+
+    @dd.displayfield(_("Template for reference"))
+    def ref_template(cls, p, ar):
+        return p.ref_template
+
+add = PeriodTypes.add_item
+# value/names,  text, duration, ref_template
+add("month",     _("Month"),     1, "{month:0>2}")
+add("quarter",   _("Quarter"),   3, "Q{period}")
+add("trimester", _("Trimester"), 4, "T{period}")
+add("semester",  _("Semester"),  6, "S{period}")
+
+
+class PeriodStates(dd.Workflow):
+    pass
+
+add = PeriodStates.add_item
+add('10', _("Open"), 'open')
+add('20', _("Closed"), 'closed')

lino/modlib/periods/mixins.py

@@ -2,14 +2,40 @@
 # Copyright 2008-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
+import datetime
 from django.db import models
 from django.utils.translation import gettext_lazy as _
 
 from lino.api import dd, rt
 from lino import mixins
 from lino.mixins import Referrable
+from lino.utils import ONE_DAY
 
 from lino.modlib.office.roles import OfficeStaff
+from lino.modlib.system.choicelists import DurationUnits
+
+
+def get_range_for_date(date):
+    """
+    Return the default start and end date of the period to create for the given
+    date.
+    """
+    pt = dd.plugins.periods.period_type
+    month = date.month
+    year = date.year
+    month -= dd.plugins.periods.start_month
+    if month < 0:
+        month += 12
+        year -= 1
+    period = int(month / pt.duration)
+    month = dd.plugins.periods.start_month + period * pt.duration
+    if month > 12:
+        month -= 12
+        year += 1
+    sd = datetime.date(year, month, 1)
+    # ed = sd.replace(month=sd.month + pt.duration + 1, 1) - ONE_DAY
+    ed = DurationUnits.months.add_duration(sd, pt.duration) - ONE_DAY
+    return (sd, ed)
 
 
 class PeriodRange(dd.Model):

lino/modlib/periods/models.py

@@ -8,52 +8,17 @@ from django.utils.translation import gettext_lazy as _
 
 from lino.api import dd
 from lino import mixins
-from lino.utils import last_day_of_month, ONE_DAY
+from lino.utils import ONE_DAY
 from lino.mixins.periods import DateRange
 from lino.mixins import Referrable
 
 from lino.modlib.office.roles import OfficeStaff
+from .mixins import get_range_for_date
+from .choicelists import PeriodTypes, PeriodStates
 
 NEXT_YEAR_SEP = "/"
 YEAR_PERIOD_SEP = "-"
 
-class PeriodType(dd.Choice):
-    ref_template = None
-    ref_template = None
-
-    def __init__(self, value, text, duration, ref_template):
-        super().__init__(value, text, value)
-        self.ref_template = ref_template
-        self.duration = duration
-
-class PeriodTypes(dd.ChoiceList):
-    item_class = PeriodType
-    verbose_name = _("Period type")
-    verbose_name_plural = _("Period types")
-    column_names = "value text duration ref_template"
-
-    @dd.displayfield(_("Duration"))
-    def duration(cls, p, ar):
-        return str(p.duration)
-
-    @dd.displayfield(_("Template for reference"))
-    def ref_template(cls, p, ar):
-        return p.ref_template
-
-add = PeriodTypes.add_item
-# value/names,  text, duration, ref_template
-add("month",     _("Month"),     1, "{month:0>2}")
-add("quarter",   _("Quarter"),   3, "Q{period}")
-add("trimester", _("Trimester"), 4, "T{period}")
-add("semester",  _("Semester"),  6, "S{period}")
-
-
-class PeriodStates(dd.Workflow):
-    pass
-
-add = PeriodStates.add_item
-add('10', _("Open"), 'open')
-add('20', _("Closed"), 'closed')
 
 
 class StoredYear(DateRange, Referrable):
@@ -120,7 +85,7 @@ class StoredPeriod(DateRange, Referrable):
     preferred_foreignkey_width = 10
 
     state = PeriodStates.field(default='open')
-    year = dd.ForeignKey('periods.StoredYear', blank=True, null=True)
+    year = dd.ForeignKey('periods.StoredYear', blank=True, null=True, related_name="periods")
     remark = models.CharField(_("Remark"), max_length=250, blank=True)
 
     @classmethod
@@ -197,10 +162,8 @@ class StoredPeriod(DateRange, Referrable):
         ref = date2ref(date)
         obj = cls.get_by_ref(ref, None)
         if obj is None:
-            obj = cls(
-                ref=ref,
-                start_date=date.replace(day=1),
-                end_date=last_day_of_month(date))
+            sd, ed = get_range_for_date(date)
+            obj = cls(ref=ref, start_date=sd, end_date=ed)
             obj.full_clean()
             obj.save()
         return obj
@@ -208,7 +171,7 @@ class StoredPeriod(DateRange, Referrable):
     def full_clean(self, *args, **kwargs):
         if self.start_date is None:
             self.start_date = dd.today().replace(day=1)
-        if not self.year:
+        if not self.year_id:
             self.year = StoredYear.get_or_create_from_date(self.start_date)
         super().full_clean(*args, **kwargs)
 
@@ -218,10 +181,19 @@ class StoredPeriod(DateRange, Referrable):
             # "{0} {1} (#{0})".format(self.pk, self.year)
         return self.ref
 
+    # def get_str_words(self, ar):
+    #     # if ar.is_obvious_field("year"):
+    #     if self.year.covers_date(dd.today()):
+    #         # yield self.nickname
+    #         yield f"{dd.plugins.periods.period_name} {self.nickname}"
+    #     else:
+    #         yield str(self)
+
     @property
     def nickname(self):
         if self.year.covers_date(dd.today()):
-            if len(parts := self.ref.split(YEAR_PERIOD_SEP)) == 2:
+            if self.ref and len(parts := self.ref.split(YEAR_PERIOD_SEP)) == 2:
+                # return "{} {}".format(dd.plugins.periods.period_name, parts[1])
                 return parts[1]
         return self.ref
 

lino/modlib/publisher/choicelists.py

@@ -51,12 +51,9 @@ class PublisherBuildMethod(JinjaBuildMethod):
             )
             context = elem.get_printable_context(ar)
             html = tpl.render(context)
-            self.html2file(html, filename)
+            self.html2file(html, filename, context)
             return os.path.getmtime(filename)
 
-    def html2file(self, html, filename):
-        raise NotImplementedError()
-
 
 BuildMethods.add_item_instance(PublisherBuildMethod())
 

lino/modlib/uploads/mixins.py

@@ -7,10 +7,10 @@ import shutil
 import uuid
 from pathlib import Path
 
-from rstgen.sphinxconf.sigal_image import parse_image_spec
-from rstgen.sphinxconf.sigal_image import Standard, Thumb, Tiny, Wide, Solo, Duo, Trio
-SMALL_FORMATS = (Thumb, Tiny, Duo, Trio)
-
+# from rstgen.sphinxconf.sigal_image import parse_image_spec
+# from rstgen.sphinxconf.sigal_image import Standard, Thumb, Tiny, Wide, Solo, Duo, Trio
+# SMALL_FORMATS = (Thumb, Tiny, Duo, Trio)
+#
 from django.db import models
 from django.conf import settings
 from django.core.files.storage import default_storage
@@ -198,36 +198,36 @@ class UploadBase(Commentable, GalleryViewable):
             return text
         return E.a(text, href=mf.get_download_url(), target="_blank")
 
-    def memo2html(self, ar, text, **ctx):
-        mf = self.get_media_file()
-        if mf is None:
-            return format_html("<em>{}</em>", text or str(self))
-        ctx.update(src=mf.get_download_url())
-        ctx.update(href=ar.renderer.obj2url(ar, self))
-        small_url = mf.get_image_url()
-        if small_url is None or small_url == mf.url:  # non-previewable mimetype
-            if not text:
-                text = str(self)
-            ctx.update(text=text)
-            tpl = '(<a href="{src}" target="_blank">{text}</a>'
-            tpl += '| <a href="{href}">detail</a>)'
-            return format_html(tpl, **ctx)
-
-        fmt = parse_image_spec(text, **ctx)
-        if isinstance(fmt, SMALL_FORMATS):
-            fmt.context.update(src=small_url)
-
-        if not fmt.context["caption"]:
-            fmt.context["caption"] = self.description or str(self)
-
-        rv = format_html(
-            '<a href="{href}" target="_blank"><img src="{src}"'
-            + ' style="{style}" title="{caption}"/></a>', **fmt.context)
-        # if ar.renderer.front_end.media_name == 'react':
-        #     return ('<figure class="lino-memo-image"><img src="{src}" ' +
-        #         'style="{style}" title="{caption}"/><figcaption' +
-        #         ' style="text-align: center;">{caption}</figcaption>' +
-        #         '</figure>').format(**kwargs)
-
-        # print("20230325", rv)
-        return rv
+    # def memo2html(self, ar, text, **ctx):
+    #     mf = self.get_media_file()
+    #     if mf is None:
+    #         return format_html("<em>{}</em>", text or str(self))
+    #     ctx.update(src=mf.get_download_url())
+    #     ctx.update(href=ar.renderer.obj2url(ar, self))
+    #     small_url = mf.get_image_url()
+    #     if small_url is None or small_url == mf.url:  # non-previewable mimetype
+    #         if not text:
+    #             text = str(self)
+    #         ctx.update(text=text)
+    #         tpl = '(<a href="{src}" target="_blank">{text}</a>'
+    #         tpl += '| <a href="{href}">detail</a>)'
+    #         return format_html(tpl, **ctx)
+    #
+    #     fmt = parse_image_spec(text, **ctx)
+    #     if isinstance(fmt, SMALL_FORMATS):
+    #         fmt.context.update(src=small_url)
+    #
+    #     if not fmt.context["caption"]:
+    #         fmt.context["caption"] = self.description or str(self)
+    #
+    #     rv = format_html(
+    #         '<a href="{href}" target="_blank"><img src="{src}"'
+    #         + ' style="{style}" title="{caption}"/></a>', **fmt.context)
+    #     # if ar.renderer.front_end.media_name == 'react':
+    #     #     return ('<figure class="lino-memo-image"><img src="{src}" ' +
+    #     #         'style="{style}" title="{caption}"/><figcaption' +
+    #     #         ' style="text-align: center;">{caption}</figcaption>' +
+    #     #         '</figure>').format(**kwargs)
+    #
+    #     # print("20230325", rv)
+    #     return rv

lino/modlib/uploads/models.py

@@ -14,6 +14,10 @@ from django.utils.text import format_lazy
 from django.utils.html import format_html, mark_safe
 from django.utils.translation import pgettext_lazy as pgettext
 
+from rstgen.sphinxconf.sigal_image import parse_image_spec
+# from rstgen.sphinxconf.sigal_image import Standard, Thumb, Tiny, Wide, Solo, Duo, Trio
+# SMALL_FORMATS = (Thumb, Tiny, Duo, Trio)
+
 from lino.utils.html import E, join_elems
 from lino.api import dd, rt, _
 from lino.modlib.gfks.mixins import Controllable
@@ -112,7 +116,7 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
         verbose_name = _("Upload file")
         verbose_name_plural = _("Upload files")
 
-    memo_command = "file"
+    memo_command = "upload"
 
     upload_area = UploadAreas.field(default="general")
     type = dd.ForeignKey("uploads.UploadType", blank=True, null=True)
@@ -129,7 +133,8 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
         elif self.file:
             s = filename_leaf(self.file.name)
         elif self.library_file:
-            s = "{}:{}".format(self.volume.ref, self.library_file)
+            s = filename_leaf(self.library_file)
+            # s = "{}:{}".format(self.volume.ref, self.library_file)
         else:
             s = str(self.id)
         if self.type:
@@ -158,12 +163,13 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
 
     def get_memo_command(self, ar=None):
         if dd.is_installed("memo"):
-            cmd = f"[{self.memo_command} {self.pk}"
-            if self.description:
-                cmd += " " + self.description + "]"
-            else:
-                cmd += "]"
-            return cmd
+            return f"[{self.memo_command} {self.pk} {self}]"
+            # cmd = f"[{self.memo_command} {self.pk}"
+            # if self.description:
+            #     cmd += " " + self.description + "]"
+            # else:
+            #     cmd += "]"
+            # return cmd
         return None
 
     def get_real_file_size(self):
@@ -180,16 +186,6 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
             df.add("camera_stream")
         return df
 
-    def full_clean(self):
-        super().full_clean()
-        for i in self.check_previews(True):
-            pass
-
-    def check_previews(self, fix):
-        for p in [rt.models.uploads.previewer]:
-            for i in p.check_preview(self, fix):
-                yield i
-
     @dd.displayfield(_("Description"))
     def description_link(self, ar):
         s = str(self)
@@ -214,6 +210,13 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
         super().full_clean(*args, **kw)
         if self.type is not None:
             self.upload_area = self.type.upload_area
+        for i in self.check_previews(True):
+            pass
+
+    def check_previews(self, fix):
+        p = rt.models.uploads.previewer
+        for i in p.check_preview(self, fix):
+            yield i
 
     def get_gallery_item(self, ar):
         d = super().get_gallery_item(ar)
@@ -415,3 +418,50 @@ def before_analyze(sender, **kwargs):
 from .ui import *
 
 # raise Exception("20241112")
+
+
+@dd.receiver(dd.post_startup)
+def setup_memo_commands(sender=None, **kwargs):
+    # Adds another memo command for Upload
+    # See :doc:`/specs/memo`
+
+    if not sender.is_installed('memo'):
+        return
+
+    def file2html(self, ar, text, **ctx):
+        """
+        Insert an image tag of the specified upload file.
+        """
+        mf = self.get_media_file()
+        if mf is None:
+            return format_html("<em>{}</em>", text or str(self))
+        ctx.update(src=mf.get_download_url())
+        ctx.update(href=ar.renderer.obj2url(ar, self))
+        if not mf.is_image():
+            if not text:
+                text = str(self)
+            ctx.update(text=text)
+            tpl = '(<a href="{src}" target="_blank">{text}</a>'
+            tpl += '| <a href="{href}">Detail</a>)'
+            return format_html(tpl, **ctx)
+
+        fmt = parse_image_spec(text, **ctx)
+        # TODO: When an image is inserted with format "wide", we should not use
+        # the thumbnail but the original file. But for a PDF file we must always
+        # use the img_src because the download_url is not an image.
+        fmt.context.update(src=mf.get_image_url())
+        # if isinstance(fmt, SMALL_FORMATS):
+        #     fmt.context.update(src=img_src)
+        # else:
+        #     print(f"20241116 {fmt} {fmt.context}")
+
+        if not fmt.context["caption"]:
+            fmt.context["caption"] = self.description or str(self)
+
+        rv = format_html(
+            '<a href="{href}" target="_blank"><img src="{src}"'
+            + ' style="{style}" title="{caption}"/></a>', **fmt.context)
+        return rv
+
+    mp = sender.plugins.memo.parser
+    mp.register_django_model('file', rt.models.uploads.Upload, rnd=file2html)

lino/modlib/uploads/utils.py

@@ -32,6 +32,12 @@ class UploadMediaFile:
             url += ".png"
         return previewer.base_dir + "/" + url
 
+    def is_image(self):
+        # whether this can be rendered in an <img> tag
+        if self.get_image_name() is None:
+            return False
+        return self.suffix in previewer.PREVIEW_SUFFIXES
+
     def get_mimetype_description(self):
         if self.suffix == ".pdf":
             return _("PDF file")

lino/modlib/users/mixins.py

@@ -159,13 +159,16 @@ class My(dbtables.Table):
 
     @classmethod
     def get_actor_label(self):
+        if self._label is not None:
+            return self._label
         if self.model is None:
-            return self._label or self.__name__
-        # return self._label or \
-        #     _("My %s") % self.model._meta.verbose_name_plural
-        return self._label or format_lazy(
-            _("My {}"), self.model._meta.verbose_name_plural
-        )
+            return self.__name__
+        return format_lazy(_("My {}"), self.model._meta.verbose_name_plural)
+
+    @classmethod
+    def setup_request(cls, ar):
+        super().setup_request(ar)
+        ar.obvious_fields.add("user")
 
     @classmethod
     def param_defaults(self, ar, **kw):

lino/modlib/weasyprint/choicelists.py

@@ -1,8 +1,9 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2016-2020 Rumma & Ko Ltd
+# Copyright 2016-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 import os
+from pathlib import Path
 from copy import copy
 
 try:
@@ -10,11 +11,20 @@ try:
 except ImportError:
     HTML = None
 
+try:
+    import bulma
+    from weasyprint import CSS
+    BULMA_CSS = Path(bulma.__file__).parent / "static/bulma/css/style.min.css"
+    assert BULMA_CSS.exists()
+except ImportError:
+    BULMA_CSS = None
+
+
+
 from django.conf import settings
 from django.utils import translation
 
 from lino.api import dd
-
 from lino.modlib.jinja.choicelists import JinjaBuildMethod
 from lino.modlib.printing.choicelists import BuildMethods
 
@@ -29,17 +39,17 @@ class WeasyHtmlBuildMethod(WeasyBuildMethod):
     target_ext = ".html"
     name = "weasy2html"
 
-    def html2file(self, html, filename):
-        open(filename, "w").write(html)
-
 
 class WeasyPdfBuildMethod(WeasyBuildMethod):
     target_ext = ".pdf"
     name = "weasy2pdf"
 
-    def html2file(self, html, filename):
+    def html2file(self, html, filename, context):
         pdf = HTML(string=html)
-        pdf.write_pdf(filename)
+        if BULMA_CSS and context.get('use_bulma_css', False):
+            pdf.write_pdf(filename, stylesheets=[CSS(filename=BULMA_CSS)])
+        else:
+            pdf.write_pdf(filename)
 
 
 add = BuildMethods.add_item_instance

lino/utils/choosers.py

@@ -108,6 +108,7 @@ class ChoiceConverter(Converter):
 
     def convert(self, **kw):
         value = kw.get(self.field.name)
+        # print(f"20241203 convert {self.field.name}")
 
         if value is not None:
             if not isinstance(value, self.field.choicelist.item_class):
@@ -190,7 +191,16 @@ class ManyToManyConverter(LookupConverter):
 
 def make_converter(f, lookup_fields={}):
     from lino.core.gfks import GenericForeignKey
+    from lino.core.fields import VirtualField
 
+    # if f.name == 'rating_type':
+    #     print(f"20241203 {f.__class__}")
+
+    # selector = f
+
+    if isinstance(f, VirtualField):
+        # print(f"20241203 {f.name} {f.return_type.name}")
+        f = f.return_type
     if isinstance(f, models.ForeignKey):
         return ForeignKeyConverter(f, lookup_fields.get(f.name, "pk"))
     if isinstance(f, GenericForeignKey):
@@ -206,8 +216,7 @@ def make_converter(f, lookup_fields={}):
     from lino.core import choicelists
 
     if isinstance(f, choicelists.ChoiceListField):
-        # if f.name == 'p_book':
-        # print "20131012 b", f
+        # print(f"20241203c {f.__class__}")
         return ChoiceConverter(f)
 
 
@@ -244,18 +253,22 @@ class Chooser(FieldChooser):
         from lino.core.gfks import is_foreignkey
         from lino.core.choicelists import ChoiceListField
 
-        if isinstance(field, ChoiceListField):
+        selector = field
+        if isinstance(field, fields.VirtualField):
+            selector = field.return_type
+
+        if isinstance(selector, ChoiceListField):
             self.simple_values = getattr(meth, "simple_values", False)
             self.instance_values = getattr(meth, "instance_values", True)
             self.force_selection = getattr(
                 meth, "force_selection", self.force_selection
             )
-        elif is_foreignkey(field):
-            pass
-        elif isinstance(field, fields.VirtualField) and isinstance(
-            field.return_type, models.ForeignKey
-        ):
+        elif is_foreignkey(selector):
             pass
+        # elif isinstance(field, fields.VirtualField) and isinstance(
+        #     field.return_type, models.ForeignKey
+        # ):
+        #     pass
         else:
             self.simple_values = getattr(meth, "simple_values", False)
             self.instance_values = getattr(meth, "instance_values", False)

lino/utils/instantiator.py

@@ -210,6 +210,15 @@ def create_and_get(model, **kw):
     o = create(model, **kw)
     return model.objects.get(pk=o.pk)
 
+def make_if_needed(model, **values):
+    qs = model.objects.filter(**values)
+    if qs.count() == 1:
+        pass # ok, nothing to do
+    elif qs.count() == 0:
+        return model(**values)
+    else:
+        raise Exception(f"Multiple {model._meta.verbose_name_plural} for {values}")
+
 
 def _test():
     import doctest