wbcore 1.59.9__py2.py3-none-any.whl

wbcore/metadata/configs/display/display.py

@@ -0,0 +1,234 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Iterable, Optional
+
+# Type Definitions
+GridArea = list[list[str]]
+SerializedField = dict[str, str | bool]
+SerializedCardLayout = dict[str, str | SerializedField | list[SerializedField]]
+SerializedTable = dict[str, str | bool]
+SerializedChart = dict[str, str]
+SerializedSection = list
+SerializedLayout = dict[str, str | SerializedSection | SerializedTable]
+SerializedItem = dict[str, str | dict[str, SerializedLayout]]
+
+
+class DisplayType(Enum):
+    FORM = "form"
+    TABLE = "table"
+    CHART = "chart"
+    CALENDAR = "calendar"
+
+
+class ItemType(Enum):
+    PAGE = "page"
+    TAB = "tab"
+
+
+class InvalidOperatorError(Exception):
+    pass
+
+
+class Operator(Enum):
+    S = "<"
+    SE = "<="
+    G = ">"
+    GE = ">="
+    E = "=="
+
+    @classmethod
+    def get_operator(cls, op: str) -> "Operator":
+        operator_dict = {o.value: o for o in cls}
+        try:
+            return operator_dict[op]
+        except KeyError as e:
+            raise InvalidOperatorError(f"`{op}` is not a valid operator") from e
+
+
+def fr(fractions: int) -> str:
+    return f"{fractions}fr"
+
+
+def px(pixels: int) -> str:
+    return f"{pixels}px"
+
+
+def pct(percent: float) -> str:
+    return f"{percent}%"
+
+
+def repeat(times: int, unit: str) -> str:
+    return f"repeat({times}, {unit})"
+
+
+def grid_definition(*units):
+    return " ".join(units)
+
+
+def layout_size(width: Optional[int] = None, operator: str | Operator = Operator.S) -> str:
+    if width is None:
+        return "default"
+
+    if isinstance(operator, str):
+        operator = Operator.get_operator(operator)
+
+    return f"{operator.value}{width}"
+
+
+@dataclass
+class Table:
+    key: str
+    editable: bool = False
+
+    def serialize(self) -> SerializedTable:
+        return {
+            "key": self.key,
+            "editable": self.editable,
+        }
+
+
+@dataclass
+class Chart:
+    key: str
+
+    def serialize(self) -> SerializedChart:
+        return {"key": self.key}
+
+
+@dataclass
+class Layout:  # This has to be renamed to FormLayout
+    grid_areas: GridArea
+    grid_columns: Optional[str] = None
+    grid_rows: Optional[str] = None
+    sections: list = field(default_factory=list)
+    tables: list[Table] = field(default_factory=list)
+    charts: list[Chart] = field(default_factory=list)
+
+    def serialize(self) -> SerializedLayout:
+        serialized_layout = {
+            "gridTemplateAreas": " ".join([f"'{' '.join(row)}'" for row in self.grid_areas]),
+            "sections": self.sections,
+            "tables": [table.serialize() for table in self.tables],
+            "charts": [chart.serialize() for chart in self.charts],
+        }
+
+        if self.grid_columns:
+            serialized_layout["gridTemplateColumns"] = self.grid_columns
+
+        if self.grid_rows:
+            serialized_layout["gridTemplateRows"] = self.grid_rows
+
+        return serialized_layout
+
+
+@dataclass
+class Field:
+    key: str
+    show_label: bool = True
+    label: str | None = None
+
+    def serialize(self) -> SerializedField:
+        serialized_field = {"key": self.key, "show_label": self.show_label}
+
+        if self.label and self.show_label:
+            serialized_field["label"] = self.label
+
+        return serialized_field
+
+
+# @dataclass
+# class TableLayout:
+#     def serialize(self) -> SerializedTableLayout:
+#         pass
+
+
+@dataclass
+class CardLayout:
+    title: Field
+    fields: list[Field] = field(default_factory=list)
+
+    color: str | None = None
+    background_color: str | None = None
+    image: str | None = None
+
+    def serialize(self) -> SerializedCardLayout:
+        serialized_layout = {"title": self.title.serialize(), "fields": [field.serialize() for field in self.fields]}
+
+        if self.color:
+            serialized_layout["color"] = self.color
+
+        if self.background_color:
+            serialized_layout["background_color"] = self.background_color
+
+        if self.image:
+            serialized_layout["image"] = self.image
+
+        return serialized_layout
+
+
+@dataclass
+class Item:
+    layouts: dict[str, Layout]
+    title: str = ""
+
+    def serialize(self) -> SerializedItem:
+        return {"title": self.title, "layout": {key: layout.serialize() for key, layout in self.layouts.items()}}
+
+
+@dataclass
+class Display:
+    display_type: DisplayType
+    items: Iterable[Item]  # Consider to also be able to just a layout to make it redundant to use an Item here
+    item_type: ItemType = ItemType.PAGE  # This can maybe also be nullable?
+
+    def serialize(self) -> dict[str, str | list[SerializedItem]]:
+        return {
+            "display_type": self.display_type.value,
+            "item_type": self.item_type.value,
+            "items": [item.serialize() for item in self.items],
+        }
+
+    def __iter__(self):
+        for item in self.items:
+            yield item.serialize()
+
+
+if __name__ == "__main__":
+    # display = Display(
+    #     display_type=DisplayType.FORM,
+    #     items=[
+    #         Item(
+    #             title="First Page",
+    #             layouts={
+    #                 layout_size(): Layout(
+    #                     grid_columns=repeat(6, fr(1)),
+    #                     grid_areas=[["status", "status", "status", "title", "period", "period"]],
+    #                 ),
+    #                 layout_size(400): Layout(
+    #                     grid_columns=repeat(3, fr(1)),
+    #                     grid_areas=[["status", "status", "status"], ["title", "period", "period"]],
+    #                 ),
+    #             },
+    #         )
+    #     ],
+    # )
+    # display = Display(
+    #     display_type=DisplayType.TABLE,
+    #     items=[
+    #         Item(
+    #             layouts={
+    #                 layout_size(): Layout(
+    #                     grid_columns=repeat(4, fr(1)),
+    #                     grid_areas=[
+    #                         ["period", "status", "title", "other_field"],
+    #                         ["period", "status", "title", "other_field1"],
+    #                     ],
+    #                 )
+    #             }
+    #         )
+    #     ],
+    # )
+    # print(display.serialize())
+    # print(list(display) == display.serialize())
+
+    print(layout_size(500, Operator.E))  # noqa: T201

wbcore/metadata/configs/display/formatting.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+
+from wbcore.enums import Operator
+
+
+@dataclass(unsafe_hash=True)
+class Condition:
+    operator: Operator
+    value: str | float | int | bool
+
+    def __post_init__(self) -> None:
+        if self.operator == Operator.EXISTS and not isinstance(self.value, bool):
+            raise TypeError(f"{Operator.EXISTS.value} is only compatible with bool")
+
+
+@dataclass(unsafe_hash=True)
+class FormattingRule:
+    style: dict | None = None
+    condition: Condition | tuple | list[tuple] | None = None
+
+    def __post_init__(self) -> None:
+        if not self.style:
+            raise ValueError("Style cannot be empty")
+
+    def __iter__(self):
+        yield "style", self.style
+        if self.condition:
+            if isinstance(self.condition, tuple):
+                yield "condition", self.condition
+            elif isinstance(self.condition, list):
+                yield "condition", [tuple(cond) for cond in self.condition]
+            else:
+                yield "condition", (self.condition.operator.value, self.condition.value)
+
+
+@dataclass(unsafe_hash=True)
+class Formatting:
+    formatting_rules: list[FormattingRule]
+    column: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.column is None and not all([not bool(rule.condition) for rule in self.formatting_rules]):
+            raise ValueError("Specifying conditions, without a reference column is not possible.")
+
+    def __iter__(self):
+        yield "column", self.column
+        yield "formatting_rules", [dict(rule) for rule in self.formatting_rules]

wbcore/metadata/configs/display/instance_display/__init__.py

@@ -0,0 +1,15 @@
+from . import operators as op
+from .display import Display
+from .enums import NavigationType
+from .layouts import Inline, Layout, Section
+from .pages import Page
+from .shortcuts import create_simple_display, create_simple_section
+from .operators import default
+from .styles import Style
+from .utils import (
+    grid_definition,
+    repeat,
+    repeat_field,
+    split_list_into_grid_template_area_sublists,
+)
+from .signals import add_display_pages

wbcore/metadata/configs/display/instance_display/display.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Iterable
+
+from wbcore.utils.importlib import parse_signal_received_for_module
+
+from .enums import NavigationType
+from .pages import Page, SerializedPage
+from .signals import add_display_pages
+
+type SerializedDisplay = dict[str, NavigationType | SerializedPage]
+
+
+@dataclass
+class Display:
+    """A display contains multiple pages and a navigation type. When only 1 page is specified, the navigation type is irrelevant"""
+
+    pages: Iterable[Page]
+    navigation_type: NavigationType = NavigationType.TAB
+
+    def serialize(
+        self, view_config=None, view=None, request=None, key_prefix=None, parent_page=None
+    ) -> SerializedDisplay:
+        """Serializes a `Display`
+
+        Returns:
+            A dictionary with all pages and the navigation type
+
+        """
+        serialized_pages = [
+            page.serialize(key_prefix=key_prefix, view_config=view_config, view=view, request=request)
+            for page in self.pages
+        ]
+        # we only allow remote page registration if the display is the top display. We could argue that we want to allow dev to register pages for any nested display by passing down the page argument. This involves refactoring of the signal receivers
+        if view_config and parent_page is None:
+            for prefix, remote_pages in parse_signal_received_for_module(
+                add_display_pages.send(view_config.__class__, request=request, view=view)
+            ):
+                for remote_page in remote_pages:
+                    serialized_pages.append(remote_page.serialize(prefix, view_config, view, request))
+        return {"navigationType": self.navigation_type.value, "pages": serialized_pages}

wbcore/metadata/configs/display/instance_display/enums.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class NavigationType(Enum):
+    TAB = "tab"
+    PAGE = "page"
+    PANEL = "panel"

wbcore/metadata/configs/display/instance_display/layouts/__init__.py

@@ -0,0 +1,3 @@
+from .inlines import Inline
+from .layouts import Layout
+from .sections import Section

wbcore/metadata/configs/display/instance_display/layouts/inlines.py

@@ -0,0 +1,58 @@
+import typing
+from dataclasses import dataclass
+
+from wbcore.metadata.utils import prefix_key
+
+if typing.TYPE_CHECKING:
+    from ..display import Display, SerializedDisplay
+
+
+type SerializedInline = dict[str, str | SerializedDisplay | list[str] | bool]
+
+
+@dataclass
+class Inline:
+    """An inline can be used to display a different endpoint in a form
+
+    When generating a form, only fields of the original endpoint can be displayed. An inline allows you to specify
+    remote content, for example a chart or a table, which the form asynchronously loads. This is very useful to
+    create dashboard like views and to seperate the load to multiple endpoints
+
+    Attributes:
+        key: A reference for the positioning on the grid
+        endpoint: A reference to the endpoint in the additional resources
+        display: An optional `Display` to override the `display` behind the `endpoint` in the additional resources
+
+    """
+
+    key: str
+    endpoint: str
+    title: str | None = None
+    display: typing.Optional["Display"] = None
+    aligned_keys: list[str] | None = None
+    hide_controls: bool = False
+
+    def serialize(self, key_prefix: str | None = None) -> SerializedInline:
+        """Serializes this `Inline`
+        Attributes:
+            key_prefix(Optional): if specified, append a prefix to the inline key
+        Returns:
+            A dictionairy containing all serialized fields
+
+        """
+        serialized_inline: SerializedInline = {
+            "key": self.key,
+            "endpoint": prefix_key(self.endpoint, key_prefix),
+            "hide_controls": self.hide_controls,
+        }
+
+        if self.title is not None:
+            serialized_inline["title"] = self.title
+
+        if self.display:
+            serialized_inline["display"] = self.display.serialize()
+
+        if self.aligned_keys:
+            serialized_inline["aligned_keys"] = self.aligned_keys
+
+        return serialized_inline

wbcore/metadata/configs/display/instance_display/layouts/layouts.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass, field
+
+from wbcore.metadata.configs.display.instance_display.styles import Style
+from wbcore.metadata.configs.display.instance_display.utils import grid_definition
+
+from .inlines import Inline, SerializedInline
+from .sections import Section, SerializedSection
+
+type SerializedLayout = dict[str, str | list[SerializedInline] | list[SerializedSection]]
+
+
+@dataclass
+class Layout:
+    """A layout contains all the information on how a form is build.
+
+    A form is rendered based on a grid, which is closely modelled after a CSS Grid. Essentially, we can define
+    rows and columns and places fields on this grid, either in one cell, or spanning multiple rows and columns.
+
+    In the future we will add all other features of css grid to ensure full control over the grid.
+
+    Attributes:
+        grid_template_areas: A 2D string Array containing the areas on the grid. The strings are the keys references to all fields
+        grid_template_columns: A string array containing the column definitions for the width of each column
+        grid_template_rows: A string array containing the row definitions for the height of each row
+        sections: A list of sections that can be positioned in `grid_template_areas`
+        inlines: A list of inlines that can be positioned in `grid_template_areas`
+        gap: A string specifying the gap between all rows and columns. Should be used with a helper method like `Style.px(10)`
+
+    """
+
+    grid_template_areas: list[list[str]]
+    grid_auto_columns: str | None = None
+    grid_template_columns: list[str] | None = None
+    grid_auto_rows: str = Style.MIN_CONTENT
+    grid_template_rows: list[str] | None = None
+
+    sections: list[Section] = field(default_factory=list)
+    inlines: list[Inline] = field(default_factory=list)
+
+    gap: str = Style.px(10)
+    row_gap: str | None = None
+    column_gap: str | None = None
+
+    def serialize(self, key_prefix: str | None = None) -> SerializedLayout:
+        """Serializes this `Layout`
+        Attributes:
+            key_prefix(Optional): if specified, append a prefix to underlying inlines key
+        Returns:
+            A dictionairy containing all serialized fields
+
+        """
+        serialized_layout = {
+            "gridTemplateAreas": " ".join([f"'{' '.join(row)}'" for row in self.grid_template_areas]),
+            "sections": [section.serialize(key_prefix=key_prefix) for section in self.sections],
+            "inlines": [inline.serialize(key_prefix=key_prefix) for inline in self.inlines],
+            "gap": self.gap,
+        }
+
+        if self.row_gap:
+            serialized_layout["rowGap"] = self.row_gap
+
+        if self.column_gap:
+            serialized_layout["columnGap"] = self.column_gap
+
+        if self.grid_auto_columns:
+            serialized_layout["gridAutoColumns"] = self.grid_auto_columns
+
+        if self.grid_template_columns:
+            serialized_layout["gridTemplateColumns"] = grid_definition(*self.grid_template_columns)
+
+        if self.grid_auto_rows:
+            serialized_layout["gridAutoRows"] = self.grid_auto_rows
+
+        if self.grid_template_rows:
+            serialized_layout["gridTemplateRows"] = grid_definition(*self.grid_template_rows)
+
+        return serialized_layout

wbcore/metadata/configs/display/instance_display/layouts/sections.py

@@ -0,0 +1,43 @@
+import typing
+from dataclasses import dataclass
+
+if typing.TYPE_CHECKING:
+    from ..display import Display, SerializedDisplay
+
+
+SerializedSection = dict[str, typing.Union[str, bool, "SerializedDisplay"]]
+
+
+@dataclass
+class Section:
+    """A section makes it possible to grid certain fields together into an area inside a form
+
+    Attributes:
+        key: A reference for the positioning on the grid
+        title: The title of the section, it will be displayed in on the top of a section
+        display: The `Display` which holds the grid of the fields in this section
+        collapsed: A flag to indicate whether this section is initially collapsed
+        collapsible: A flag to indicate whether this section is collapsible
+
+    """
+
+    key: str
+    title: str
+    display: "Display"
+    collapsed: bool = False
+    collapsible: bool = True
+
+    def serialize(self, key_prefix: str | None = None) -> SerializedSection:
+        """Serializes this `Section`
+
+        Returns:
+            A dictionairy containing all serialized fields
+
+        """
+        return {
+            "key": self.key,
+            "title": self.title,
+            "display": self.display.serialize(key_prefix=key_prefix),
+            "collapsed": self.collapsed,
+            "collapsible": self.collapsible,
+        }

wbcore/metadata/configs/display/instance_display/operators.py

@@ -0,0 +1,22 @@
+def lt(value: int) -> str:
+    return _stringify("<", value)
+
+
+def lte(value: int) -> str:
+    return _stringify("<=", value)
+
+
+def gt(value: int) -> str:
+    return _stringify(">", value)
+
+
+def gte(value: int) -> str:
+    return _stringify(">=", value)
+
+
+def default() -> str:
+    return "default"
+
+
+def _stringify(operator: str, value: int) -> str:
+    return f"{operator}{value}"

wbcore/metadata/configs/display/instance_display/pages.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from .layouts.layouts import Layout, SerializedLayout
+
+if TYPE_CHECKING:
+    from .display import Display, SerializedDisplay
+
+
+type SerializedPage = dict[str, None | str | dict[str, SerializedLayout] | SerializedDisplay]
+
+
+@dataclass
+class Page:
+    """Represents a page, which may include an optional title and a dictionary defining layout boundaries along with a Layout. Alternatively, a list of subpages can also be specified."""
+
+    title: str | None = None
+    layouts: dict[str, Layout] | None = None
+    display: "Display | None" = None
+
+    def serialize(self, key_prefix: str | None = None, view_config=None, view=None, request=None) -> SerializedPage:
+        """Serializes the `Page` into a dictionairy
+
+        Returns:
+            A dictionairy containing all fields of a `Page`
+
+        """
+        page: SerializedPage = {
+            "title": self.title,
+        }
+
+        if self.layouts is not None:
+            page["layouts"] = {key: layout.serialize(key_prefix=key_prefix) for key, layout in self.layouts.items()}
+
+        elif self.display is not None:
+            page["display"] = self.display.serialize(
+                view_config=view_config, view=view, request=request, key_prefix=key_prefix, parent_page=self
+            )
+
+        return page

wbcore/metadata/configs/display/instance_display/shortcuts.py

@@ -0,0 +1,81 @@
+from .display import Display
+from .layouts import Inline, Layout, Section
+from .operators import default
+from .pages import Page
+from .styles import Style
+
+
+def create_simple_display(
+    grid_template_areas: list[list[str]],
+    sections: list[Section] | None = None,
+    inlines: list[Inline] | None = None,
+) -> Display:
+    """Creates a simple display without having to specify all the intermediary classes
+
+    Args:
+        grid_template_areas: 2D string array containing all fields that should be displayed
+        sections: A list of sections included in the `grid_template_areas`
+        inlines: A list of inlines if necessary.
+
+    Returns:
+        A `Display` containing 1 `Page` with all fields in 1 `Section` with all columns and rows having the same dimensions
+
+    """
+    return Display(
+        pages=[
+            Page(
+                layouts={
+                    default(): Layout(
+                        grid_template_areas=grid_template_areas,
+                        grid_auto_columns=Style.fr(1),
+                        inlines=inlines if inlines else [],
+                        sections=sections if sections else [],
+                    )
+                }
+            )
+        ]
+    )
+
+
+def create_simple_section(
+    key: str,
+    title: str,
+    grid_template_areas: list[list[str]] | None = None,
+    inline_key: str | None = None,
+    extra_display_kwargs: dict | None = None,
+    **kwargs,
+) -> Section:
+    """Creates a simple section without having to specify everything
+
+    Args:
+        key: A string that will be later referenced in the display's `grid_template_areas`
+        title: A string which is used as a header
+        grid_template_areas: 2D string array containing all fields that should be displayed
+        inline_key: if the section is a nested table, the inline is the corresponding endpoint
+        extra_display_kwargs: an additional dictionary for create_simple_display parameters.
+
+    Returns:
+        A `Section` containing a simple `Display`
+
+    """
+    return Section(
+        key=key,
+        title=title,
+        display=create_simple_display(
+            grid_template_areas=grid_template_areas if grid_template_areas else [],
+            inlines=[Inline(key=inline_key, endpoint=inline_key)] if inline_key else [],
+            **extra_display_kwargs if extra_display_kwargs else {},
+        ),
+        **kwargs,
+    )
+
+
+def create_simple_page_with_inline(title: str, key: str) -> Page:
+    return Page(
+        title=title,
+        layouts={
+            default(): Layout(
+                grid_template_areas=[[key]], grid_template_rows=["100%"], inlines=[Inline(key=key, endpoint=key)]
+            )
+        },
+    )

wbcore/metadata/configs/display/instance_display/signals.py

@@ -0,0 +1,3 @@
+from django.dispatch import Signal
+
+add_display_pages = Signal()  # many