accrete 0.0.37__tar.gz → 0.0.38__tar.gz

{accrete-0.0.37 → accrete-0.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: accrete
-Version: 0.0.37
+Version: 0.0.38
 Summary: Django Shared Schema Multi Tenant
 Author-email: Benedikt Jilek <benedikt.jilek@pm.me>
 License: Copyright (c) 2023 Benedikt Jilek

{accrete-0.0.37 → accrete-0.0.38}/accrete/contrib/ui/context.py

@@ -2,14 +2,18 @@ import logging
 from dataclasses import dataclass, field
 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 accrete.utils.models import get_related_model
-from .elements import ClientAction, BreadCrumb, TableField, TableFieldType
+from accrete.annotation import Annotation
+from .elements import (
+    ClientAction, BreadCrumb, TableField, TableFieldType, TableFieldAlignment
+)
 from .filter import Filter
-from ...annotation import Annotation
+
 
 _logger = logging.getLogger(__name__)
 
@@ -180,34 +184,50 @@ def get_table_fields(
         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_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
-        if len(f_name.split('__')) == 1:
+        parts = f_name.split('__')
+        if len(parts) == 1:
             rel_model = model
+            names = [rel_model._meta.verbose_name]
         else:
-            rel_model = get_related_model(model, f_name)
-            print(rel_model)
+            rel_model, names = get_related_model(model, f_name)
         try:
-            return rel_model.table_field_definition[f_name]
+            return rel_model.table_field_definition[parts[-1]]
         except (AttributeError, KeyError):
-            attr = getattr(rel_model, f_name)
+            attr = getattr(rel_model, parts[-1])
             if isinstance(attr, Annotation):
-               attr = attr
+                pass
             elif hasattr(attr, 'field'):
                 attr = attr.field
+        names.append(attr.verbose_name)
         return TableField(
-            label=str(attr.verbose_name),
+            label=' / '.join([str(name) for name in names[1:]]),
             name=f_name,
             header_info=str(attr.help_text),
-            truncate_after=50
+            truncate_after=50,
+            alignment=get_alignment(attr)
         )
 
+    if field_definition is None:
+        field_definition = {}
+
     table_fields = []
     for field_name in fields:
         try:

{accrete-0.0.37 → accrete-0.0.38}/accrete/contrib/ui/filter.py

@@ -69,7 +69,7 @@ class Filter:
             except AttributeError:
                 label = field.related_model._meta.verbose_name
             res.append({
-                'name': field.name,
+                'name': f'{rel_path}',
                 'label': str(label),
                 'type': field.get_internal_type(),
                 'null': field.null,

{accrete-0.0.37 → accrete-0.0.38}/accrete/contrib/ui/templatetags/accrete_ui.py

@@ -28,27 +28,20 @@ def combine_templates(template_name, request=None):
 
 @register.filter(name='get_attr')
 def get_attr_from_string(param: object, value: str):
-    try:
-        attr = getattr(param, value)
-    except AttributeError:
-        _logger.exception(f'Object {param} has no attribute {value}')
-        return ''
+    attr_name = value.split('__')
+    attr = param
+    for name in attr_name:
+        try:
+            attr = getattr(attr, name)
+        except AttributeError:
+            _logger.exception(f'Object {attr} has no attribute {name}')
+            return ''
     if callable(attr):
         return attr()
     else:
         return attr
 
 
-def get_field_value(param: type[Model], value: str):
-    model = param
-    vals = value.split('__')
-    if len(vals) == 1:
-        return get_attr_from_string(model, vals[0])
-    for val in value.split('__'):
-        pass
-
-
-
 @register.filter(name='message_class')
 def message_class(param):
     if param.level == 25:

{accrete-0.0.37 → accrete-0.0.38}/accrete/querystring.py

@@ -2,6 +2,8 @@ import logging
 import json
 import operator
 from django.db.models import Model, Q, QuerySet
+from accrete.utils.models import get_related_model
+from accrete.annotation import Annotation
 
 _logger = logging.getLogger(__name__)
 
@@ -34,28 +36,23 @@ def parse_querystring(model: type[Model], query_string: str) -> Q:
             expression = Q(**{term: value})
             return ~expression if invert else expression
 
-        rel_path = parts[0].rstrip('__')
-        term = parts[1]
-        rel_model = get_related_model(rel_path) if rel_path else model
-        objects = rel_model.objects.filter(Q(**{term: value}))
+        rel_path = '__'.join(parts[:-2])
+        related_model, x = get_related_model(model, rel_path)
+        attr = getattr(related_model, parts[-2])
+        if not isinstance(attr, Annotation):
+            expression = Q(**{term: value})
+            return ~expression if invert else expression
+
+        objects = related_model.objects.filter(Q(**{
+            '__'.join(parts[len(x):]): value
+        }))
         expression = Q(**{
-            f'{rel_path}{"__" if rel_path else ""}id__in': objects.values_list('id', flat=True)
+            f'{rel_path}{"__" if rel_path else ""}id__in':
+                objects.values_list('id', flat=True)
         })
 
         return ~expression if invert else expression
 
-    def get_related_model(rel_path: str):
-        related_model = model
-        for part in rel_path.split('__'):
-            try:
-                related_model = related_model._meta.fields_map[part].related_model
-            except (AttributeError, KeyError):
-                try:
-                    related_model = getattr(related_model, part).field.related_model
-                except AttributeError:
-                    break
-        return related_model
-
     def parse_query_block(sub_item) -> Q:
         op = ops['&']
         parsed_query = Q()

accrete-0.0.38/accrete/utils/models.py

@@ -0,0 +1,19 @@
+from django.db.models import Model
+
+
+def get_related_model(model: type[Model], rel_path: str) -> tuple[Model, list[str]]:
+    names = []
+    related_model = model
+    for part in rel_path.split('__'):
+        names.append(str(related_model._meta.verbose_name))
+        try:
+            next_model = related_model._meta.fields_map[part].related_model
+            related_model = next_model
+        except (AttributeError, KeyError):
+            try:
+                next_model = getattr(related_model, part).field.related_model
+                if next_model is not None:
+                    related_model = next_model
+            except AttributeError:
+                break
+    return related_model, names

{accrete-0.0.37 → accrete-0.0.38}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'hatchling.build'
 
 [project]
 name = 'accrete'
-version = '0.0.37'
+version = '0.0.38'
 authors = [
   { name='Benedikt Jilek', email='benedikt.jilek@pm.me' },
 ]

accrete-0.0.37/accrete/utils/models.py

@@ -1,14 +0,0 @@
-from django.db.models import Model
-
-
-def get_related_model(model: type[Model], rel_path: str):
-    related_model = model
-    for part in rel_path.split('__'):
-        try:
-            related_model = related_model._meta.fields_map[part].related_model
-        except (AttributeError, KeyError):
-            try:
-                related_model = getattr(related_model, part).field.related_model
-            except AttributeError:
-                break
-    return related_model