accrete 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

accrete/annotation.py

@@ -0,0 +1,46 @@
+from django.db.models import Field, QuerySet
+from django.db.models.expressions import Func
+from django.db.models.aggregates import Aggregate
+
+
+class Annotation:
+
+    def __init__(
+            self,
+            verbose_name: str,
+            field: type[Field],
+            function: type[Func] | type[Aggregate],
+            help_text: str = '',
+            **kwargs
+    ):
+        self.verbose_name = verbose_name or self
+        self.field = field
+        self.function = function
+        self.help_text = help_text
+        self.__dict__.update(kwargs)
+
+
+class AnnotationModelMixin:
+
+    @classmethod
+    def get_annotations(cls) -> list[dict]:
+        return list({'name': a, 'annotation': getattr(cls, a)} for a in filter(
+            lambda a:
+            not a.startswith('__')
+            and isinstance(getattr(cls, a), Annotation),
+            cls.__dict__
+        ))
+
+
+class AnnotationManagerMixin:
+
+    @staticmethod
+    def add_annotations(queryset: QuerySet):
+        model = queryset.model
+        if not hasattr(model, 'get_annotations'):
+            return queryset
+        return queryset.annotate(**{
+            annotation['name']: annotation['annotation'].function
+            for annotation in model.get_annotations()
+        })
+

accrete/contrib/ui/__init__.py

@@ -4,18 +4,15 @@ from .context import (
     TableContext,
     ListContext,
     FormContext,
-    default_form_actions,
-    Page,
-    ListContent,
-    DetailContent,
-    FormContent,
-    get_list_page,
-    get_detail_page,
+    form_actions,
+    list_page,
+    detail_page,
     cast_param,
     prepare_url_params,
     extract_url_params,
     exclude_params,
-    url_param_str
+    url_param_str,
+    get_table_fields
 )
 from .elements import (
     ClientAction,
@@ -26,7 +23,3 @@ from .elements import (
     TableFieldType,
     Icon
 )
-from .querystring import (
-    load_querystring,
-    build_querystring,
-)

accrete/contrib/ui/context.py

@@ -1,15 +1,20 @@
 import logging
-from typing import TypedDict
 from dataclasses import dataclass, field
-from django.utils.translation import gettext_lazy as _
-from django.shortcuts import resolve_url
+from typing import TypedDict
+from django.utils.translation import gettext_lazy as _t
+from django.db import models
 from django.db.models import Model, QuerySet
 from django.core.paginator import Paginator
 from django.core import paginator
 from django.forms import Form, ModelForm
-from .elements import ClientAction, BreadCrumb, TableField
+from accrete.utils.models import get_related_model
+from accrete.annotation import Annotation
+from .elements import (
+    ClientAction, BreadCrumb, TableField, TableFieldType, TableFieldAlignment
+)
 from .filter import Filter
 
+
 _logger = logging.getLogger(__name__)
 
 DEFAULT_PAGINATE_BY = 40
@@ -22,31 +27,55 @@ class DetailPagination(TypedDict):
     total_objects: int
 
 
-class TableContext(TypedDict, total=False):
+@dataclass(kw_only=True)
+class Context:
+
+    title: str = ''
+    breadcrumbs: list[BreadCrumb] = field(default_factory=list)
+    actions: list[ClientAction] = field(default_factory=list)
+    kwargs: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        for key, value in self.kwargs.items():
+            setattr(self, key, value)
+
+    def dict(self):
+        return {
+            attr: getattr(self, attr, '') for attr
+            in filter(lambda x: not x.startswith('_'), self.__dict__)
+        }
+
+
+@dataclass
+class TableContext(Context):
 
-    title: str
     object_label: str
-    object_param_str: str
     fields: list[TableField]
-    breadcrumbs: list[BreadCrumb]
-    actions: list[ClientAction]
     list_page: paginator.Page
     pagination_param_str: str
     endless_scroll: bool
     filter: Filter
+    object_param_str: str = field(default='', kw_only=True)
 
 
-class ListContext(TypedDict):
+@dataclass
+class ListContext(Context):
 
-    title: str
     object_label: str
     object_param_str: str
-    breadcrumbs: list[BreadCrumb]
-    actions: list[ClientAction]
     list_page: paginator.Page
     pagination_param_str: str
-    endless_scroll: bool
     filter: Filter
+    endless_scroll: bool = True
+    column_height: int = 4
+    column_width: int = 12
+
+    def __post_init__(self):
+        super().__post_init__()
+        if self.column_width not in range(1, 13):
+            _logger.warning(
+                'ListContext parameter column_width should be in range 1 - 12'
+            )
 
 
 class DetailContext(TypedDict, total=False):
@@ -59,7 +88,7 @@ class DetailContext(TypedDict, total=False):
     actions: list[ClientAction]
 
 
-class FormContext(TypedDict):
+class FormContext(TypedDict, total=False):
 
     title: str
     breadcrumbs: list[BreadCrumb]
@@ -68,204 +97,9 @@ class FormContext(TypedDict):
     actions: list[ClientAction]
 
 
-# @dataclass
-# class ListContext:
-#
-#     title: str
-#     actions: list[ClientAction] = field(default_factory=list)
-#     object_label: str = ''
-#     fields: list[TableField] = field(default_factory=list)
-#     page: paginator.Page = None
-#     list_pagination: bool = True
-#     endless_scroll: bool = True
-#     params: dict = field(default_factory=dict)
-#     filter: Filter = None
-#
-#     def dict(self):
-#         return {
-#             "title": self.title,
-#             "actions": self.actions,
-#             "object_label": self.object_label,
-#             "fields": self.fields,
-#             "page": self.page,
-#             "list_pagination": self.list_pagination,
-#             "endless_scroll": self.endless_scroll,
-#             "params": self.params,
-#             "filter": self.filter
-#         }
-
-
-class GenericContent:
-
-    def __init__(self, *args, **kwargs):
-        self.page: Page | None = None
-
-    def dict(self):
-        return {}
-
-
-class ListContent:
-
-    def __init__(
-            self, queryset: QuerySet, paginate_by: int = DEFAULT_PAGINATE_BY,
-            page_number: int = 1, filter_obj: Filter = None,
-            endless_scroll: bool = True, fields: list[TableField] = None,
-            object_label: str = None, object_url_params: dict = None
-    ):
-        self.queryset = queryset
-        self.paginate_by = paginate_by or DEFAULT_PAGINATE_BY
-        self.page_number = page_number
-        self.filter = filter_obj
-        self.endless_scroll = endless_scroll
-        self.fields = fields or []
-        self.object_label = object_label or _('Name')
-        self.object_url_params = object_url_params or {}
-        self.page: Page | None = None
-
-    def get_page_number(self, paginator):
-        if self.page_number < 1:
-            return 1
-        if self.page_number > paginator.num_pages:
-            return paginator.num_pages
-        return self.page_number
-
-    def dict(self):
-        paginator = Paginator(self.queryset, self.paginate_by)
-        page = paginator.page(self.get_page_number(paginator))
-        context = {
-            'page': page,
-            'object_label': self.object_label,
-            'object_url_params': url_param_str(prepare_url_params(self.object_url_params)),
-            'fields': self.fields,
-            'list_pagination': True if self.paginate_by > 0 else False,
-            'filter': self.filter,
-            'endless_scroll': self.endless_scroll
-        }
-        return context
-
-
-class DetailContent:
-
-    def __init__(
-            self, obj: Model | type[Model], queryset: QuerySet = None,
-    ):
-        self.obj = obj
-        self.queryset = queryset
-        self.page: Page | None = None
-
-    def get_detail_pagination(self):
-        return detail_pagination(self.queryset, self.obj)
-
-    def dict(self):
-        ctx = {
-            'object': self.obj,
-            'detail_pagination': False,
-        }
-        if self.queryset:
-            ctx.update(self.get_detail_pagination())
-        return ctx
-
-
-class FormContent:
-
-    def __init__(
-            self, model: Model | type[Model], form: Form | ModelForm,
-            form_id: str = 'form', add_default_actions: bool = True,
-            discard_url: str = None
-    ):
-        self.model = model
-        self.form = form
-        self.form_id = form_id
-        self.add_default_actions = add_default_actions
-        self.discard_url = discard_url
-        self.page: Page | None = None
-
-    def add_default_form_actions(self):
-        actions = [
-            ClientAction(
-                name=_('Save'),
-                submit=True,
-                class_list=['is-success'],
-                form_id=self.form_id
-            )
-        ]
-        try:
-            url = self.discard_url or (self.model.pk and self.model.get_absolute_url())
-        except TypeError:
-            raise TypeError(
-                'Supply the discard_url parameter if Form is called '
-                'with a model class instead of an instance.'
-            )
-        except AttributeError as e:
-            _logger.error(
-                'Supply the discard_url parameter if Form is '
-                'called with a model instance that has the get_absolute_url '
-                'method not defined.'
-            )
-            raise e
-
-        actions.append(
-            ClientAction(
-                name=_('Discard'),
-                url=url,
-            )
-        )
-        if self.page:
-            self.page.actions = actions.extend(self.page.actions)
-
-    def get_title(self):
-        try:
-            int(self.model.pk)
-            return _('Edit')
-        except TypeError:
-            return _('Add')
-        except Exception as e:
-            _logger.exception(e)
-            return ''
-
-    def dict(self):
-        ctx = {
-            'form': self.form,
-            'form_id': self.form_id,
-        }
-        if self.add_default_actions:
-            self.add_default_form_actions()
-        if self.page and not self.page.title:
-            self.page.title = self.get_title()
-        return ctx
-
-
-class Page:
-
-    def __init__(
-            self, *, title: str = None,
-            content: GenericContent | ListContent | DetailContent | FormContent = None,
-            breadcrumbs: list[BreadCrumb] = None, get_params: dict = None,
-            actions: list[ClientAction] = None,
-    ):
-        self.title = title or ''
-        self.content = content
-        self.breadcrumbs = breadcrumbs or []
-        self.actions = actions or []
-        self.get_params = get_params or {}
-        if self.content:
-            self.content.page = self
-
-    def dict(self):
-        url_params = prepare_url_params(self.get_params)
-        ctx = {
-            'title': self.title,
-            'breadcrumbs': self.breadcrumbs,
-            'actions': self.actions,
-            'url_params': url_params,
-            'url_params_str': url_param_str(url_params)
-        }
-        if self.content:
-            ctx.update(self.content.dict())
-        return ctx
-
-
 def cast_param(params: dict, param: str, cast_to: callable, default):
+    if param not in params:
+        return default
     try:
         return cast_to(params.get(param, default))
     except Exception as e:
@@ -281,7 +115,7 @@ def url_param_str(params: dict, extract: list[str] = None) -> str:
     """
     Return a URL Querystring from the given parameters
     If extract is supplied, extract the value from the dictionary and prepare
-    them, so that each value is formatted eg. {'page': '&page=1'}
+    them, so that each value is formatted e.g. {'page': '&page=1'}
     """
     if extract:
         params = prepare_url_params(extract_url_params(params, extract))
@@ -302,12 +136,12 @@ def exclude_params(params: dict, keys: list[str]) -> dict:
     return {key: val for key, val in params.items() if key not in keys}
 
 
-def get_list_page(queryset: QuerySet, paginate_by: int, page_number: int) -> paginator.Page:
+def list_page(queryset: QuerySet, paginate_by: int, page_number: int) -> paginator.Page:
     pages = Paginator(queryset, per_page=paginate_by)
     return pages.page(page_number <= pages.num_pages and page_number or pages.num_pages)
 
 
-def get_detail_page(queryset: QuerySet, obj: Model) -> dict:
+def detail_page(queryset: QuerySet, obj: Model) -> dict:
     if not hasattr(obj, 'get_absolute_url'):
         _logger.warning(
             'Detail pagination disabled for models without the '
@@ -330,16 +164,75 @@ def get_detail_page(queryset: QuerySet, obj: Model) -> dict:
     }
 
 
-def default_form_actions(discard_url: str, form_id: str = 'form') -> list[ClientAction]:
+def form_actions(discard_url: str, form_id: str = 'form') -> list[ClientAction]:
     return [
         ClientAction(
-            name=_('Save'),
+            name=_t('Save'),
             submit=True,
             class_list=['is-success'],
             form_id=form_id,
         ),
         ClientAction(
-            name=_('Discard'),
+            name=_t('Discard'),
             url=discard_url
         )
     ]
+
+
+def get_table_fields(
+        fields: list[str],
+        model: type[Model],
+        field_definition: dict[str | TableField] = None
+) -> list[TableField]:
+
+    def get_alignment(field_attr):
+        number_field_types = (
+            models.DecimalField, models.IntegerField, models.FloatField
+        )
+        if (
+                isinstance(field_attr, number_field_types)
+                or (
+                isinstance(field_attr, Annotation)
+                and field_attr.field in number_field_types
+        )):
+            return TableFieldAlignment.RIGHT
+        return TableFieldAlignment.LEFT
+
+
+    def get_field_definition(f_name: str) -> TableField:
+        if definition := field_definition.get(f_name):
+            return definition
+        parts = f_name.split('__')
+        if len(parts) == 1:
+            rel_model = model
+            names = [rel_model._meta.verbose_name]
+        else:
+            rel_model, names = get_related_model(model, f_name)
+        try:
+            return rel_model.table_field_definition[parts[-1]]
+        except (AttributeError, KeyError):
+            attr = getattr(rel_model, parts[-1])
+            if isinstance(attr, Annotation):
+                pass
+            elif hasattr(attr, 'field'):
+                attr = attr.field
+        names.append(attr.verbose_name)
+        return TableField(
+            label=' / '.join([str(name) for name in names[1:]]),
+            name=f_name,
+            header_info=str(attr.help_text),
+            truncate_after=50,
+            alignment=get_alignment(attr)
+        )
+
+    if field_definition is None:
+        field_definition = {}
+
+    table_fields = []
+    for field_name in fields:
+        try:
+            table_fields.append(get_field_definition(field_name))
+        except AttributeError as e:
+            print(e)
+            pass
+    return table_fields