amsdal 0.4.13__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

amsdal/contrib/frontend_configs/constants.pyi

@@ -0,0 +1 @@
+ON_RESPONSE_EVENT: str

amsdal/contrib/frontend_configs/conversion/__init__.py

@@ -0,0 +1,5 @@
+from amsdal.contrib.frontend_configs.conversion.convert import convert_to_frontend_config
+
+__all__ = [
+    'convert_to_frontend_config',
+]

amsdal/contrib/frontend_configs/conversion/__init__.pyi

@@ -0,0 +1,3 @@
+from amsdal.contrib.frontend_configs.conversion.convert import convert_to_frontend_config as convert_to_frontend_config
+
+__all__ = ['convert_to_frontend_config']

amsdal/contrib/frontend_configs/conversion/convert.py

@@ -0,0 +1,286 @@
+from contextlib import suppress
+from datetime import date
+from datetime import datetime
+from enum import Enum
+from inspect import _empty
+from inspect import signature
+from types import FunctionType
+from types import UnionType
+from typing import Any
+from typing import ClassVar
+from typing import ForwardRef
+from typing import Union
+from typing import get_args
+from typing import get_origin
+
+from amsdal_models.classes.class_manager import ClassManager
+from amsdal_models.classes.model import LegacyModel
+from amsdal_models.classes.model import Model
+from amsdal_models.classes.model import TypeModel
+from amsdal_models.classes.relationships.constants import MANY_TO_MANY_FIELDS
+from amsdal_models.schemas.object_schema import model_to_object_schema
+from amsdal_utils.models.data_models.reference import Reference
+from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
+
+default_types_map = {
+    int: 'number',
+    float: 'number',
+    bool: 'checkbox',
+    str: 'text',
+    bytes: 'Bytes',
+    date: 'date',
+    datetime: 'datetime',
+}
+
+
+def _process_union(value: UnionType, *, is_transaction: bool = False) -> dict[str, Any]:
+    arg_type = {'required': True}
+
+    for arg in get_args(value):
+        if arg is type(None):
+            arg_type['required'] = False
+            continue
+
+        if not is_transaction:
+            with suppress(TypeError):
+                if issubclass(arg, Model):
+                    arg_type['type'] = 'object_latest'  # type: ignore[assignment]
+                    arg_type['entityType'] = arg.__name__
+                    continue
+
+        control = convert_to_frontend_config(arg, is_transaction=is_transaction)
+        if control:
+            arg_type.update(control)
+
+    return arg_type
+
+
+def convert_to_frontend_config(value: Any, *, is_transaction: bool = False) -> dict[str, Any]:
+    """
+    Converts a given value to a frontend configuration dictionary.
+
+    This function takes a value and converts it into a dictionary that represents
+    the configuration for a frontend form control. It handles various types such as
+    Union, list, dict, BaseModel, and custom types.
+
+    Args:
+        value (Any): The value to be converted to frontend configuration.
+        is_transaction (bool, optional): Indicates if the conversion is for a transaction. Defaults to False.
+
+    Returns:
+        dict[str, Any]: A dictionary representing the frontend configuration for the given value.
+    """
+    schema = None
+    origin_class = get_origin(value)
+
+    if origin_class:
+        if origin_class in [ClassVar]:
+            return {}
+
+        if origin_class is Union:
+            _union = _process_union(value, is_transaction=is_transaction)
+
+            if 'entityType' in _union and _union['entityType'] == 'File':
+                _union['type'] = 'file'
+                del _union['entityType']
+
+            return _union
+
+        if origin_class is list:
+            return {
+                'type': 'array',
+                'name': 'array_items',
+                'label': 'array_items',
+                'control': {
+                    'name': 'array_items_values',
+                    'label': 'array_items_values',
+                    **convert_to_frontend_config(value.__args__[0], is_transaction=is_transaction),
+                },
+            }
+
+        if origin_class is dict:
+            return {
+                'type': 'dict',
+                'name': 'dict_items',
+                'label': 'dict_items',
+                'control': {
+                    'name': 'dict_items_values',
+                    'label': 'dict_items_values',
+                    **convert_to_frontend_config(value.__args__[1], is_transaction=is_transaction),
+                },
+            }
+
+    if isinstance(value, ForwardRef):
+        class_name = value.__forward_arg__
+        _class = ClassManager().import_class(class_name)
+
+        if issubclass(_class, Model):
+            return {
+                'entityType': value.__forward_arg__,
+            }
+
+        value = _class
+
+    if isinstance(value, UnionType):
+        _union = _process_union(value, is_transaction=is_transaction)
+
+        if 'entityType' in _union and _union['entityType'] == 'File':
+            _union['type'] = 'file'
+            del _union['entityType']
+
+        return _union
+
+    if value in default_types_map:
+        return {
+            'type': default_types_map[value],
+        }
+
+    if value is Any:
+        return {
+            'type': 'text',
+        }
+
+    if isinstance(value, FunctionType):
+        function_controls = []
+
+        while hasattr(value, '__wrapped__'):
+            value = value.__wrapped__
+
+        _signature = signature(value)
+        _parameters = _signature.parameters
+
+        for arg_name in _parameters:
+            if arg_name in value.__annotations__:
+                arg_type = value.__annotations__[arg_name]
+                control = convert_to_frontend_config(
+                    arg_type,
+                    is_transaction=True,
+                )
+
+                if not control:
+                    continue
+
+                control['name'] = arg_name
+                control['label'] = arg_name
+            else:
+                control = {
+                    'type': 'text',
+                    'name': arg_name,
+                    'label': arg_name,
+                }
+
+            control.setdefault('required', True)
+            _param = _parameters[arg_name]
+            if _param.default is not _empty:
+                control['value'] = _param.default
+                control['required'] = False
+
+            if not control['name'].startswith('_'):
+                function_controls.append(control)
+
+        return {
+            'type': 'group',
+            'name': value.__name__,
+            'label': value.__name__,
+            'controls': function_controls,
+        }
+
+    try:
+        if issubclass(value, Reference):
+            return {
+                'type': 'object_latest',
+            }
+    except TypeError:
+        return {}
+
+    if is_transaction and issubclass(value, Model):
+        if value.__name__ == 'File':
+            return {
+                'type': 'file',
+            }
+        return {
+            'type': 'object_latest',
+            'entityType': value.__name__,
+        }
+
+    if issubclass(value, LegacyModel):
+        return {}
+
+    if issubclass(value, BaseModel):
+        model_controls = []
+
+        try:
+            if issubclass(value, Model | TypeModel):
+                schema = model_to_object_schema(value)
+        except FileNotFoundError:
+            schema = None
+
+        if value.__name__ == 'File':
+            return {
+                'type': 'file',
+            }
+
+        for field_name, field in value.model_fields.items():
+            control = convert_to_frontend_config(field.annotation, is_transaction=is_transaction)
+
+            if not control:
+                continue
+
+            control.setdefault('required', True)
+
+            if field.default is not PydanticUndefined:
+                control['value'] = field.default
+
+            control['name'] = field_name
+            control['label'] = field_name
+
+            if schema and schema.properties and field_name in schema.properties:
+                schema_property = schema.properties[field_name]
+
+                if schema_property.options:
+                    control['options'] = [
+                        {
+                            'label': option.key,
+                            'value': option.value,
+                        }
+                        for option in schema_property.options
+                    ]
+                    if control.get('type') == 'text':
+                        control['type'] = 'select'
+
+                if schema_property.title:
+                    control['label'] = schema_property.title
+
+            if not control['name'].startswith('_'):
+                model_controls.append(control)
+
+        for m2m, (m2m_ref, _, _, field_info) in (getattr(value, MANY_TO_MANY_FIELDS, None) or {}).items():
+            pass
+            control = convert_to_frontend_config(list[Reference | m2m_ref], is_transaction=is_transaction)  # type: ignore[valid-type]
+
+            if getattr(field_info, 'default', PydanticUndefined) is not PydanticUndefined:
+                control['value'] = field_info.default
+
+            control['name'] = m2m
+            control['label'] = m2m
+            control['required'] = False
+            model_controls.append(control)
+
+        return {
+            'type': 'group',
+            'name': value.__name__,
+            'label': value.__name__,
+            'controls': model_controls,
+        }
+
+    try:
+        if issubclass(value, Enum):
+            return {
+                'type': 'select',
+                'options': [{'label': option.name, 'value': option.value} for option in value],
+            }
+    except TypeError:
+        pass
+
+    return {}

amsdal/contrib/frontend_configs/conversion/convert.pyi

@@ -0,0 +1,22 @@
+from _typeshed import Incomplete
+from types import UnionType
+from typing import Any
+
+default_types_map: Incomplete
+
+def _process_union(value: UnionType, *, is_transaction: bool = False) -> dict[str, Any]: ...
+def convert_to_frontend_config(value: Any, *, is_transaction: bool = False) -> dict[str, Any]:
+    """
+    Converts a given value to a frontend configuration dictionary.
+
+    This function takes a value and converts it into a dictionary that represents
+    the configuration for a frontend form control. It handles various types such as
+    Union, list, dict, BaseModel, and custom types.
+
+    Args:
+        value (Any): The value to be converted to frontend configuration.
+        is_transaction (bool, optional): Indicates if the conversion is for a transaction. Defaults to False.
+
+    Returns:
+        dict[str, Any]: A dictionary representing the frontend configuration for the given value.
+    """

amsdal/contrib/frontend_configs/lifecycle/consumer.py

@@ -0,0 +1,306 @@
+# mypy: disable-error-code="arg-type"
+import contextlib
+import logging
+from typing import Any
+
+from amsdal_models.classes.errors import AmsdalClassNotFoundError
+from amsdal_utils.lifecycle.consumer import LifecycleConsumer
+from amsdal_utils.models.data_models.address import Address
+from amsdal_utils.models.data_models.core import LegacyDictSchema
+from amsdal_utils.models.data_models.enums import CoreTypes
+from amsdal_utils.models.enums import Versions
+from amsdal_utils.schemas.schema import PropertyData
+
+logger = logging.getLogger(__name__)
+
+core_to_frontend_types = {
+    CoreTypes.NUMBER.value: 'number',
+    CoreTypes.INTEGER.value: 'integer',
+    CoreTypes.BOOLEAN.value: 'checkbox',
+    CoreTypes.STRING.value: 'text',
+    CoreTypes.ANYTHING.value: 'text',
+    CoreTypes.BINARY.value: 'text',
+    CoreTypes.DATE.value: 'date',
+    CoreTypes.DATETIME.value: 'datetime',
+}
+
+
+def process_property(field_name: str, property_data: PropertyData) -> dict[str, Any]:
+    """
+    Processes a property and converts it to a frontend configuration dictionary.
+
+    This function takes a field name and property data, and converts them into a dictionary
+    that represents the configuration for a frontend form control. It handles various types
+    such as core types, arrays, dictionaries, and files.
+
+    Args:
+        field_name (str): The name of the field to be processed.
+        property_data (PropertyData): The property data to be processed.
+
+    Returns:
+        dict[str, Any]: A dictionary representing the frontend configuration for the given property.
+    """
+    type_definition: dict[str, Any]
+    if property_data.type in core_to_frontend_types:
+        type_definition = {
+            'type': core_to_frontend_types[property_data.type],
+        }
+    elif property_data.type == CoreTypes.ARRAY.value:
+        type_definition = {
+            'type': 'array',
+            'control': process_property(f'{field_name}_items', property_data.items),  # type: ignore[arg-type]
+        }
+    elif property_data.type == CoreTypes.DICTIONARY.value:
+        if isinstance(property_data.items, LegacyDictSchema):
+            type_definition = {
+                'type': 'dict',
+                'control': process_property(
+                    f'{field_name}_items',
+                    PropertyData(
+                        type=property_data.items.key_type,
+                        items=None,
+                        title=None,
+                        read_only=False,
+                        options=None,
+                        default=None,
+                        field_name=field_name,
+                        field_id=None,
+                        is_deleted=False,
+                    ),
+                ),
+            }
+        else:
+            type_definition = {
+                'type': 'dict',
+                'control': process_property(
+                    f'{field_name}_items',
+                    property_data.items.key,  # type: ignore[union-attr, arg-type]
+                ),
+            }
+    elif property_data.type == 'File':
+        type_definition = {
+            'type': 'file',
+        }
+    else:
+        type_definition = {
+            'type': 'object_latest',
+            'entityType': property_data.type,
+        }
+
+    if getattr(property_data, 'default', None) is not None:
+        type_definition['value'] = property_data.default
+
+    if getattr(property_data, 'options', None) is not None:
+        type_definition['options'] = [
+            {
+                'label': option.key,
+                'value': option.value,
+            }
+            for option in property_data.options  # type: ignore[union-attr]
+        ]
+
+    return {
+        'name': field_name,
+        'label': property_data.title if hasattr(property_data, 'title') and property_data.title else field_name,
+        **type_definition,
+    }
+
+
+def populate_frontend_config_with_values(config: dict[str, Any], values: dict[str, Any]) -> dict[str, Any]:
+    """
+    Populates a frontend configuration dictionary with values.
+
+    This function takes a frontend configuration dictionary and a dictionary of values,
+    and populates the configuration with the corresponding values. It recursively processes
+    nested controls to ensure all values are populated.
+
+    Args:
+        config (dict[str, Any]): The frontend configuration dictionary to be populated.
+        values (dict[str, Any]): The dictionary of values to populate the configuration with.
+
+    Returns:
+        dict[str, Any]: The populated frontend configuration dictionary.
+    """
+    if config.get('controls') and isinstance(config['controls'], list):
+        for control in config['controls']:
+            populate_frontend_config_with_values(control, values)
+
+    if config.get('name') in values:
+        config['value'] = values[config['name']]
+
+    return config
+
+
+def get_values_from_response(response: dict[str, Any] | list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    Extracts values from a response dictionary or list of dictionaries.
+
+    This function processes a response to extract the relevant values. It checks if the response
+    is a dictionary containing a 'rows' key and processes the rows to find the appropriate values.
+    If the response is not in the expected format, it returns an empty dictionary.
+
+    Args:
+        response (dict[str, Any] | list[dict[str, Any]]): The response to extract values from.
+
+    Returns:
+        dict[str, Any]: A dictionary containing the extracted values.
+    """
+    if not isinstance(response, dict) or 'rows' not in response or not response['rows']:
+        return {}
+
+    for row in response['rows']:
+        if '_metadata' in row and row['_metadata'].get('next_version') is None:
+            return row
+
+    return response['rows'][0]
+
+
+def get_default_control(class_name: str) -> dict[str, Any]:
+    """
+    Retrieves the default frontend control configuration for a given class name.
+
+    This function attempts to import a class by its name from various schema types.
+    If the class is found, it converts it to a frontend configuration dictionary
+    and returns it. If the class is not found, it returns an empty dictionary.
+
+    Args:
+        class_name (str): The name of the class to retrieve the default control for.
+
+    Returns:
+        dict[str, Any]: A dictionary representing the frontend control configuration for the given class.
+    """
+    from amsdal_models.classes.class_manager import ClassManager
+
+    from amsdal.contrib.frontend_configs.conversion import convert_to_frontend_config
+    from amsdal.contrib.frontend_configs.models.frontend_control_config import (
+        FrontendControlConfig,  # type: ignore[import-not-found]
+    )
+    from amsdal.models.core.file import File
+
+    target_class = None
+    with contextlib.suppress(AmsdalClassNotFoundError):
+        target_class = ClassManager().import_class(class_name)
+
+    if not target_class:
+        return {}
+
+    if target_class is File:
+        config = {
+            'type': 'group',
+            'name': 'File',
+            'label': 'File',
+            'controls': [
+                {'label': 'Filename', 'name': 'filename', 'type': 'text', 'required': True},
+                {'label': 'Data', 'name': 'data', 'type': 'Bytes', 'required': True},
+                {'label': 'Size', 'name': 'size', 'type': 'number', 'required': False},
+            ],
+        }
+    else:
+        config = convert_to_frontend_config(target_class, is_transaction=False)
+
+    return FrontendControlConfig(**config).model_dump(
+        exclude_none=True,
+    )
+
+
+class ProcessResponseConsumer(LifecycleConsumer):
+    """
+    Consumer class for processing responses and populating frontend configurations.
+
+    This class extends the LifecycleConsumer and processes responses to populate
+    frontend configurations based on the class name and values extracted from the response.
+    """
+
+    def on_event(
+        self,
+        request: Any,
+        response: dict[str, Any],
+    ) -> None:
+        """
+        Handles the event by extracting the class name and values from the request and response,
+        and populates the frontend configuration accordingly.
+
+        Args:
+            request (Any): The request object containing query and path parameters.
+            response (dict[str, Any]): The response dictionary to be processed.
+
+        Returns:
+            None
+        """
+        from amsdal.contrib.frontend_configs.models.frontend_model_config import (
+            FrontendModelConfig,  # type: ignore[import-not-found]
+        )
+
+        class_name = None
+        values = {}
+        if hasattr(request, 'query_params') and 'class_name' in request.query_params:
+            class_name = request.query_params['class_name']
+
+        if hasattr(request, 'path_params') and 'address' in request.path_params:
+            class_name = Address.from_string(request.path_params['address']).class_name
+            values = get_values_from_response(response)
+
+        if class_name and isinstance(response, dict):
+            config = (
+                FrontendModelConfig.objects.all()
+                .first(
+                    class_name=class_name,
+                    _metadata__is_deleted=False,
+                    _address__object_version=Versions.LATEST,
+                )
+                .execute()
+            )
+
+            if config and config.control:
+                response['control'] = populate_frontend_config_with_values(
+                    config.control.model_dump(exclude_none=True), values
+                )
+            else:
+                response['control'] = populate_frontend_config_with_values(get_default_control(class_name), values)
+
+    async def on_event_async(
+        self,
+        request: Any,
+        response: dict[str, Any],
+    ) -> None:
+        """
+        Handles the event by extracting the class name and values from the request and response,
+        and populates the frontend configuration accordingly.
+
+        Args:
+            request (Any): The request object containing query and path parameters.
+            response (dict[str, Any]): The response dictionary to be processed.
+
+        Returns:
+            None
+        """
+        from amsdal.contrib.frontend_configs.models.frontend_model_config import (
+            FrontendModelConfig,  # type: ignore[import-not-found]
+        )
+
+        class_name = None
+        values = {}
+        if hasattr(request, 'query_params') and 'class_name' in request.query_params:
+            class_name = request.query_params['class_name']
+
+        if hasattr(request, 'path_params') and 'address' in request.path_params:
+            class_name = Address.from_string(request.path_params['address']).class_name
+            values = get_values_from_response(response)
+
+        if class_name and isinstance(response, dict):
+            config = (
+                await FrontendModelConfig.objects.all()
+                .first(
+                    class_name=class_name,
+                    _metadata__is_deleted=False,
+                    _address__object_version=Versions.LATEST,
+                )
+                .aexecute()
+            )
+
+            if config and config.control:
+                response['control'] = populate_frontend_config_with_values(
+                    config.control.model_dump(exclude_none=True), values
+                )
+            else:
+                response['control'] = populate_frontend_config_with_values(get_default_control(class_name), values)