smartdjango 4.4.0__py3-none-any.whl

smartdjango/__init__.py

@@ -0,0 +1,29 @@
+from smartdjango.validation.validator import Validator, ValidatorErrors
+from smartdjango.validation.params import Params
+from smartdjango.validation.list_validator import ListValidator
+from smartdjango.validation.dict_validator import DictValidator
+from smartdjango.validation.key import Key
+
+from smartdjango.analyse import AnalyseErrors
+from smartdjango import analyse
+from smartdjango.choice import Choice
+from smartdjango.code import Code
+from smartdjango.error import Error, OK
+from smartdjango.middleware import APIPacker
+
+
+__all__ = [
+    'Validator',
+    'ValidatorErrors',
+    'Params',
+    'ListValidator',
+    'DictValidator',
+    'Key',
+    'AnalyseErrors',
+    'analyse',
+    'Choice',
+    'Code',
+    'Error',
+    'APIPacker',
+    'OK'
+]

smartdjango/analyse.py

@@ -0,0 +1,132 @@
+from functools import wraps
+
+from django.http import HttpRequest
+from django.utils.translation import gettext as _
+from oba import Obj
+
+from smartdjango.code import Code
+from smartdjango.error import Error
+from smartdjango.utils import io, inspect
+from smartdjango.validation.dict_validator import DictValidator
+from smartdjango.validation.validator import Validator
+
+
+class Request(HttpRequest):
+    json: Obj
+    query: Obj
+    argument: Obj
+    data: Obj
+
+
+@Error.register
+class AnalyseErrors:
+    REQUEST_NOT_FOUND = Error(_("Cannot find request"), code=Code.InternalServerError)
+
+
+def get_request(*args):
+    for i, arg in enumerate(args):
+        if isinstance(arg, HttpRequest):
+            return arg
+    raise AnalyseErrors.REQUEST_NOT_FOUND
+
+
+def update_to_data(req: Request, target):
+    data = getattr(req, 'data', {})
+    if isinstance(data, Obj):
+        data = data()
+    data.update(target())
+    req.data = Obj(data)
+
+
+def analyse(*validators: Validator | str, target_getter, target_setter, restrict_keys):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            req = get_request(*args)
+            target = target_getter(req, kwargs)
+
+            validator = DictValidator().fields(*validators)
+            if restrict_keys:
+                validator.restrict_keys()
+            target = validator.clean(target)
+            target_setter(req, Obj(target))
+
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+
+def json(*validators: Validator | str, restrict_keys=True):
+    def getter(req, kwargs):
+        return io.json_loads(req.body.decode())
+
+    def setter(req, target):
+        req.json = target
+        update_to_data(req, target)
+
+    return analyse(
+        *validators,
+        target_getter=getter,
+        target_setter=setter,
+        restrict_keys=restrict_keys
+    )
+
+
+def query(*validators: Validator | str, restrict_keys=False):
+    def getter(req, kwargs):
+        return req.GET.dict()
+
+    def setter(req, target):
+        req.query = target
+        update_to_data(req, target)
+
+    return analyse(
+        *validators,
+        target_getter=getter,
+        target_setter=setter,
+        restrict_keys=restrict_keys
+    )
+
+
+def argument(*validators: Validator | str, restrict_keys=True):
+    def getter(req, kwargs):
+        return kwargs
+
+    def setter(req, target):
+        req.argument = target
+        update_to_data(req, target)
+
+    return analyse(
+        *validators,
+        target_getter=getter,
+        target_setter=setter,
+        restrict_keys=restrict_keys
+    )
+
+
+def request(bool_func, message=None):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            req = get_request(*args)
+            Validator().bool(bool_func, message=message).clean(req)
+            return func(*args, **kwargs)
+
+        return wrapper
+    return decorator
+
+
+def function(*validators: Validator | str, restrict_keys=True):
+    validator = DictValidator().fields(*validators)
+    if restrict_keys:
+        validator.restrict_keys()
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            arguments = inspect.get_function_arguments(func, *args, **kwargs)
+            arguments = validator.clean(arguments)
+
+            return func(**arguments)
+        return wrapper
+    return decorator

smartdjango/choice.py

@@ -0,0 +1,4 @@
+class Choice:
+    @classmethod
+    def to_choices(cls):
+        return [(v, v) for k, v in cls.__dict__.items() if not k.startswith('_')]

smartdjango/code.py

@@ -0,0 +1,63 @@
+class Code:
+    Continue = 100
+    SwitchingProtocols = 101
+    Processing = 102
+
+    OK = 200
+    Created = 201
+    Accepted = 202
+    NonAuthoritativeInformation = 203
+    NoContent = 204
+    ResetContent = 205
+    PartialContent = 206
+    MultiStatus = 207
+
+    MultipleChoices = 300
+    MovedPermanently = 301
+    MoveTemporarily = 302
+    SeeOther = 303
+    NotModified = 304
+    UseProxy = 305
+    SwitchProxy = 306  # 不再使用
+    TemporaryRedirect = 307
+
+    BadRequest = 400
+    Unauthorized = 401
+    PaymentRequired = 402
+    Forbidden = 403
+    NotFound = 404
+    MethodNotAllowed = 405
+    NotAcceptable = 406
+    ProxyAuthenticationRequired = 407
+    RequestTimeout = 408
+    Conflict = 409
+    Gone = 410
+    LengthRequired = 411
+    PreconditionFailed = 412
+    RequestEntityTooLarge = 413
+    RequestURITooLong = 414
+    UnsupportedMediaType = 415
+    RequestedRangeNotSatisfiable = 416
+    ExpectationFailed = 417
+    ImATeapot = 418
+    TooManyConnections = 421
+    UnprocessableEntity = 422
+    Locked = 423
+    FailedDependency = 424
+    TooEarly = 425
+    UpgradeRequired = 426
+    RetryWith = 449
+    UnavailableForLegalReasons = 451
+
+    InternalServerError = 500
+    NotImplemented = 501
+    BadGateway = 502
+    ServiceUnavailable = 503
+    GatewayTimeout = 504
+    HTTPVersionNotSupported = 505
+    VariantAlsoNegotiates = 506
+    InsufficientStorage = 507
+    BandwidthLimitExceeded = 509
+    NotExtended = 510
+
+    UnparseableResponseHeaders = 600

smartdjango/error.py

@@ -0,0 +1,103 @@
+from typing import Dict, Optional, Union
+
+from django.utils.encoding import force_str
+from django.utils.functional import Promise
+
+from smartdjango.code import Code
+
+
+MessageLike = Union[str, Promise]
+
+
+class Error(Exception):
+    __ERRORS: Dict[str, 'Error'] = dict()
+
+    """Base class for exceptions in this module."""
+    def __init__(
+        self,
+        message: MessageLike,
+        code=Code.OK,
+        user_message: Optional[MessageLike] = None,
+        identifier=None,
+    ):
+        super().__init__(message)
+
+        self.__identifier = identifier or None
+        self.message = message
+        self.code = code
+        self.details = []
+        self.user_message = user_message or message
+
+    @property
+    def identifier(self) -> str:
+        return self.__identifier
+
+    @identifier.setter
+    def identifier(self, value):
+        if self.__identifier is not None:
+            raise AttributeError('Identifier is already set')
+        if value in self.__ERRORS:
+            raise AttributeError(f'Conflict error identifier: {value}')
+        self.__identifier = value
+        self.__ERRORS[value] = self
+
+    def json(self):
+        return {
+            'message': force_str(self.message),
+            'code': self.code,
+            'details': self.details,
+            'user_message': force_str(self.user_message),
+            'identifier': self.identifier,
+        }
+
+    def jsonl(self):
+        return {
+            'message': force_str(self.message),
+            'code': self.code,
+            'identifier': self.identifier,
+        }
+
+    def __call__(self, details=None, user_message=None, **kwargs):
+        message = force_str(self.message).format(**kwargs)
+        if user_message is None:
+            user_message = force_str(self.user_message).format(**kwargs)
+
+        if details is not None and not isinstance(details, str):
+            details = force_str(details)
+        if user_message is not None and not isinstance(user_message, str):
+            user_message = force_str(user_message)
+        error = Error(message, code=self.code, user_message=user_message, identifier=self.identifier)
+        error.details = self.details.copy()
+        if details is not None:
+            error.details.append(details)
+        return error
+
+    def __eq__(self, other: 'Error'):
+        return self.identifier == other.identifier
+
+    @classmethod
+    def register(cls, class_):
+        class_name = class_.__name__
+        if not class_name.upper().endswith('ERRORS'):
+            raise AttributeError('Error class name should end with "Errors"')
+        class_name = class_name[:-6].upper()
+        for name in class_.__dict__:  # type: str
+            e = getattr(class_, name)
+            if not isinstance(e, Error):
+                continue
+            e.identifier = f'{class_name}@{name}'
+
+        return class_
+
+    def ok(self) -> bool:
+        return self.identifier == 'OK'
+
+    @classmethod
+    def all(cls) -> Dict[str, 'Error']:
+        return cls.__ERRORS
+
+    def equals(self, other: 'Error'):
+        return self.identifier == other.identifier
+
+
+OK = Error('OK', code=Code.OK, identifier='OK')

smartdjango/middleware.py

@@ -0,0 +1,40 @@
+from django.http import HttpResponse
+
+from smartdjango.error import Error, OK
+from smartdjango.utils import io
+
+
+class APIPacker:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request, *args, **kwargs):
+        response = self.get_response(request, *args, **kwargs)
+        if isinstance(response, HttpResponse):
+            return response
+
+        return self.pack(response)
+
+    @classmethod
+    def process_exception(cls, _, error):
+        if isinstance(error, Error):
+            return cls.pack(error)
+        return None
+
+    @staticmethod
+    def pack(response):
+        if isinstance(response, Error):
+            body, error = None, response
+        else:
+            body, error = response, OK
+
+        response = error.json()
+        response['body'] = body
+
+        response = io.json_dumps(response, indent=False)
+        response = HttpResponse(
+            response,
+            status=error.code,
+            content_type="application/json; encoding=utf-8",
+        )
+        return response

smartdjango/models/__init__.py

@@ -0,0 +1,20 @@
+from diq import Dictify
+from django.db.models import *
+from django.db.models import Model as BaseModel
+
+from smartdjango.models.queryset import QuerySet
+from smartdjango.models.manager import Manager
+
+
+class Model(BaseModel, Dictify):
+    objects = Manager()
+    normalizers = None
+    validators = None
+    normalizer = None
+    validator = None
+    norm = None
+    vldt = None
+
+    class Meta:
+        abstract = True
+        default_manager_name = 'objects'

smartdjango/models/manager.py

@@ -0,0 +1,12 @@
+# 自定义 Manager
+from django.db import models
+
+from smartdjango.models.queryset import QuerySet
+
+
+class Manager(models.Manager):
+    def get_queryset(self) -> QuerySet:
+        return QuerySet(self.model, using=self._db)
+
+    def map(self, func, *args, **kwargs):
+        return self.get_queryset().map(func, *args, **kwargs)

smartdjango/models/queryset.py

@@ -0,0 +1,6 @@
+from django.db import models
+
+
+class QuerySet(models.QuerySet):
+    def map(self, func, *args, **kwargs):
+        return [func(obj, *args, **kwargs) for obj in self]

smartdjango/paginator.py

@@ -0,0 +1,69 @@
+from smartdjango.models import QuerySet
+
+
+class Page:
+    OBJECTS = 'objects'
+    NEXT = 'next'
+    COUNT = 'count'
+
+    def __init__(self, queryset, count, next_value):
+        self.queryset: QuerySet = queryset
+        self.count = count
+        self.next_value = next_value
+
+    @classmethod
+    def rename(cls, objects, next_value, count):
+        cls.OBJECTS = objects
+        cls.NEXT = next_value
+        cls.COUNT = count
+
+    def dict(self, object_map, next_map=None):
+        return {
+            self.OBJECTS: self.queryset.map(object_map),
+            self.NEXT: next_map(self.next_value) if next_map else self.next_value,
+            self.COUNT: self.count,
+        }
+
+
+class Paginator:
+    def __init__(
+            self,
+            queryset: QuerySet,
+            page_size: int,
+    ):
+        self.queryset = queryset
+        self.page_size = page_size
+        self.count = self.queryset.count()
+
+        self.target_field = None
+
+    def filter(self, **kwargs):
+        assert len(kwargs) == 1, "only one filter is allowed"
+        order = list(kwargs.keys())[0]
+        assert '__' in order, "attribute must contain '__' to specify the comparison method"
+        self.target_field, compare_op = order.split('__', 1)
+        assert compare_op in ['lt', 'gt'], "comparison operation must be 'lt' or 'gt'"
+
+        order = self.target_field
+        if compare_op == 'lt':
+            order = '-' + order
+
+        self.queryset = self.queryset.filter(**kwargs).order_by(order)
+        self.count = self.queryset.count()
+
+    def get_page(
+        self,
+        page: int = None,
+    ) -> Page:
+        if page is None:
+            assert self.target_field is not None, "filter should be firstly called when page is None"
+
+            queryset = self.queryset[:self.page_size]
+            next_value = self.queryset.count() > self.page_size and getattr(queryset.last(), self.target_field)
+
+            return Page(queryset, self.count, next_value)
+
+        queryset = self.queryset[self.page_size * page:self.page_size * (page + 1)]
+        next_value = self.queryset.count() > self.page_size * (page + 1) and page + 1
+
+        return Page(queryset, self.count, next_value)

smartdjango/utils/inspect.py

@@ -0,0 +1,8 @@
+import inspect
+
+
+def get_function_arguments(func, *args, **kwargs):
+    signature = inspect.signature(func)
+    bound = signature.bind_partial(*args, **kwargs)
+    bound.apply_defaults()
+    return dict(bound.arguments)

smartdjango/utils/io.py

@@ -0,0 +1,61 @@
+import json
+import pickle
+
+from django.core.serializers.json import DjangoJSONEncoder
+
+from typing import Protocol, cast
+
+
+class SupportsWriteStr(Protocol):
+    def write(self, __s: str) -> object:
+        ...
+
+
+class SupportsWriteBytes(Protocol):
+    def write(self, __s: bytes) -> object:
+        ...
+
+
+def json_load(filepath: str):
+    with open(filepath, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+
+def json_loads(s: str):
+    return json.loads(s)
+
+
+def json_dumps(obj, indent=2) -> str:
+    if indent is False:
+        indent = None
+    return json.dumps(obj, indent=indent, ensure_ascii=False, cls=DjangoJSONEncoder)
+
+
+def json_save(obj, filepath: str):
+    with open(filepath, 'w', encoding='utf-8') as f:
+        json.dump(obj, cast(SupportsWriteStr, f), indent=2, ensure_ascii=False, cls=DjangoJSONEncoder)
+
+
+def jsonl_load(filepath: str):
+    lines = file_load(filepath).split('\n')  # 读取整个文件并按行分割
+    lines = list(filter(lambda line: line.strip(), lines))  # 去掉空行
+    lines = list(map(lambda line: json_loads(line), lines))  # 每行解析成 JSON 对象
+    return lines
+
+
+def file_load(filepath: str) -> str:
+    with open(filepath, 'r', encoding='utf-8') as f:
+        return f.read()
+
+
+def file_save(filepath: str, content: str, append=False):
+    with open(filepath, 'a+' if append else 'w', encoding='utf-8') as f:
+        f.write(content)
+
+
+def pkl_load(filepath: str):
+    return pickle.load(open(filepath, "rb"))
+
+
+def pkl_save(obj, filepath: str):
+    pickle.dump(obj, cast(SupportsWriteBytes, open(filepath, "wb")))

smartdjango/validation/dict_validator.py

@@ -0,0 +1,61 @@
+from smartdjango.error import Error
+from smartdjango.validation.validator import Validator, ValidatorErrors
+
+
+class DictValidator(Validator):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.field_validators = dict()
+
+    def copy(self):
+        new = super().copy()
+        new.field_validators = self.field_validators.copy()
+        return new
+
+    def field(self, validator: Validator | str):
+        if isinstance(validator, str):
+            validator = Validator(validator)
+        if validator.key is None:
+            raise ValueError('Validator key is required for DictValidator field')
+        if validator.key in self.field_validators:
+            raise ValidatorErrors.EXIST_PARAM_KEY(key=validator.key)
+        self.field_validators[validator.key] = validator
+        return self
+
+    def fields(self, *validators: Validator | str):
+        for validator in validators:
+            self.field(validator)
+        return self
+
+    def restrict_keys(self):
+        def key_validator(value):
+            for key in value:
+                if key not in self.field_validators:
+                    raise ValidatorErrors.INVALID_KEY(key=key)
+        self.exception(key_validator)
+        return self
+
+    def clean(self, value):
+        value = super().clean(value)
+        if value is None:
+            return None
+        if not isinstance(value, dict):
+            raise ValidatorErrors.NOT_A_DICT
+
+        new_value = dict()
+        for key, validator in self.field_validators.items():
+            try:
+                final_value = validator.clean(value.get(key.name, Validator.unset()))
+            except Error as error:
+                raise error
+            new_value[key.final_name] = final_value
+        return new_value
+
+    def __str__(self):
+        string = super().__str__()
+        if self.field_validators:
+            string += ' with fields:'
+            for key, validator in self.field_validators.items():
+                string += self.indent('\n' + str(validator))
+        return string

smartdjango/validation/key.py

@@ -0,0 +1,23 @@
+class Key:
+    def __init__(self, name, verbose_name=None, final_name=None):
+        self.name = name
+        self.verbose_name = verbose_name or name
+        self.final_name = final_name or name
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __eq__(self, other):
+        if isinstance(other, Key):
+            return self.name == other.name
+        if isinstance(other, str):
+            return self.name == other
+        return False
+
+    def copy(self):
+        return Key(self.name, self.verbose_name, self.final_name)
+
+    def __str__(self):
+        if self.verbose_name != self.name:
+            return f'Key({self.name}, {self.verbose_name})'
+        return f'Key({self.name})'

smartdjango/validation/list_validator.py

@@ -0,0 +1,52 @@
+from smartdjango.validation.validator import Validator, ValidatorErrors
+
+
+class ListValidator(Validator):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.element_validator = None
+
+    def element(self, validator: Validator):
+        self.element_validator = validator
+        return self
+
+    def elements(self, *validators: Validator):
+        self.element_validator = list(validators)
+        return self
+
+    def copy(self):
+        new = super().copy()
+        new.element_validator = self.element_validator
+        if isinstance(self.element_validator, (list, tuple)):
+            new.element_validator = new.element_validator.copy()
+        return new
+
+    def clean(self, value):
+        value = super().clean(value)
+        if value is None:
+            return None
+        if not isinstance(value, list):
+            raise ValidatorErrors.NOT_A_LIST
+        if self.element_validator is None:
+            return value
+
+        if isinstance(self.element_validator, (list, tuple)):
+            if len(self.element_validator) != len(value):
+                raise ValidatorErrors.LIST_LENGTH_MISMATCH
+            values = [validator.clean(v) for validator, v in zip(self.element_validator, value)]
+        else:
+            values = [self.element_validator.clean(v) for v in value]
+
+        return values
+
+    def __str__(self):
+        string = super().__str__()
+        if self.element_validator is not None:
+            string += ' with element validator:'
+
+            if isinstance(self.element_validator, (list, tuple)):
+                for validator in self.element_validator:
+                    string += self.indent('\n' + str(validator))
+            else:
+                string += self.indent('\n' + str(self.element_validator))
+        return string

smartdjango/validation/params.py

@@ -0,0 +1,60 @@
+from typing import Type
+
+from django.db import models
+
+from smartdjango.validation.validator import Validator
+
+
+class Params(type):
+    model_class: Type[models.Model]
+    __params = None
+
+    @staticmethod
+    def _handler_source(model_class, *attr_names):
+        sources = []
+        for attr_name in attr_names:
+            source = getattr(model_class, attr_name, None)
+            if source is not None:
+                sources.append((attr_name, source))
+
+        unique_sources = []
+        for attr_name, source in sources:
+            if all(existing is not source for _, existing in unique_sources):
+                unique_sources.append((attr_name, source))
+
+        if len(unique_sources) > 1:
+            attr_names_str = ', '.join(name for name, _ in unique_sources)
+            raise AttributeError(f'Conflicting params hook sources: {attr_names_str}')
+
+        if not unique_sources:
+            return None
+        return unique_sources[0][1]
+
+    @classmethod
+    def _field_handler(cls, model_class, field_name, *attr_names):
+        source = cls._handler_source(model_class, *attr_names)
+        if source is None:
+            return None
+        handler = getattr(source, field_name, None)
+        if callable(handler):
+            return handler
+        return None
+
+    def __getattr__(cls, field_name):
+        if cls.__params is None:
+            cls.__params = {}
+
+        if field_name not in cls.__params:
+            field = cls.model_class._meta.get_field(field_name)
+            validator = Validator.from_field(field, name=field.name, verbose_name=field.verbose_name)
+
+            norm = cls._field_handler(cls.model_class, field_name, 'normalizers', 'normalizer', 'norm')
+            if norm is not None:
+                validator.to(norm)
+
+            vldt = cls._field_handler(cls.model_class, field_name, 'validators', 'validator', 'vldt')
+            if vldt is not None:
+                validator.exception(vldt)
+
+            cls.__params[field_name] = validator
+        return cls.__params[field_name]

smartdjango/validation/validator.py

@@ -0,0 +1,197 @@
+import datetime
+from typing import Callable, Union
+
+from django.core.validators import BaseValidator
+from django.db import models
+from django.utils.translation import gettext as _
+
+from smartdjango.code import Code
+from smartdjango.error import Error
+from smartdjango.validation.key import Key
+
+
+@Error.register
+class ValidatorErrors:
+    NO_DEFAULT = Error(_('No default value'), code=Code.BadRequest)
+    NULL_NOT_ALLOW = Error(_('Null is not allowed'), code=Code.BadRequest)
+    NOT_VALID = Error(_('Not valid: {message}'), code=Code.BadRequest)
+    VALIDATOR_CRUSHED = Error(_('Validator crushed'), code=Code.InternalServerError)
+    PROCESSOR_CRUSHED = Error(_('Processor crushed'), code=Code.InternalServerError)
+    NOT_A_LIST = Error(_('Not a list'), code=Code.BadRequest)
+    LIST_LENGTH_MISMATCH = Error(_('List length mismatch'), code=Code.BadRequest)
+    NOT_A_DICT = Error(_('Not a dict'), code=Code.BadRequest)
+    INVALID_KEY = Error(_('{key} is an invalid key'), code=Code.BadRequest)
+    EXIST_PARAM_KEY = Error(_('Param key {key} already exists'), code=Code.InternalServerError)
+
+
+class Validator:
+    class __NoDefaultValue:
+        ...
+
+    class __UnSetValue:
+        ...
+
+    @classmethod
+    def unset(cls):
+        return cls.__UnSetValue
+
+    def __init__(self, name=None, verbose_name=None, final_name=None, **kwargs):
+        self.allow_null = False
+        self.default_value = self.__NoDefaultValue
+        self.to_python = []
+        self.validators = []
+
+        self._default_as_final = False
+
+        if isinstance(name, str):
+            name = Key(name, verbose_name, final_name)
+        if name and not isinstance(name, Key):
+            raise TypeError('name must be a string or Key instance')
+        self.key = name
+
+    def _carry_key_info(self, error: Error):
+        if self.key is None:
+            return error
+
+        err = error()
+        err.details.append(_('Target key: {key}').format(key=str(self.key)))
+        return err
+
+    def rename(self, name: Union[str, Key], verbose_name=__UnSetValue, final_name=__UnSetValue):
+        if isinstance(name, Key):
+            self.key = name
+            return self
+
+        self.key = self.key.copy() if self.key else Key(name)
+
+        self.key.name = name
+        if verbose_name is not self.unset():
+            self.key.verbose_name = verbose_name
+        if final_name is not self.unset():
+            self.key.final_name = final_name
+        return self
+
+    def copy(self):
+        new = Validator()
+        new.allow_null = self.allow_null
+        new.default_value = self.default_value
+        new.to_python = self.to_python.copy()
+        new.validators = self.validators.copy()
+        new._default_as_final = self._default_as_final
+        new.key = self.key.copy() if self.key else None
+        return new
+
+    def null(self, allow_null=True):
+        self.allow_null = allow_null
+        return self
+
+    def default(self, value, as_final=False):
+        self.default_value = value
+        self._default_as_final = as_final
+        return self
+
+    def to(self, to_python: Callable):
+        self.to_python.append(to_python)
+        return self
+
+    def exception(self, validator: Callable, message: str = None):
+        def wrap(value):
+            try:
+                validator(value)
+            except Error as e:
+                raise e
+            except Exception as err:
+                raise ValidatorErrors.NOT_VALID(message=message, details=err)
+
+        self.validators.append(wrap)
+        return self
+
+    def bool(self, validator: Callable, message: str = None):
+        def wrap(value):
+            if not validator(value):
+                raise ValidatorErrors.NOT_VALID(message=message or '')
+
+        return self.exception(wrap)
+
+    def clean(self, value):
+        if value is self.__UnSetValue:
+            if self.default_value is self.__NoDefaultValue:
+                raise self._carry_key_info(ValidatorErrors.NO_DEFAULT)
+
+            value = self.default_value
+            if self._default_as_final:
+                return value
+
+        if value is None:
+            if not self.allow_null:
+                raise self._carry_key_info(ValidatorErrors.NULL_NOT_ALLOW)
+            return None
+
+        for to_python in self.to_python:
+            try:
+                value = to_python(value)
+            except Error as e:
+                raise self._carry_key_info(e)
+            except Exception as err:
+                raise self._carry_key_info(ValidatorErrors.PROCESSOR_CRUSHED(details=err))
+        for validator in self.validators:
+            try:
+                validator(value)
+            except Error as e:
+                raise self._carry_key_info(e)
+            except Exception as err:
+                raise self._carry_key_info(ValidatorErrors.VALIDATOR_CRUSHED(details=err))
+        return value
+
+    def __call__(self, value):
+        return self.clean(value)
+
+    @classmethod
+    def from_field(cls, field: models.Field, *args, **kwargs):
+        validator = cls(*args, **kwargs)
+        validator.null(field.null)
+        if field.default != models.fields.NOT_PROVIDED:
+            validator.default(field.default)
+        if field.choices:
+            validator.bool(lambda x: x in dict(field.choices), message=_('Invalid choice'))
+        if field.validators:
+            for field_validator in field.validators:
+                if not isinstance(field_validator, BaseValidator):
+                    validator.exception(field_validator)
+        if isinstance(field, models.CharField):
+            validator.bool(lambda x: isinstance(x, str), message=_('Not a string'))
+            validator.bool(lambda x: len(x) <= field.max_length, message=_('Too long'))
+        if isinstance(field, models.IntegerField):
+            validator.bool(lambda x: isinstance(x, int), message=_('Not an integer'))
+        if isinstance(field, models.FloatField):
+            validator.bool(lambda x: isinstance(x, float), message=_('Not a float'))
+        if isinstance(field, models.BooleanField):
+            validator.bool(lambda x: isinstance(x, bool), message=_('Not a boolean'))
+        if isinstance(field, models.DateField):
+            validator.bool(lambda x: isinstance(x, datetime.date), message=_('Not a date'))
+        if isinstance(field, models.DateTimeField):
+            validator.bool(lambda x: isinstance(x, datetime.datetime), message=_('Not a datetime'))
+        return validator
+
+    @property
+    def classname(self):
+        return self.__class__.__name__
+
+    @staticmethod
+    def indent(string, indent='\t'):
+        lines = string.split('\n')
+        return '\n'.join([indent + line for line in lines])
+
+    def __str__(self):
+        num_validators = len(self.validators)
+        name_str = f'{self.key}' if self.key else ''
+        if num_validators == 0:
+            validator_str = ''
+        elif num_validators == 1:
+            validator_str = ' 1 validator'
+        else:
+            validator_str = f'{num_validators} validators'
+        if name_str and validator_str:
+            name_str += ', '
+
+        return f'{self.classname}({name_str}{validator_str})'

smartdjango-4.4.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: smartdjango
+Version: 4.4.0
+Summary: fast Django app development
+Home-page: https://github.com/Jyonn/smartdjango
+Author: Jyonn Liu
+Author-email: i@6-79.cn
+License: MIT Licence
+Keywords: django
+Platform: any
+License-File: LICENSE
+Requires-Dist: django
+Requires-Dist: oba
+Requires-Dist: diq
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: summary
+
+field validation detector, model advanced search, unified error class

smartdjango-4.4.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+smartdjango/__init__.py,sha256=CEly2u6Zt8wnZ9JutDklexuCcOFwbMjisEL_ej1-n3A,752
+smartdjango/analyse.py,sha256=f8sKVoiPC5qJY_hS5w_gGsbCIVnOciA-ok2sBOOvpSE,3378
+smartdjango/choice.py,sha256=EYuJu4NU0lmGeVNuhi1WUYgsE2FexJeM_YXV7aPy9s0,138
+smartdjango/code.py,sha256=u7mFnpPJUASqIfNHevsgks3M-BOSWVdo4dYLgeHkmvI,1481
+smartdjango/error.py,sha256=xvDJkq9bJFX__Daj5ACsPzm6LcUdgIu_OQnKmY-kjfU,3140
+smartdjango/middleware.py,sha256=q0eirW_f-dBZ9atTF_NCG1tCKyGA5IxuYxkFZn4ISqY,1067
+smartdjango/paginator.py,sha256=BhN6lwcvgduYvO7CV0zoQ7OhmjiR25bfJvzAjTKWYa4,2189
+smartdjango/models/__init__.py,sha256=xKJfWojCOCw3CpbCc0EQkJ9O2gRiJtHGqML32Y0posQ,461
+smartdjango/models/manager.py,sha256=CS-7nLRElxX6RVT4S4a8gv59Xd4-198cLMVQq1ANAAY,329
+smartdjango/models/queryset.py,sha256=iHP67SY4C7luc-EBa3b2Dm6xSBFXhNzC3WbTmaP3dJI,166
+smartdjango/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smartdjango/utils/inspect.py,sha256=-6gTEfEWVS1TL545G6tPUTu_RD157bqTLr9PKQC3VA0,220
+smartdjango/utils/io.py,sha256=bECY69QVi-9lxOl__OaFIYVCw9CYt1CxglRO1Rnx6ks,1583
+smartdjango/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smartdjango/validation/dict_validator.py,sha256=4ICxEuO9UwkQTQvNseW5FOb0ILIVNaikEE6gqaDOE3o,2065
+smartdjango/validation/key.py,sha256=Q6bKmHgmwC7Rw9zRuv6dEp2F0GgIR1ZYRd8YfU41fMM,703
+smartdjango/validation/list_validator.py,sha256=RLFiGxkNR9RK27CZlNB_YYXzy9T5QCD9Zchu7JhwcSE,1817
+smartdjango/validation/params.py,sha256=m7U_YjGXyP1tubcyhT6qEkixy4FORSLMFpbctv60fRY,2042
+smartdjango/validation/validator.py,sha256=ImT_Awk4PWD6FNBhbTfUnjTXvtKn01ykXwWW-rtCeQw,7137
+smartdjango-4.4.0.dist-info/licenses/LICENSE,sha256=MNmQxQoNjYQdJiUYOg0kOT_lCLbdR8p53uuWSFjNNss,1065
+smartdjango-4.4.0.dist-info/METADATA,sha256=ijPO4CNaDcXmxXtxumGnJh3fr0zUiQvD3gmw3LcII94,580
+smartdjango-4.4.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+smartdjango-4.4.0.dist-info/top_level.txt,sha256=U7Ho0CB4EW-R-rDFMAC7MU9kOsoR4Babc2O434oW_UM,12
+smartdjango-4.4.0.dist-info/RECORD,,

smartdjango-4.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

smartdjango-4.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 JyonnLIU
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

smartdjango-4.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+smartdjango