csu 1.0.0__py3-none-any.whl

csu/__init__.py

@@ -0,0 +1,5 @@
+"""
+a.k.a Clean Slate Utils
+"""
+
+__version__ = "1.0.0"

csu/admin.py

@@ -0,0 +1,116 @@
+from django.contrib.admin import DateFieldListFilter
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.db.models import Choices
+from django.db.models.expressions import Col
+from django.db.models.lookups import Exact
+from django.db.models.sql import AND
+from django.utils.encoding import force_str
+from django.utils.tree import Node
+from import_export.fields import Field
+from import_export.resources import ModelResource
+from import_export.widgets import Widget
+from rest_framework import serializers
+
+from .timezones import today
+
+
+class PastDateListFilter(DateFieldListFilter):
+    def __init__(self, field, request, params, model, model_admin, field_path):
+        super().__init__(field, request, params, model, model_admin, field_path)
+        self.links = [
+            (label, {self.lookup_kwarg_until: filters[self.lookup_kwarg_since]} if self.lookup_kwarg_until in filters else filters)
+            for label, filters in self.links
+        ]
+
+
+def repr_expr(obj):
+    if isinstance(obj, Exact):
+        return f"{repr_expr(obj.lhs)}={repr_expr(obj.rhs)}"
+    elif isinstance(obj, Col):
+        return obj.target.column
+    elif isinstance(obj, Node):
+        if obj.connector == AND:
+            return "-".join(map(repr_expr, obj.children))
+        else:
+            return "~".join(map(repr_expr, obj.children))
+    else:
+        return str(obj)
+
+
+class FullFilenameExportAdminMixin:
+    model: models.Model
+
+    def get_export_filename(self, request, queryset: models.QuerySet, file_format):
+        filters = repr_expr(queryset.query.where)
+        filename = "{}-{}-{}-{}.{}".format(
+            self.model._meta.app_label,
+            self.model._meta.verbose_name_plural.replace(" ", "-").replace("/", "-"),
+            today().isoformat(),
+            filters or "all",
+            file_format.get_extension(),
+        )
+        return filename
+
+
+class ChoiceWidget(Widget):
+    def __init__(self, choice_class: type[Choices]):
+        self.choice_class = choice_class
+
+    def render(self, value, obj=None):
+        if value in self.choice_class:
+            return self.choice_class(value).name
+        else:
+            return value
+
+    def clean(self, value, row=None, **kwargs):
+        if value in self.choice_class:
+            return self.choice_class[value]
+
+
+class SmartField(Field):
+    def clean(self, data, **kwargs):
+        """
+        Perform exception wrapping early here (instead of letting import_obj do it).
+        Apparently that behavior is completely missing from (for import_id_fields).
+        """
+        try:
+            return super().clean(data, **kwargs)
+        except ValueError as e:
+            raise ValidationError({self.attribute: force_str(e)}, code="invalid") from e
+
+
+def widget_passthrough(widget_instance):
+    def widget_trampoline(key_is_id=None, **kwargs):
+        assert not kwargs, f"no widget kwargs are allowed but we got: {kwargs!r}"
+        return widget_instance
+
+    return widget_trampoline
+
+
+def widget_for_drf_field(drf_field: serializers.Field):
+    class WidgetWrapper(Widget):
+        def clean(self, value, row=None, **kwargs):
+            try:
+                return drf_field.run_validation(value)
+            except serializers.ValidationError as exc:
+                raise ValueError(*map(str, exc.detail)) from None
+
+    return WidgetWrapper()
+
+
+class SmartModelResource(ModelResource):
+    DEFAULT_RESOURCE_FIELD = SmartField
+
+    @classmethod
+    def widget_kwargs_for_field(self, *args):
+        return {}
+
+    @classmethod
+    def widget_from_django_field(cls, f: models.Field, *args, **kwargs):
+        name = f.name
+        widgets = cls._meta.widgets or ()
+        if name in widgets:
+            return widget_passthrough(widgets[name])
+        else:
+            return widget_passthrough(super().widget_from_django_field(f, *args, **kwargs)())

csu/conf.py

@@ -0,0 +1,19 @@
+from datetime import datetime
+from datetime import timezone
+from importlib.util import find_spec
+from zoneinfo import ZoneInfo
+
+if find_spec("django"):
+    from django.conf import settings
+else:
+    settings = None
+
+WSGI_BUFFER_INPUT_LIMIT = int(getattr(settings, "DATA_UPLOAD_MAX_MEMORY_SIZE", 25 * 1024 * 1024))
+DRF_BEARER_TOKEN = getattr(settings, "BEARER_API_TOKEN", None)
+
+UTC = timezone.utc
+
+if hasattr(settings, "TIME_ZONE"):
+    TIME_ZONE = ZoneInfo(settings.TIME_ZONE)
+else:
+    TIME_ZONE = datetime.now(UTC).astimezone().tzinfo

csu/consts.py

@@ -0,0 +1,70 @@
+import re
+
+# Fields stuff.
+CYRILLIC_CONVERSION_TABLE = str.maketrans(
+    {
+        "А": "A",
+        "В": "B",
+        "Е": "E",
+        "К": "K",
+        "М": "M",
+        "Н": "H",
+        "О": "O",
+        "Р": "P",
+        "С": "C",
+        "Т": "T",
+        "У": "Y",
+        "Х": "X",
+        # lowercase
+        "а": "A",
+        "в": "B",
+        "е": "E",
+        "к": "K",
+        "м": "M",
+        "н": "H",
+        "о": "O",
+        "р": "P",
+        "с": "C",
+        "т": "T",
+        "у": "Y",
+        "х": "X",
+    }
+)
+NON_WORD_RE = re.compile(r"[^a-zA-Z0-9]+")
+NON_DIGIT_RE = re.compile(r"[^0-9]+")
+SPACES_RE = re.compile(r"\s+")
+REGISTRATION_NUMBER_RE = {
+    "HU": re.compile(r"^(?=(CD)?.{6,7}$)[A-Z][A-Z]*[0-9]+$"),
+    "RO": re.compile(
+        r"""^(
+            (MAI|A|CD|TC|FA|ALA)\d{1,6}
+            |
+            (AB|AG|AR|BC|BH|BN|BR|BT|BV|BZ|CJ|CL|CS|CT|CV|DB|DJ|GJ|GL|GR|
+             HD|HR|IF|IL|IS|MH|MM|MS|NT|OT|PH|SB|SJ|SM|SV|TL|TM|TR|VL|VN|VS)
+            (
+                (?!00)\d{2}[A-Z]{3}
+            )
+            |
+            B(
+                (?!00)[0-9]{2}[A-Z]{3}
+                |
+                (?!0)[0-9]{3}[A-Z]{3}
+            )
+        )$""",
+        re.VERBOSE,
+    ),
+}
+
+# Logging stuff.
+LINE_LENGTH = 140
+THICK_LINE = "=" * LINE_LENGTH
+CONTEXT_LINE = " context ".center(LINE_LENGTH, "-")
+REQUEST_CONTENT_LINE = " request content ".center(LINE_LENGTH, "-")
+REQUEST_DATA_LINE = " request data ".center(LINE_LENGTH, "-")
+REQUEST_OVERSIZE_LINE = " request oversize (first 10kb) ".center(LINE_LENGTH, "-")
+RESPONSE_CONTENT_LINE = " response content ".center(LINE_LENGTH, "-")
+RESPONSE_DATA_LINE = " response data ".center(LINE_LENGTH, "-")
+RESPONSE_EXCEPTION_LINE = " response exception ".center(LINE_LENGTH, "-")
+RESPONSE_LINE = " response ".center(LINE_LENGTH, "-")
+RESPONSE_UNKNOWN_LINE = " response (unknown) ".center(LINE_LENGTH, "-")
+TRACEBACK_LINE = " traceback ".center(LINE_LENGTH, "-")

csu/drf/auth.py

@@ -0,0 +1,71 @@
+from hmac import compare_digest
+
+from asgiref.sync import sync_to_async
+from rest_framework import exceptions
+from rest_framework.authentication import BaseAuthentication
+from rest_framework.authentication import SessionAuthentication as BaseSessionAuthentication
+from rest_framework.authentication import get_authorization_header
+from rest_framework.permissions import BasePermission
+from rest_framework.request import Request
+
+from ..conf import DRF_BEARER_TOKEN
+from ..gettext_lazy import _
+
+
+class AnyAuthentication(BasePermission):
+    """
+    Allows access only to authenticated users.
+    """
+
+    def has_permission(self, request, view):
+        return bool(request.user and request.user.is_authenticated or request.auth)
+
+
+class BearerTokenAuthentication(BaseAuthentication):
+    """
+    Simple token based authentication.
+
+    Clients should authenticate by passing the token key in the "Authorization"
+    HTTP header, prepended with the string "Token ".  For example:
+
+        Authorization: Bearer 401f7ac837da42b97f613d789819ff93537bee6a
+    """
+
+    keyword = "Bearer"
+    keyword_test = keyword.lower().encode()
+    expected_token_value = DRF_BEARER_TOKEN
+
+    async def aauthenticate(self, request: Request):
+        return self.authenticate(request)
+
+    def authenticate(self, request: Request):
+        auth = get_authorization_header(request).split()
+
+        if not auth or auth[0].lower() != self.keyword_test:
+            return None
+
+        if len(auth) == 1:
+            raise exceptions.AuthenticationFailed(_("Invalid Authorization header: no credentials provided."))
+        elif len(auth) > 2:
+            raise exceptions.AuthenticationFailed(_("Invalid Authorization header: token contains spaces."))
+
+        try:
+            token = auth[1].decode()
+        except UnicodeError:
+            raise exceptions.AuthenticationFailed(_("Invalid Authorization header: token contains invalid characters.")) from None
+
+        if compare_digest(token, self.expected_token_value):
+            return None, token
+        else:
+            raise exceptions.AuthenticationFailed(_("Invalid Authorization header: token invalid."))
+
+    def authenticate_header(self, request):
+        return self.keyword
+
+
+class SessionAuthentication(BaseSessionAuthentication):
+    async def aauthenticate(self, request: Request):
+        return await sync_to_async(self.authenticate, thread_sensitive=False)(request)
+
+    def authenticate(self, request: Request):
+        return super().authenticate(request)

csu/drf/fields.py

@@ -0,0 +1,203 @@
+from zoneinfo import ZoneInfo
+
+from django.conf import settings
+from django.core.validators import RegexValidator
+from django.db.models import Choices
+from rest_framework import serializers
+from rest_framework.fields import CharField
+from rest_framework.fields import ChoiceField
+from rest_framework.fields import ReadOnlyField
+from rest_framework.relations import HyperlinkedRelatedField
+
+from ..consts import CYRILLIC_CONVERSION_TABLE
+from ..consts import NON_DIGIT_RE
+from ..consts import NON_WORD_RE
+from ..consts import REGISTRATION_NUMBER_RE
+from ..consts import SPACES_RE
+from ..gettext_lazy import _
+from ..timezones import adjust_dt
+
+
+class AsciiCharField(CharField):
+    default_error_messages = {
+        **CharField.default_error_messages,
+        "non_ascii": _("Ensure this field has only latin characters."),
+    }
+    # Allowed cyrillic characters
+    cyrillic_conversion_table = CYRILLIC_CONVERSION_TABLE
+    non_word_re = NON_WORD_RE
+    spaces_re = SPACES_RE
+
+    def __init__(self, *, uppercase=False, only_alphanumerics=False, normalize_spaces=True, translate_cyrillics=True, **kwargs):
+        super().__init__(**kwargs)
+        self.uppercase = uppercase
+        self.translate_cyrillics = translate_cyrillics
+        self.only_alphanumerics = only_alphanumerics
+        self.normalize_spaces = normalize_spaces
+
+    def to_internal_value(self, value):
+        value: str = super().to_internal_value(value)
+        if self.translate_cyrillics:
+            value = value.translate(self.cyrillic_conversion_table)
+        try:
+            value.encode("ascii")
+        except UnicodeEncodeError:
+            self.fail("non_ascii")
+        if self.only_alphanumerics:
+            value = self.non_word_re.sub("", value)
+        elif self.normalize_spaces:
+            value = self.spaces_re.sub(" ", value)
+        if self.uppercase:
+            value = value.upper()
+        return value
+
+
+class DigitsCharField(AsciiCharField):
+    default_error_messages = {
+        **CharField.default_error_messages,
+        "non_digit": _("Ensure this field has only digits."),
+    }
+    non_word_re = NON_DIGIT_RE
+
+    def __init__(self, *, strip=True, **kwargs):
+        super().__init__(**kwargs, only_alphanumerics=strip)
+
+    def to_internal_value(self, value):
+        value: str = super().to_internal_value(value)
+        if not value.isdigit():
+            self.fail("non_digit")
+        return value
+
+
+class RegistrationNumberField(AsciiCharField):
+    def __init__(self, **kwargs):
+        max_length = kwargs.pop("max_length", 10)
+        super().__init__(
+            **kwargs,
+            max_length=max_length,
+            only_alphanumerics=True,
+            uppercase=True,
+        )
+
+
+class RomanianRegistrationNumberField(RegistrationNumberField):
+    def __init__(self, **kwargs):
+        super().__init__(
+            **kwargs,
+            validators=[
+                RegexValidator(
+                    regex=REGISTRATION_NUMBER_RE["RO"],
+                    message=_("Value must be a valid Romanian registration number."),
+                )
+            ],
+        )
+
+
+class ChassisNumberField(AsciiCharField):
+    default_error_messages = {
+        **AsciiCharField.default_error_messages,
+        "length": _("Chassis number must have {required_length} characters ({length} given)."),
+        "letter": _("Chassis number cannot contain the letter '{letter}'."),
+    }
+
+    def __init__(self, required_length=17, **kwargs):
+        super().__init__(
+            **kwargs,
+            only_alphanumerics=True,
+            uppercase=True,
+        )
+        self.required_length = required_length
+
+    def to_internal_value(self, value):
+        value = super().to_internal_value(value)
+        length = len(value)
+        if self.required_length and length != self.required_length:
+            self.fail("length", length=length, required_length=self.required_length)
+        if "I" in value:
+            self.fail("letter", letter="i")
+        if "O" in value:
+            self.fail("letter", letter="o")
+        if "Q" in value:
+            self.fail("letter", letter="q")
+
+        return value
+
+
+class EnumField(ChoiceField):
+    default_error_messages = {
+        "invalid_choice": _('"{input}" is not a valid choice. Must be one of: {opts}.'),
+        "invalid_choice_multiple": _('"{input}" is not a valid choice. Must be one of: {opts} or {last_opt}.'),
+    }
+
+    def __init__(self, *, enum: type[Choices], **kwargs):
+        super().__init__(
+            choices=[("", "-") if name == "__empty__" else (name, enum[name].label) for name in enum.names],
+            **kwargs,
+        )
+        self.enum = enum
+
+    def to_representation(self, value):
+        return self.enum(value).name
+
+    def to_internal_value(self, data):
+        if data in self.enum.names:
+            return self.enum[data]
+        else:
+            *opts, last_opt = self.enum
+            opts = ", ".join(f'"{i.name}"' for i in opts)
+            last_opt = f'"{last_opt.name}"'
+            if opts:
+                self.fail("invalid_choice_multiple", input=data, opts=opts, last_opt=last_opt)
+            else:
+                self.fail("invalid_choice", input=data, opts=last_opt)
+
+
+class FormattedField(ReadOnlyField):
+    format: str
+
+    def __init__(self, *, format=None, **kwargs):
+        self.format = format
+        super().__init__(**kwargs, read_only=True)
+
+    def to_representation(self, value):
+        # noinspection StrFormat
+        return self.format.format(value)
+
+
+class DispatchingHyperlinkedRelatedField(HyperlinkedRelatedField):
+    def __init__(self, *, dispatch_field, dispatch_mapping, **kwargs):
+        kwargs["read_only"] = True
+        kwargs["source"] = "*"
+        super().__init__(lookup_field=dispatch_field, view_name=dispatch_mapping, **kwargs)
+
+    def use_pk_only_optimization(self):
+        return False
+
+    def get_url(self, obj, view_name, request, format):
+        dispatch_value = getattr(obj, self.lookup_field)
+        view_options = view_name[dispatch_value]
+        lookup_value = getattr(obj, view_options["lookup_field"])
+        kwargs = {view_options["lookup_url_kwarg"]: lookup_value}
+        return self.reverse(view_options["view_name"], kwargs=kwargs, request=request, format=format)
+
+
+class LocalizedTimeField(serializers.DateTimeField):
+    def __init__(self, *args, timezone: str | ZoneInfo = settings.TIME_ZONE, **kwargs):
+        self.timezone = ZoneInfo(timezone) if isinstance(timezone, str) else timezone
+        super().__init__(*args, **kwargs)
+
+    def to_representation(self, value):
+        if value is None:
+            return None
+
+        localized_value = adjust_dt(value, tz=self.timezone)
+        return localized_value.isoformat("T")
+
+
+class PermissiveHyperlinkedRelatedField(serializers.HyperlinkedRelatedField):
+    def to_internal_value(self, data):
+        model = self.get_queryset().model
+        if isinstance(data, model):
+            return data
+        else:
+            return super().to_internal_value(data)

csu/drf/forms.py

@@ -0,0 +1,65 @@
+from collections.abc import Callable
+from typing import TypedDict
+from typing import TypeVar
+
+from django.core.exceptions import ValidationError
+from django.forms import CharField
+from rest_framework.exceptions import ValidationError as DRFValidationError
+from rest_framework.fields import Field
+
+try:
+    from typing import Unpack
+except ImportError:
+    from typing_extensions import Unpack  # noqa: UP035, RUF100
+
+_FORM_FIELD_TYPE = TypeVar("_FORM_FIELD_TYPE", bound=type[Field])
+
+
+class _DRF_FIELD_KWARGS(TypedDict):
+    read_only: bool
+    write_only: bool
+    required: bool | None
+    default: object
+    initial: object
+    source: str
+    label: str
+    help_text: str
+    style: str
+    error_messages: dict[str, str]
+    validators: list[Callable]
+    allow_null: bool
+
+
+def formfield_for_drf_field(
+    drf_field: type[Field] | Field,
+    /,
+    *,
+    formfield_class: _FORM_FIELD_TYPE = CharField,
+    **drf_field_kwargs: Unpack[_DRF_FIELD_KWARGS],
+) -> _FORM_FIELD_TYPE:
+    if drf_field_kwargs:
+        assert issubclass(drf_field, Field)
+        drf_field = drf_field(**drf_field_kwargs)
+
+    class FormFieldWrapper(formfield_class):
+        def to_python(self, value):
+            value = super().to_python(value)
+            try:
+                return drf_field.run_validation(value)
+            except DRFValidationError as exc:
+                detail = exc.detail
+                if isinstance(detail, list):
+                    if len(detail) == 1:
+                        (detail,) = detail
+                        raise ValidationError(str(detail), detail.code) from exc
+                    else:
+                        code = {err.code for err in detail}
+                        if len(code) == 1:
+                            (code,) = code
+                        else:
+                            code = None
+                        raise ValidationError([str(err) for err in detail], code) from exc
+                else:
+                    raise ValidationError(exc.detail) from exc
+
+    return FormFieldWrapper

csu/drf/phonenumber.py

@@ -0,0 +1,51 @@
+from django.conf import settings
+from phonenumber_field.phonenumber import PhoneNumber
+from phonenumbers import NumberParseException
+from phonenumbers import PhoneNumberType
+from phonenumbers import number_type
+from rest_framework import serializers
+
+from ..gettext_lazy import _
+
+ACCEPTABLE_PHONE_PREFIXES = {
+    40,  # Romania
+}
+NUMBER_TYPE_VALUES = PhoneNumberType.values()
+NUMBER_TYPE_NAMES = {value: name for name, value in vars(PhoneNumberType).items() if value in NUMBER_TYPE_VALUES}
+
+
+class PhoneNumberField(serializers.CharField):
+    default_error_messages = {
+        "invalid": _("Invalid phone number."),
+        "failed_parse": _("Invalid phone number: {error}."),
+        "wrong_type": _("Invalid phone number: type is {type}."),
+        "invalid_choice": _("'{country_code}' is not an accepted code."),
+    }
+
+    def to_internal_value(self, data):
+        phone_number: PhoneNumber | None = None
+        try:
+            phone_number = PhoneNumber.from_string(phone_number=data, region=settings.PHONENUMBER_DEFAULT_REGION)
+        except NumberParseException as exc:
+            if exc.error_type == NumberParseException.TOO_SHORT_NSN:
+                self.fail("failed_parse", error=_("too short to be a phone number"))
+            elif exc.error_type == NumberParseException.TOO_LONG:
+                self.fail("failed_parse", error=_("too long to be a phone number"))
+            else:
+                self.fail("invalid")
+
+        if phone_number and not phone_number.is_valid():
+            self.fail("invalid")
+
+        phone_number_type = number_type(phone_number)
+        if phone_number_type not in (
+            PhoneNumberType.MOBILE,
+            PhoneNumberType.FIXED_LINE_OR_MOBILE,
+            PhoneNumberType.PERSONAL_NUMBER,
+            PhoneNumberType.UNKNOWN,
+        ):
+            self.fail("wrong_type", type=NUMBER_TYPE_NAMES[phone_number_type])
+
+        if phone_number.country_code not in ACCEPTABLE_PHONE_PREFIXES:
+            self.fail("invalid_choice", country_code=phone_number.country_code)
+        return phone_number.as_e164