adjango 0.3.6__py3-none-any.whl

adjango/adecorators.py

@@ -0,0 +1,170 @@
+# wwwadecorators.py
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from functools import wraps
+from time import time
+from typing import Callable, Any
+
+from asgiref.sync import sync_to_async
+from django.conf import settings
+from django.contrib.auth import REDIRECT_FIELD_NAME
+from django.core.handlers.asgi import ASGIRequest
+from django.http import HttpResponseNotAllowed, HttpResponse, QueryDict, RawPostDataException
+
+from adjango.conf import ADJANGO_CONTROLLERS_LOGGER_NAME, ADJANGO_CONTROLLERS_LOGGING
+from adjango.utils.base import AsyncAtomicContextManager
+from adjango.utils.common import traceback_str
+from adjango.utils.funcs import auser_passes_test
+
+
+def aforce_data(fn: Callable[..., Any]) -> Callable[..., Any]:
+    """
+    Асинхронный декоратор для объединения данных из POST, GET и JSON тела запроса.
+
+    :param fn: Асинхронная функция, которая будет обернута.
+
+    :return: Асинхронная функция, в которой объединены данные из разных частей запроса.
+
+    @usage:
+        @force_data
+        def my_view(request):
+            print(request.data)
+    """
+
+    @wraps(fn)
+    async def _wrapped_view(request: ASGIRequest, *args: Any, **kwargs: Any) -> HttpResponse:
+        if not hasattr(request, 'data'): request.data = {}
+        request.data.update(request.POST.dict() if isinstance(request.POST, QueryDict) else request.POST)
+        request.data.update(request.GET.dict() if isinstance(request.GET, QueryDict) else request.GET)
+        try:
+            json_data = json.loads(request.body.decode('utf-8'))
+            if isinstance(json_data, dict): request.data.update(json_data)
+        except (ValueError, TypeError, UnicodeDecodeError, RawPostDataException):
+            pass
+        return await fn(request, *args, **kwargs)
+
+    return _wrapped_view
+
+
+def aatomic(fn: Callable[..., Any]) -> Callable[..., Any]:
+    """
+    Асинхронный декоратор, который оборачивает представление в контекст менеджера транзакций.
+
+    @usage: @aatomic
+            async def my_view(request): ...
+    """
+
+    @wraps(fn)
+    async def _wrapped_view(request: ASGIRequest, *args: Any, **kwargs: Any) -> Any:
+        async with AsyncAtomicContextManager():
+            return await fn(request, *args, **kwargs)
+
+    return _wrapped_view
+
+
+def acontroller(
+        name: str | None = None,
+        logger: str = None,
+        log_name: bool = None,
+        log_time: bool = False
+) -> Callable[..., Any]:
+    """
+    Асинхронный контроллер с логированием и обработкой исключений.
+
+    :param name: Название контроллера.
+    :param logger: Имя логгера для записи сообщений.
+    :param log_name: Логировать имя контроллера.
+    :param log_time: Логировать время выполнения контроллера.
+
+    :return: Асинхронный контроллер с логированием и обработкой исключений.
+
+    @usage:
+        @acontroller
+        async def my_view(request):
+            ...
+    """
+
+    def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(fn)
+        async def inner(request: ASGIRequest, *args: Any, **kwargs: Any) -> Any:
+            log = logging.getLogger(logger or ADJANGO_CONTROLLERS_LOGGER_NAME)
+            fn_name = name or fn.__name__
+            start_time = None
+            if log_name or (log_name is None and ADJANGO_CONTROLLERS_LOGGING):
+                log.info(f'ACtrl: {request.method} | {fn_name}')
+
+            if log_time: start_time = time()
+            if settings.DEBUG:
+                result = await fn(request, *args, **kwargs)
+                if log_time:
+                    end_time = time()
+                    elapsed_time = end_time - start_time
+                    log.info(f"Execution time {fn_name}: {elapsed_time:.2f} seconds")
+                return result
+            else:
+                try:
+                    result = await fn(request, *args, **kwargs)
+                    if log_time:
+                        end_time = time()
+                        elapsed_time = end_time - start_time
+                        log.info(f"Execution time {fn_name}: {elapsed_time:.2f} seconds")
+                    return result
+                except Exception as e:
+                    log.critical(f"ERROR in {fn_name}: {traceback_str(e)}", exc_info=True)
+
+                    raise e
+
+        return inner
+
+    return decorator
+
+
+def aallowed_only(allowed_methods: list[str]) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """
+    Асинхронный декоратор для ограничения методов запроса.
+
+    :param allowed_methods: Список разрешенных методов (GET, POST и т.д.).
+
+    :return: Асинхронная функция, которая ограничивает вызов view-функции в зависимости от метода запроса.
+
+    @usage:
+        @aallowed_only(['GET', 'POST'])
+        async def my_view(request):
+            ...
+    """
+
+    def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
+        async def wrapped_view(request: ASGIRequest, *args: Any, **kwargs: Any) -> HttpResponse:
+            if request.method in allowed_methods:
+                if asyncio.iscoroutinefunction(fn):
+                    return await fn(request, *args, **kwargs)
+                else:
+                    return fn(request, *args, **kwargs)
+            else:
+                return HttpResponseNotAllowed(allowed_methods)
+
+        return wrapped_view
+
+    return decorator
+
+
+def alogin_required(
+        function: Callable[..., Any] | None = None,
+        redirect_field_name: str = REDIRECT_FIELD_NAME,
+        login_url: str | None = None,
+) -> Callable[..., Any]:
+    """
+    Asynchronous decorator for views that checks if the user is authenticated,
+    redirecting to the login page if necessary.
+    """
+    actual_decorator = auser_passes_test(
+        sync_to_async(lambda u: u.is_authenticated),
+        login_url=login_url,
+        redirect_field_name=redirect_field_name,
+    )
+    if function:
+        return actual_decorator(function)
+    return actual_decorator

adjango/apps.py

@@ -0,0 +1,9 @@
+# apps.py
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class ADjangoConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'adjango'
+    verbose_name = _('ADjango')

adjango/aserializers.py

@@ -0,0 +1,109 @@
+from typing import TypedDict, List
+
+try:
+    from rest_framework.serializers import ListSerializer as DRFListSerializer
+    from rest_framework.serializers import ModelSerializer as DRFModelSerializer
+    from rest_framework.serializers import Serializer as DRFSerializer
+    from rest_framework import status
+    from rest_framework.exceptions import APIException
+    from rest_framework.status import HTTP_400_BAD_REQUEST
+except ImportError:
+    pass
+from asgiref.sync import sync_to_async
+from django.utils.translation import gettext_lazy as _
+
+
+class FieldError(TypedDict):
+    field: str
+    message: str
+
+
+def serializer_errors_to_field_errors(serializer_errors) -> List[FieldError]:
+    field_errors = []
+    for field, messages in serializer_errors.items():
+        for message in messages:
+            field_errors.append(FieldError(
+                field=field,
+                message=_(message)
+            ))
+    return field_errors
+
+
+class DetailExceptionDict(TypedDict):
+    message: str
+    fields_errors: List[FieldError]
+
+
+class DetailAPIException(APIException):
+    status_code = status.HTTP_400_BAD_REQUEST
+
+    def __init__(self, detail: DetailExceptionDict, code: str = None, status_code: str = None):
+        if status_code is not None:
+            self.status_code = status_code
+        super().__init__(detail=detail, code=code or 'error')
+
+
+class SerializerErrors(DetailAPIException):
+    def __init__(self, serializer_errors: dict, code: str = None, status_code: str = HTTP_400_BAD_REQUEST,
+                 message: str = _('Correct the mistakes.')):
+        detail = DetailExceptionDict(
+            message=message,
+            fields_errors=serializer_errors_to_field_errors(serializer_errors)
+        )
+        super().__init__(detail=detail, code=code, status_code=status_code)
+
+
+class AListSerializer(DRFListSerializer):
+    @property
+    async def adata(self):
+        items_data = []
+        for item in self.instance:
+            serializer = self.child.__class__(item, context=self.context)
+            data = await serializer.adata
+            items_data.append(data)
+        return items_data
+
+
+class ASerializer(DRFSerializer):
+    async def asave(self, **kwargs):
+        return await sync_to_async(self.save)(**kwargs)
+
+    async def ais_valid(self, raise_exception=False, **kwargs):
+        is_valid = await sync_to_async(self.is_valid)(**kwargs)
+        if raise_exception and not is_valid:
+            raise SerializerErrors(self.errors)
+        return is_valid
+
+    @property
+    async def adata(self): return await sync_to_async(lambda: self.data)()
+
+    @property
+    async def avalid_data(self): return await sync_to_async(lambda: self.validated_data)()
+
+    @classmethod
+    def many_init(cls, *args, **kwargs):
+        kwargs['child'] = cls()
+        return AListSerializer(*args, **kwargs)
+
+
+class AModelSerializer(DRFModelSerializer):
+    async def asave(self, **kwargs):
+        return await sync_to_async(self.save)(**kwargs)
+
+    async def ais_valid(self, raise_exception=False, **kwargs):
+        is_valid = await sync_to_async(self.is_valid)(**kwargs)
+        if raise_exception and not is_valid: raise SerializerErrors(self.errors)
+        return is_valid
+
+    @property
+    async def adata(self):
+        return await sync_to_async(lambda: self.data)()
+
+    @property
+    async def avalid_data(self):
+        return await sync_to_async(lambda: self.validated_data)()
+
+    @classmethod
+    def many_init(cls, *args, **kwargs):
+        kwargs['child'] = cls()
+        return AListSerializer(*args, **kwargs)

adjango/conf.py

@@ -0,0 +1,26 @@
+# conf.py
+from django.conf import settings
+
+
+def get_setting(name, default=None, required=False):
+    value = getattr(settings, name, None)
+    if value is None:
+        if required:
+            if default is not None:
+                return default
+            raise ValueError(f'Missing required django setting: {name}')
+        return default
+    return value
+
+
+ADJANGO_BACKENDS_APPS = get_setting('ADJANGO_BACKENDS_APPS', settings.BASE_DIR)
+ADJANGO_FRONTEND_APPS = get_setting('ADJANGO_FRONTEND_APPS', settings.BASE_DIR)
+ADJANGO_APPS_PREPATH = get_setting('ADJANGO_APPS_PREPATH')
+ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION = get_setting(
+    'ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION',
+)
+ADJANGO_CONTROLLERS_LOGGER_NAME = get_setting('ADJANGO_CONTROLLERS_LOGGER_NAME', 'global')
+ADJANGO_CONTROLLERS_LOGGING = get_setting('ADJANGO_CONTROLLERS_LOGGING',)
+ADJANGO_EMAIL_LOGGER_NAME = get_setting('ADJANGO_EMAIL_LOGGER_NAME', 'email')
+ADJANGO_IP_LOGGER = get_setting('ADJANGO_IP_LOGGER')
+ADJANGO_IP_META_NAME = get_setting('ADJANGO_IP_META_NAME')

adjango/constants/times.py

@@ -0,0 +1,53 @@
+# constants/times.py
+MIN_1 = 1 * 60
+MIN_5 = 5 * 60
+MIN_10 = 10 * 60
+MIN_15 = 15 * 60
+MIN_20 = 20 * 60
+MIN_25 = 25 * 60
+MIN_30 = 30 * 60
+MIN_40 = 40 * 60
+MIN_50 = 50 * 60
+HOUR_1 = 1 * 60 * 60
+HOUR_2 = 2 * 60 * 60
+HOUR_3 = 3 * 60 * 60
+HOUR_4 = 4 * 60 * 60
+HOUR_5 = 5 * 60 * 60
+HOUR_6 = 6 * 60 * 60
+HOUR_7 = 7 * 60 * 60
+HOUR_8 = 8 * 60 * 60
+HOUR_9 = 9 * 60 * 60
+HOUR_10 = 10 * 60 * 60
+HOUR_11 = 11 * 60 * 60
+HOUR_12 = 12 * 60 * 60
+HOUR_13 = 13 * 60 * 60
+HOUR_14 = 14 * 60 * 60
+HOUR_15 = 15 * 60 * 60
+HOUR_16 = 16 * 60 * 60
+HOUR_17 = 17 * 60 * 60
+HOUR_18 = 18 * 60 * 60
+HOUR_19 = 19 * 60 * 60
+HOUR_20 = 20 * 60 * 60
+HOUR_21 = 21 * 60 * 60
+HOUR_22 = 22 * 60 * 60
+HOUR_23 = 23 * 60 * 60
+DAY_1 = 1 * 60 * 60 * 24
+DAYS_2 = 2 * 60 * 60 * 24
+DAYS_3 = 3 * 60 * 60 * 24
+DAYS_4 = 4 * 60 * 60 * 24
+DAYS_5 = 5 * 60 * 60 * 24
+DAYS_6 = 6 * 60 * 60 * 24
+DAYS_7 = 7 * 60 * 60 * 24
+DAYS_8 = 8 * 60 * 60 * 24
+DAYS_9 = 9 * 60 * 60 * 24
+DAYS_10 = 10 * 60 * 60 * 24
+DAYS_11 = 11 * 60 * 60 * 24
+DAYS_12 = 12 * 60 * 60 * 24
+DAYS_13 = 13 * 60 * 60 * 24
+DAYS_14 = 14 * 60 * 60 * 24
+DAYS_15 = 15 * 60 * 60 * 24
+DAYS_16 = 16 * 60 * 60 * 24
+DAYS_17 = 17 * 60 * 60 * 24
+DAYS_18 = 18 * 60 * 60 * 24
+DAYS_19 = 19 * 60 * 60 * 24
+DAYS_20 = 20 * 60 * 60 * 24

adjango/decorators.py

@@ -0,0 +1,195 @@
+# decorators.py
+from __future__ import annotations
+
+import json
+import logging
+from functools import wraps
+from time import time
+from typing import Callable, Any
+
+from django.conf import settings
+from django.core.handlers.wsgi import WSGIRequest
+from django.http import HttpResponseNotAllowed, HttpResponse, QueryDict, RawPostDataException
+from django.shortcuts import redirect
+
+from adjango.conf import ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION, ADJANGO_CONTROLLERS_LOGGING, \
+    ADJANGO_CONTROLLERS_LOGGER_NAME
+from adjango.utils.common import traceback_str
+
+
+def admin_description(description: str):
+    def decorator(func):
+        func.short_description = description
+        return func
+
+    return decorator
+
+
+def admin_label(label: str):
+    def decorator(func):
+        func.label = label
+        return func
+
+    return decorator
+
+
+def admin_order_field(field: str):
+    def decorator(func):
+        func.admin_order_field = field
+        return func
+
+    return decorator
+
+
+def admin_allow_tags(allow: bool = True):
+    def decorator(func):
+        func.allow_tags = allow
+        return func
+
+    return decorator
+
+
+def task(logger: str = None):
+    """
+    Декоратор для задач Celery, который логирует начало и конец выполнения задачи и её ошибки.
+
+    :param logger: Имя логгера для логирования. Если не передано, логирование не будет выполнено.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            log = None
+            if logger:
+                log = logging.getLogger(logger)
+                log.info(f"Start executing task: {func.__name__}\n{args}\n{kwargs}")
+            try:
+                result = func(*args, **kwargs)
+            except Exception as e:
+                log.critical(f'Error executing task: {func.__name__}')
+                log.critical(traceback_str(e))
+                raise e
+            if log: log.info(f"End executing task: {func.__name__}\n{args}\n{kwargs}")
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def allowed_only(allowed_methods: list[str]) -> Callable[[Callable[..., HttpResponse]], Callable[..., HttpResponse]]:
+    """
+    Декоратор для ограничения методов запроса.
+
+    :param allowed_methods: Список разрешенных методов (GET, POST и т.д.).
+
+    :return: Функция, которая ограничивает вызов view-функции в зависимости от метода запроса.
+
+    @usage:
+        @allowed_only(['GET', 'POST'])
+        def my_view(request):
+            ...
+    """
+
+    def decorator(fn: Callable[..., HttpResponse]) -> Callable[..., HttpResponse]:
+        def wrapped_view(request: WSGIRequest, *args: Any, **kwargs: Any) -> HttpResponse:
+            if request.method in allowed_methods:
+                return fn(request, *args, **kwargs)
+            else:
+                return HttpResponseNotAllowed(allowed_methods)
+
+        return wrapped_view
+
+    return decorator
+
+
+def force_data(fn: Callable[..., Any]) -> Callable[..., Any]:
+    """
+    Декоратор для объединения данных из POST, GET и JSON тела запроса.
+
+    :param fn: Функция, которая будет обернута.
+
+    :return: Функция, в которой объединены данные из разных частей запроса.
+
+    @usage:
+        @force_data
+        def my_view(request):
+            print(request.data)
+    """
+
+    @wraps(fn)
+    def _wrapped_view(request: WSGIRequest, *args: Any, **kwargs: Any) -> HttpResponse:
+        if not hasattr(request, 'data'): request.data = {}
+        request.data.update(request.POST.dict() if isinstance(request.POST, QueryDict) else request.POST)
+        request.data.update(request.GET.dict() if isinstance(request.GET, QueryDict) else request.GET)
+        try:
+            json_data = json.loads(request.body.decode('utf-8'))
+            if isinstance(json_data, dict): request.data.update(json_data)
+        except (ValueError, TypeError, UnicodeDecodeError, RawPostDataException):
+            pass
+        return fn(request, *args, **kwargs)
+
+    return _wrapped_view
+
+
+def controller(
+        name: str | None = None,
+        logger: str = None,
+        log_name: bool = True,
+        log_time: bool = False,
+        auth_required: bool = False,
+        not_auth_redirect: str = settings.LOGIN_URL
+) -> Callable[..., Any]:
+    """
+    Синхронный контроллер с логированием, проверкой аутентификации и обработкой исключений.
+
+    :param name: Название контроллера.
+    :param logger: Имя логгера для записи сообщений.
+    :param log_name: Логировать имя контроллера.
+    :param log_time: Логировать время выполнения контроллера.
+    :param auth_required: Проверять ли аутентификацию пользователя.
+    :param not_auth_redirect: URL для редиректа, если пользователь не аутентифицирован.
+
+    :return: Синхронный контроллер с логированием и обработкой исключений.
+
+    @usage:
+        @controller
+        def my_view(request):
+            ...
+    """
+
+    def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(fn)
+        def inner(request: WSGIRequest, *args: Any, **kwargs: Any) -> Any:
+            log = logging.getLogger(logger or ADJANGO_CONTROLLERS_LOGGER_NAME)
+            fn_name = name or fn.__name__
+            start_time = None
+            if log_name or (log_name is None and ADJANGO_CONTROLLERS_LOGGING):
+                log.info(f'Ctrl: {request.method} | {fn_name}')
+            if log_time: start_time = time()
+            if auth_required and not request.user.is_authenticated: return redirect(not_auth_redirect)
+            if settings.DEBUG:
+                result = fn(request, *args, **kwargs)
+                if log_time:
+                    end_time = time()
+                    elapsed_time = end_time - start_time
+                    log.info(f"Execution time {fn_name}: {elapsed_time:.2f} seconds")
+                return result
+            else:
+                try:
+                    result = fn(request, *args, **kwargs)
+                    if log_time:
+                        end_time = time()
+                        elapsed_time = end_time - start_time
+                        log.info(f"Execution time {fn_name}: {elapsed_time:.2f} seconds")
+                    return result
+                except Exception as e:
+                    log.critical(f"ERROR in {fn_name}: {traceback_str(e)}", exc_info=True)
+                    if hasattr(settings, 'ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION'):
+                        handling_function = ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION
+                        if callable(handling_function): handling_function(fn_name, request, e, *args, **kwargs)
+                    raise e
+
+        return inner
+
+    return decorator

adjango/descriptors.py

@@ -0,0 +1,17 @@
+# descriptors.py
+from django.db.models.fields.related_descriptors import ManyToManyDescriptor
+
+from adjango.managers.base import AManager
+
+
+class AManyToManyDescriptor(ManyToManyDescriptor):
+    @property
+    def related_manager_cls(self):
+        # Get the original related_manager_cls
+        original_manager_cls = super().related_manager_cls
+
+        # Define a new manager class that extends the original and adds the 'aall' method
+        class AManyRelatedManager(original_manager_cls, AManager):
+            pass
+
+        return AManyRelatedManager

adjango/fields.py

@@ -0,0 +1,11 @@
+# fields.py
+from django.db.models import ManyToManyField
+
+from adjango.descriptors import AManyToManyDescriptor
+
+
+class AManyToManyField(ManyToManyField):
+    def contribute_to_class(self, cls, name, **kwargs):
+        super().contribute_to_class(cls, name, **kwargs)
+        # Replace the descriptor with our custom one
+        setattr(cls, self.name, AManyToManyDescriptor(self.remote_field, reverse=False))

adjango/handlers.py

@@ -0,0 +1,74 @@
+# handlers.py
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from django.core.handlers.asgi import ASGIRequest
+from django.core.handlers.wsgi import WSGIRequest
+
+from adjango.utils.common import traceback_str
+
+
+class IHandlerControllerException(ABC):
+    @staticmethod
+    @abstractmethod
+    def handle(fn_name: str, request: WSGIRequest | ASGIRequest, e: Exception, *args, **kwargs) -> None:
+        """
+        Пример функции обработки исключений.
+
+        :param fn_name: Имя функции, в которой произошло исключение.
+        :param request: Объект запроса (WSGIRequest или ASGIRequest).
+        :param e: Исключение, которое нужно обработать.
+        :param args: Позиционные аргументы, переданные в функцию.
+        :param kwargs: Именованные аргументы, переданные в функцию.
+
+        :return: None
+
+        @usage:
+            _handling_function(fn_name, request, e)
+        """
+        pass
+
+
+class HCE(IHandlerControllerException):
+    """
+    Пример реализации обработчика исключений контроллеров.
+    """
+
+    @staticmethod
+    def handle(fn_name: str, request: WSGIRequest | ASGIRequest, e: Exception, *args, **kwargs) -> None:
+        """
+        Пример функции обработки исключений.
+
+        :param fn_name: Имя функции, в которой произошло исключение.
+        :param request: Объект запроса (WSGIRequest или ASGIRequest).
+        :param e: Исключение, которое нужно обработать.
+        :param args: Позиционные аргументы, переданные в функцию.
+        :param kwargs: Именованные аргументы, переданные в функцию.
+
+        :return: None
+
+        @usage:
+            _handling_function(fn_name, request, e)
+        """
+        import logging
+        from django.conf import settings
+        from adjango.tasks import send_emails_task
+        log = logging.getLogger('global')
+        error_text = (f'ERROR in {fn_name}:\n'
+                      f'{traceback_str(e)}\n'
+                      f'{request.POST=}\n'
+                      f'{request.GET=}\n'
+                      f'{request.FILES=}\n'
+                      f'{request.COOKIES=}\n'
+                      f'{request.user=}\n'
+                      f'{args=}\n'
+                      f'{kwargs=}')
+        log.error(error_text)
+        if not settings.DEBUG:
+            send_emails_task.delay(
+                subject='SERVER ERROR',
+                emails=('admin@example.com', 'admin2@example.com',),
+                template='admin/exception_report.html',
+                context={'error': error_text}
+            )