amsdal 0.2.5__cp312-cp312-win_amd64.whl

amsdal/contrib/auth/models/user/hooks/post_init.py

@@ -0,0 +1,58 @@
+from typing import Any
+
+
+def post_init(self, *, is_new_object: bool, kwargs: dict[str, Any]) -> None:  # type: ignore[no-untyped-def]
+    """
+    Post-initializes a user object by validating email and password, and hashing the password.
+
+    This method checks if the email and password are provided and valid. If the object is new,
+    it hashes the password and sets the object ID to the lowercased email.
+
+    Args:
+        is_new_object (bool): Indicates if the object is new.
+        kwargs (dict[str, Any]): The keyword arguments containing user details.
+
+    Raises:
+        UserCreationError: If the email or password is invalid.
+    """
+    import bcrypt
+
+    from amsdal.contrib.auth.errors import UserCreationError
+
+    email = kwargs.get('email', None)
+    password = kwargs.get('password', None)
+
+    if email is None or email == '':
+        msg = "Email can't be empty"
+        raise UserCreationError(msg)
+
+    if password is None or password == '':
+        msg = "Password can't be empty"
+        raise UserCreationError(msg)
+
+    kwargs['email'] = email.lower()
+
+    if is_new_object and '_metadata' not in kwargs:
+        hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
+        self.password = hashed_password
+        self._object_id = email.lower()
+        self.get_metadata().address.object_id = self._object_id
+
+
+def pre_update(self) -> None:  # type: ignore[no-untyped-def]
+    import bcrypt
+
+    original_object = self.refetch_from_db()
+
+    password = self.password
+
+    if original_object.password and password is not None:
+        if isinstance(password, str):
+            password = password.encode('utf-8')
+
+        try:
+            if not bcrypt.checkpw(password, original_object.password):
+                self.password = password
+        except ValueError:
+            hashed_password = bcrypt.hashpw(password, bcrypt.gensalt())
+            self.password = hashed_password

amsdal/contrib/auth/models/user/hooks/pre_create.py

@@ -0,0 +1,8 @@
+def pre_create(self) -> None:  # type: ignore[no-untyped-def]
+    """
+    Pre-creates a user object.
+
+    This method is a placeholder for any pre-creation logic that needs to be executed
+    before a user object is created.
+    """
+    pass

amsdal/contrib/auth/models/user/model.json

@@ -0,0 +1,25 @@
+{
+  "title": "User",
+  "type": "object",
+  "properties": {
+    "email": {
+      "title": "Email",
+      "type": "string"
+    },
+    "password": {
+      "title": "Password (hash)",
+      "type": "binary"
+    },
+    "permissions": {
+      "title": "Permissions",
+      "type": "array",
+      "items": {
+        "type": "Permission"
+      }
+    }
+  },
+  "required": [
+    "email",
+    "password"
+  ]
+}

amsdal/contrib/auth/models/user/modifiers/display_name.py

@@ -0,0 +1,19 @@
+@property  # type: ignore[misc]
+def display_name(self) -> str:  # type: ignore[no-untyped-def]
+    """
+    Returns the display name of the user.
+
+    This method returns the email of the user as their display name.
+
+    Returns:
+        str: The email of the user.
+    """
+    return self.email
+
+
+def __str__(self) -> str:  # type: ignore[no-untyped-def]  # noqa: N807
+    return f'User(email={self.email})'
+
+
+def __repr__(self) -> str:  # type: ignore[no-untyped-def]  # noqa: N807
+    return str(self)

amsdal/contrib/auth/settings.py

@@ -0,0 +1,36 @@
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    Settings configuration for the application.
+
+    This class uses Pydantic's BaseSettings to manage application settings
+    from environment variables and a .env file.
+
+    Attributes:
+        model_config (SettingsConfigDict): Configuration for Pydantic settings.
+        ADMIN_USER_EMAIL (str | None): The email of the admin user.
+        ADMIN_USER_PASSWORD (str | None): The password of the admin user.
+        AUTH_JWT_KEY (str | None): The key used for JWT authentication.
+        AUTH_TOKEN_EXPIRATION (int): The expiration time for authentication tokens in seconds.
+        REQUIRE_DEFAULT_AUTHORIZATION (bool): Flag to require default authorization.
+    """
+
+    model_config = SettingsConfigDict(
+        case_sensitive=True,
+        env_prefix='AMSDAL_',
+        env_file='.env',
+        env_file_encoding='utf-8',
+        extra='ignore',
+    )
+
+    ADMIN_USER_EMAIL: str | None = None
+    ADMIN_USER_PASSWORD: str | None = None
+    AUTH_JWT_KEY: str | None = None
+    AUTH_TOKEN_EXPIRATION: int = 86400
+    REQUIRE_DEFAULT_AUTHORIZATION: bool = True
+
+
+auth_settings = Settings()

amsdal/contrib/auth/settings.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    """
+    Settings configuration for the application.
+
+    This class uses Pydantic's BaseSettings to manage application settings
+    from environment variables and a .env file.
+
+    Attributes:
+        model_config (SettingsConfigDict): Configuration for Pydantic settings.
+        ADMIN_USER_EMAIL (str | None): The email of the admin user.
+        ADMIN_USER_PASSWORD (str | None): The password of the admin user.
+        AUTH_JWT_KEY (str | None): The key used for JWT authentication.
+        AUTH_TOKEN_EXPIRATION (int): The expiration time for authentication tokens in seconds.
+        REQUIRE_DEFAULT_AUTHORIZATION (bool): Flag to require default authorization.
+    """
+    model_config: Incomplete
+    ADMIN_USER_EMAIL: str | None
+    ADMIN_USER_PASSWORD: str | None
+    AUTH_JWT_KEY: str | None
+    AUTH_TOKEN_EXPIRATION: int
+    REQUIRE_DEFAULT_AUTHORIZATION: bool
+
+auth_settings: Incomplete

amsdal/contrib/frontend_configs/app.py

@@ -0,0 +1,24 @@
+from amsdal_utils.lifecycle.producer import LifecycleProducer
+
+from amsdal.contrib.app_config import AppConfig
+from amsdal.contrib.frontend_configs.constants import ON_RESPONSE_EVENT
+from amsdal.contrib.frontend_configs.lifecycle.consumer import ProcessResponseConsumer
+
+
+class FrontendConfigAppConfig(AppConfig):
+    """
+    Application configuration class for frontend configurations.
+
+    This class extends the AppConfig and sets up listeners for lifecycle events
+    to process frontend configurations.
+    """
+
+    def on_ready(self) -> None:
+        """
+        Registers a listener for the ON_RESPONSE_EVENT to process responses
+        using the ProcessResponseConsumer.
+
+        Returns:
+            None
+        """
+        LifecycleProducer.add_listener(ON_RESPONSE_EVENT, ProcessResponseConsumer)  # type: ignore[arg-type]

amsdal/contrib/frontend_configs/app.pyi

@@ -0,0 +1,19 @@
+from amsdal.contrib.app_config import AppConfig as AppConfig
+from amsdal.contrib.frontend_configs.constants import ON_RESPONSE_EVENT as ON_RESPONSE_EVENT
+from amsdal.contrib.frontend_configs.lifecycle.consumer import ProcessResponseConsumer as ProcessResponseConsumer
+
+class FrontendConfigAppConfig(AppConfig):
+    """
+    Application configuration class for frontend configurations.
+
+    This class extends the AppConfig and sets up listeners for lifecycle events
+    to process frontend configurations.
+    """
+    def on_ready(self) -> None:
+        """
+        Registers a listener for the ON_RESPONSE_EVENT to process responses
+        using the ProcessResponseConsumer.
+
+        Returns:
+            None
+        """

amsdal/contrib/frontend_configs/constants.py

@@ -0,0 +1 @@
+ON_RESPONSE_EVENT = 'on_response'

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,250 @@
+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 amsdal_models.classes.manager import ClassManager
+from amsdal_models.classes.model import LegacyModel
+from amsdal_models.classes.model import Model
+from amsdal_utils.models.data_models.reference import Reference
+from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
+
+from amsdal.schemas.manager import SchemaManager
+
+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 value.__args__:
+        if arg is type(None):
+            arg_type['required'] = False
+            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.
+    """
+    if hasattr(value, '__origin__'):
+        origin_class = value.__origin__
+
+        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, ClassManager().resolve_schema_type(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
+
+            function_controls.append(control)
+
+        return {
+            'type': 'group',
+            'name': value.__name__,
+            'label': value.__name__,
+            'controls': function_controls,
+        }
+
+    if issubclass(value, Reference):
+        return {
+            'type': 'object_latest',
+        }
+
+    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:
+            schema = SchemaManager().get_schema_by_name(value.__name__)
+        except FileNotFoundError:
+            schema = None
+
+        for field_name, field in value.__annotations__.items():
+            control = convert_to_frontend_config(field, is_transaction=is_transaction)
+
+            if not control:
+                continue
+
+            control.setdefault('required', True)
+
+            if field_name in value.model_fields:
+                _field = value.model_fields[field_name]
+
+                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
+
+            model_controls.append(control)
+
+        return {
+            'type': 'group',
+            'name': value.__name__,
+            'label': value.__name__,
+            'controls': model_controls,
+        }
+
+    if issubclass(value, Enum):
+        return {
+            'type': 'select',
+            'options': [{'label': option.name, 'value': option.value} for option in value],
+        }
+
+    return {}

amsdal/contrib/frontend_configs/conversion/convert.pyi

@@ -0,0 +1,23 @@
+from _typeshed import Incomplete
+from amsdal.schemas.manager import SchemaManager as SchemaManager
+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.
+    """