accrete 0.0.35__py3-none-any.whl → 0.0.37__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

@@ -1,10 +1,20 @@
 from .filter import Filter
 from .context import (
-    ListContext,
     DetailContext,
+    TableContext,
+    ListContext,
     FormContext,
+    form_actions,
+    list_page,
+    detail_page,
+    cast_param,
+    prepare_url_params,
+    extract_url_params,
+    exclude_params,
+    url_param_str,
+    get_table_fields
 )
-from .components import (
+from .elements import (
     ClientAction,
     ActionMethod,
     BreadCrumb,
@@ -13,4 +23,3 @@ from .components import (
     TableFieldType,
     Icon
 )
-from .querystring import load_querystring, build_querystring

accrete/contrib/ui/context.py

@@ -1,291 +1,218 @@
 import logging
 from dataclasses import dataclass, field
-
-from django.utils.translation import gettext_lazy as _
-from django.db.models import Model, QuerySet, Q
+from typing import TypedDict
+from django.utils.translation import gettext_lazy as _t
+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 accrete.querystring import parse_querystring
-
-from .querystring import load_querystring, build_querystring
-from .components import ClientAction, BreadCrumb, TableField
+from accrete.utils.models import get_related_model
+from .elements import ClientAction, BreadCrumb, TableField, TableFieldType
 from .filter import Filter
+from ...annotation import Annotation
 
 _logger = logging.getLogger(__name__)
 
 DEFAULT_PAGINATE_BY = 40
 
 
-@dataclass
-class ListContext:
-
-    model: type[Model]
-    get_params: dict
-    title: str = None
-    context: dict = field(default_factory=dict)
-    queryset: QuerySet = None
-    select_related: list[str] = field(default_factory=list)
-    prefetch_related: list[str] = field(default_factory=list)
-    annotate: dict = field(default_factory=dict)
-    paginate_by: int = DEFAULT_PAGINATE_BY
-    order_by: list[str] = field(default_factory=list)
-    filter_relation_depth: int = 4
-    default_filter_term: str = ''
-    actions: list[ClientAction] = field(default_factory=list)
-    breadcrumbs: list[BreadCrumb] = field(default_factory=list)
-    object_label: str = None
-    fields: list[TableField] = field(default_factory=list)
-    unselect_button: bool = False
-    endless_scroll: bool = True
+class DetailPagination(TypedDict):
+    previous_object_url: str
+    next_object_url: str
+    current_object_idx: int
+    total_objects: int
 
-    def get_queryset(self):
-        if self.queryset:
-            return self.queryset
-
-        order = self.order_by or self.model._meta.ordering
-
-        # pks = self.model.objects.filter(
-        #     parse_querystring(self.model, self.get_params.get('q', '[]'))
-        # ).distinct().values_list('pk', flat=True)
-
-        queryset = self.model.objects.select_related(
-            *self.select_related
-        ).prefetch_related(
-            *self.prefetch_related
-        ).filter(
-            parse_querystring(self.model, self.get_params.get('q', '[]'))
-        ).annotate(
-            **self.get_annotations()
-        ).order_by(
-            *order
-        ).distinct()
-
-        return queryset
-
-    def get_annotations(self):
-        annotations = {
-            annotation['name']: annotation['func']
-            for annotation in getattr(self.model, 'annotations', [])
-        }
-        if self.annotate:
-            annotations.update(self.annotate)
-        return annotations
 
-    def get_page_number(self, paginator):
-        page_number = self.get_params.get('page', '1')
+@dataclass(kw_only=True)
+class Context:
 
-        try:
-            page_number = int(page_number)
-        except ValueError:
-            page_number = 1
-
-        if page_number < 1:
-            page_number = 1
-        elif page_number > paginator.num_pages:
-            page_number = paginator.num_pages
-        return page_number
-
-    def get_paginate_by(self):
-        paginate_by = self.get_params.get('paginate_by', self.paginate_by)
-        try:
-            paginate_by = int(paginate_by)
-        except ValueError:
-            paginate_by = self.paginate_by
-        return paginate_by
+    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):
-        queryset = self.get_queryset()
-        paginate_by = self.get_paginate_by()
-        paginator = Paginator(queryset, paginate_by)
-        page = paginator.page(self.get_page_number(paginator))
-        context = {
-            'queryset': queryset,
-            'paginate_by': paginate_by,
-            'order_by': self.get_params.get('order_by', self.model._meta.ordering),
-            'paginator': paginator,
-            'page': page,
-            'list_pagination': True,
-            'title': self.title or self.model._meta.verbose_name_plural,
-            'object_label': self.object_label or self.model._meta.verbose_name or _('Name'),
-            'filter': Filter(self.model, self.filter_relation_depth),
-            'default_filter_term': self.default_filter_term,
-            'breadcrumbs': self.breadcrumbs,
-            'querystring': load_querystring(self.get_params),
-            'url_params': build_querystring(self.get_params),
-            'actions': self.actions,
-            'fields': self.fields,
-            'endless_scroll': self.endless_scroll
+        return {
+            attr: getattr(self, attr, '') for attr
+            in filter(lambda x: not x.startswith('_'), self.__dict__)
         }
-        context.update(self.context)
-        return context
 
 
 @dataclass
-class DetailContext:
-
-    obj: Model | type[Model]
-    get_params: dict
-    order_by: str = None
-    paginate_by: int = DEFAULT_PAGINATE_BY
-    title: str = None
-    queryset: type[QuerySet] = None
-    select_related: list[str] = field(default_factory=list)
-    prefetch_related: list[str] = field(default_factory=list)
-    annotate: dict = field(default_factory=dict)
-    actions: list[ClientAction] = field(default_factory=list)
-    breadcrumbs: list[BreadCrumb] = field(default_factory=list)
-    context: dict = field(default_factory=dict)
-
-    def get_queryset(self):
-        if self.queryset:
-            return self.queryset
-
-        order = self.order_by or self.obj._meta.model._meta.ordering
-
-        pks = self.obj._meta.model.objects.filter(
-            parse_querystring(self.obj._meta.model, self.get_params.get('q', '[]'))
-        ).distinct().values_list('pk', flat=True)
-
-        queryset = self.obj._meta.model.objects.select_related(
-            *self.select_related
-        ).prefetch_related(
-            *self.prefetch_related
-        ).filter(
-            Q(pk__in=pks)
-        ).annotate(
-            **self.get_annotations()
-        ).order_by(
-            *order
-        ).distinct()
-
-        return queryset
-
-    def get_annotations(self):
-        annotations = {
-            annotation['name']: annotation['func']
-            for annotation in getattr(self.obj._meta.model, 'annotations', [])
-        }
-        if self.annotate:
-            annotations.update(self.annotate)
-        return annotations
+class TableContext(Context):
 
-    def get_paginate_by(self):
-        paginate_by = self.get_params.get('paginate_by', self.paginate_by)
-        try:
-            paginate_by = int(paginate_by)
-        except ValueError:
-            paginate_by = self.paginate_by
-        return paginate_by
+    object_label: str
+    fields: list[TableField]
+    list_page: paginator.Page
+    pagination_param_str: str
+    endless_scroll: bool
+    filter: Filter
+    object_param_str: str = field(default='', kw_only=True)
+
+
+@dataclass
+class ListContext(Context):
+
+    object_label: str
+    object_param_str: str
+    list_page: paginator.Page
+    pagination_param_str: str
+    filter: Filter
+    endless_scroll: bool = True
+    column_height: int = 4
+    column_width: int = 12
 
-    def get_pagination_context(self):
-        if not hasattr(self.obj, 'get_absolute_url'):
+    def __post_init__(self):
+        super().__post_init__()
+        if self.column_width not in range(1, 13):
             _logger.warning(
-                'Detail pagination disabled for models without the '
-                'get_absolute_url attribute. Set paginate_by to 0 to '
-                'deactivate pagination.'
+                'ListContext parameter column_width should be in range 1 - 12'
             )
-            return {}
-        queryset = self.get_queryset()
-        idx = (*queryset,).index(self.obj)
-        previous_object_url = (
-            queryset[idx - 1] if idx - 1 >= 0 else queryset.last()
-        ).get_absolute_url()
-        next_object_url = (
-            queryset[idx + 1] if idx + 1 <= queryset.count() - 1 else queryset.first()
-        ).get_absolute_url()
-        ctx = {
-            'previous_object_url': previous_object_url,
-            'next_object_url': next_object_url,
-            'current_object_idx': idx + 1,
-            'total_objects': queryset.count(),
-            'detail_pagination': True
-        }
-        return ctx
 
-    def dict(self):
-        paginate_by = self.get_paginate_by()
-        ctx = {
-            'object': self.get_queryset().get(pk=self.obj.pk),
-            'title': self.title or self.obj,
-            'order_by': self.get_params.get('order_by', self.obj._meta.model._meta.ordering),
-            'paginate_by': paginate_by,
-            'detail_pagination': False,
-            'breadcrumbs': self.breadcrumbs,
-            'url_params': build_querystring(self.get_params, ['page']),
-            'actions': self.actions
-        }
-        if self.paginate_by > 0:
-            ctx.update(self.get_pagination_context())
-        ctx.update(self.context)
-        return ctx
 
+class DetailContext(TypedDict, total=False):
 
-@dataclass
-class FormContext:
+    title: str
+    object: Model
+    breadcrumbs: list[BreadCrumb]
+    detail_page: DetailPagination
+    pagination_param_str: str
+    actions: list[ClientAction]
+
+
+class FormContext(TypedDict, total=False):
 
-    model: Model | type[Model]
+    title: str
+    breadcrumbs: list[BreadCrumb]
     form: Form | ModelForm
-    get_params: dict
-    title: str = None
-    context: dict = field(default_factory=dict)
-    form_id: str = 'form'
-    add_default_actions: bool = True
-    discard_url: str = None
-    actions: list[ClientAction] = field(default_factory=list)
-    breadcrumbs: list[BreadCrumb] = field(default_factory=list)
+    form_id: str
+    actions: list[ClientAction]
 
-    def get_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 FormContext is called '
-                'with a model class instead of an instance.'
-            )
-        except AttributeError as e:
-            _logger.error(
-                'Supply the discard_url parameter if FormContext is '
-                'called with a model instance that has the get_absolute_url '
-                'method not defined.'
-            )
-            raise e
 
-        actions.append(
-            ClientAction(
-                name=_('Discard'),
-                url=url,
-            )
-        )
-        return actions
+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:
+        _logger.exception(e)
+        return default
+
+
+def prepare_url_params(get_params: dict) -> dict:
+    return {key: f'&{key}={value}' for key, value in get_params.items()}
+
+
+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 e.g. {'page': '&page=1'}
+    """
+    if extract:
+        params = prepare_url_params(extract_url_params(params, extract))
+    param_str = (
+        "".join(str(value) for value in params.values())
+        .replace('&&', '&')
+        .replace('?&', '?')
+        .strip('?&')
+    )
+    return f'?{param_str}'
+
 
-    def get_title(self):
-        if self.title:
-            return self.title
+def extract_url_params(params: dict, keys: list[str]) -> dict:
+    return {key: params[key] for key in keys if key in params}
+
+
+def exclude_params(params: dict, keys: list[str]) -> dict:
+    return {key: val for key, val in params.items() if key not in keys}
+
+
+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 detail_page(queryset: QuerySet, obj: Model) -> dict:
+    if not hasattr(obj, 'get_absolute_url'):
+        _logger.warning(
+            'Detail pagination disabled for models without the '
+            'get_absolute_url attribute. Set paginate_by to 0 to '
+            'deactivate pagination.'
+        )
+        return {}
+    idx = (*queryset,).index(obj)
+    previous_object_url = (
+        queryset[idx - 1] if idx - 1 >= 0 else queryset.last()
+    ).get_absolute_url()
+    next_object_url = (
+        queryset[idx + 1] if idx + 1 <= queryset.count() - 1 else queryset.first()
+    ).get_absolute_url()
+    return {
+        'previous_object_url': previous_object_url,
+        'next_object_url': next_object_url,
+        'current_object_idx': idx + 1,
+        'total_objects': queryset.count()
+    }
+
+
+def form_actions(discard_url: str, form_id: str = 'form') -> list[ClientAction]:
+    return [
+        ClientAction(
+            name=_t('Save'),
+            submit=True,
+            class_list=['is-success'],
+            form_id=form_id,
+        ),
+        ClientAction(
+            name=_t('Discard'),
+            url=discard_url
+        )
+    ]
+
+
+def get_table_fields(
+        fields: list[str],
+        model: type[Model],
+        field_definition: dict[str | TableField] = None
+) -> list[TableField]:
+    print(fields, model, field_definition)
+
+    if field_definition is None:
+        field_definition = {}
+
+    def get_field_definition(f_name: str) -> TableField:
+        if definition := field_definition.get(f_name):
+            return definition
+        if len(f_name.split('__')) == 1:
+            rel_model = model
+        else:
+            rel_model = get_related_model(model, f_name)
+            print(rel_model)
         try:
-            int(self.model.pk)
-            return _('Edit')
-        except TypeError:
-            return _('Add')
+            return rel_model.table_field_definition[f_name]
+        except (AttributeError, KeyError):
+            attr = getattr(rel_model, f_name)
+            if isinstance(attr, Annotation):
+               attr = attr
+            elif hasattr(attr, 'field'):
+                attr = attr.field
+        return TableField(
+            label=str(attr.verbose_name),
+            name=f_name,
+            header_info=str(attr.help_text),
+            truncate_after=50
+        )
 
-    def dict(self):
-        ctx = {
-            'title': self.get_title(),
-            'form': self.form,
-            'form_id': self.form_id,
-            'url_params': build_querystring(self.get_params, ['page']),
-            'actions': [],
-            'breadcrumbs': self.breadcrumbs,
-        }
-        if self.add_default_actions:
-            ctx.update({'actions': self.get_default_form_actions()})
-        ctx['actions'].extend(self.actions)
-        ctx.update(self.context)
-        return ctx
+    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

accrete/contrib/ui/elements.py

@@ -1,2 +1,78 @@
-from dataclasses import dataclass
-from django.forms import Form, ModelForm
+from enum import Enum
+from dataclasses import dataclass, field
+
+
+class Icon(Enum):
+
+    ADD = 'icon-add'
+    EDIT = 'icon-edit'
+    LIST = 'icon-list'
+    OPEN_RELATED = 'icon-open-related'
+    ENVELOPE = 'icon-envelope'
+    CLEAR = 'icon-clear'
+    BACKSPACE = 'icon-backspace'
+    FILTER = 'icon-filter'
+    DELETE_FILTER = 'icon-delete-filter'
+    SELECT = 'icon-select'
+
+
+class ActionMethod(Enum):
+
+    HREF = 'href'
+    GET = 'hx-get'
+    POST = 'hx-post'
+    PUT = 'hx-put'
+    DELETE = 'hx-delete'
+
+
+@dataclass
+class ClientAction:
+
+    name: str
+    url: str = ''
+    method: ActionMethod = ActionMethod.HREF
+    attrs: list[tuple[str, str]] = field(default_factory=list)
+    submit: bool = False
+    form_id: str = 'form'
+    class_list: list[str] = field(default_factory=list)
+    icon: Icon | type[Enum] = None
+
+    def attrs_str(self):
+        return ' '.join([f'{str(attr[0])}={str(attr[1])}' for attr in self.attrs])
+
+
+class TableFieldAlignment(Enum):
+
+    LEFT = 'left'
+    CENTER = 'center'
+    RIGHT = 'right'
+
+
+class TableFieldType(Enum):
+
+    NONE = ''
+    STRING = '_string'
+    MONETARY = '_monetary'
+    FLOAT = '_float'
+
+
+@dataclass
+class TableField:
+
+    label: str
+    name: str
+    alignment: TableFieldAlignment | Enum = TableFieldAlignment.LEFT
+    header_alignment: TableFieldAlignment | Enum = None
+    header_info: str = None
+    field_type: TableFieldType | Enum = TableFieldType.NONE
+    prefix: str = ''
+    suffix: str = ''
+    truncate_after: int = 0
+    template: str = None
+
+
+@dataclass
+class BreadCrumb:
+
+    name: str
+    url: str