[BACK][VLN] Project init

.dockerignore

+*.pyc
+/.idea/
+/venv/
+/vevn/
+/dev/data/
+/dev/logs/
+/dev/share/
+/docs/
+/app/main/settings_local.py

.editorconfig

+# Editor configuration, see https://editorconfig.org
+root = true
+
+[*.yml]
+indent_size = 2
+
+[*.py]
+indent_size = 4

.flake8

+[flake8]
+ignore = E203, E266, E501, W503, F403, F401
+max-line-length = 79
+max-complexity = 18
+select = B,C,E,F,W,T4,B9

.gitignore

+*.pyc
+/.idea/
+/venv/
+/vevn/
+/static/
+
+# Compiled messages
+*.mo
+
+#IDE stuff
+*.iml
+
+#local env
+*.env
+
+#local settings
+/app/main/settings_local.py
+
+#data for local compose env
+/dev/data/
+/dev/logs/
+/dev/share/
+
+# Generated documentation
+/docs/api/exec-api.html
+
+# pre-built metadata files
+computed_fields.map

.pre-commit-config.yaml

+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+  - repo: https://github.com/ambv/black
+    rev: 20.8b1
+    hooks:
+      - id: black
+        language_version: python3.9
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.9.0
+    hooks:
+      - id: flake8
+default_language_version:
+  python: python3.9

DEPLOY.md

+# Deploy
+
+- Скопировать содержимое папки app в папке /opt/back/app, предварительно очистив ее
+- Скопировать содержимое папки locale в папку /opt/back/locale
+- Скопировать файлы Dockerfile и requirements.txt в папку /opt/back
+- Из папки /opt вызвать команду sudo docker-compose -f docker-compose.dev.yml up -d --build

Dockerfile

+FROM python:3.9.2-slim-buster AS development_build
+
+LABEL maintainer="sobolevn@wemake.services"
+LABEL vendor="wemake.services"
+
+ARG DJANGO_ENV
+
+ENV DJANGO_ENV=${DJANGO_ENV} \
+  # build:
+  BUILD_ONLY_PACKAGES='wget' \
+  # python:
+  PYTHONFAULTHANDLER=1 \
+  PYTHONUNBUFFERED=1 \
+  PYTHONHASHSEED=random \
+  PYTHONDONTWRITEBYTECODE=1 \
+  # pip:
+  PIP_NO_CACHE_DIR=off \
+  PIP_DISABLE_PIP_VERSION_CHECK=on \
+  PIP_DEFAULT_TIMEOUT=100 \
+  # dockerize:
+  DOCKERIZE_VERSION=v0.6.1 \
+  # tini:
+  TINI_VERSION=v0.19.0 \
+  # poetry:
+  POETRY_VERSION=1.1.4 \
+  POETRY_NO_INTERACTION=1 \
+  POETRY_VIRTUALENVS_CREATE=false \
+  POETRY_CACHE_DIR='/var/cache/pypoetry' \
+  PATH="$PATH:/root/.poetry/bin"
+
+
+# System deps:
+RUN apt-get update \
+  && apt-get install --no-install-recommends -y \
+    bash \
+    build-essential \
+    curl \
+    gettext \
+    git \
+    libpq-dev \
+    # Defining build-time-only dependencies:
+    $BUILD_ONLY_PACKAGES \
+  # Installing `dockerize` utility:
+  # https://github.com/jwilder/dockerize
+  && wget "https://github.com/jwilder/dockerize/releases/download/${DOCKERIZE_VERSION}/dockerize-linux-amd64-${DOCKERIZE_VERSION}.tar.gz" \
+  && tar -C /usr/local/bin -xzvf "dockerize-linux-amd64-${DOCKERIZE_VERSION}.tar.gz" \
+  && rm "dockerize-linux-amd64-${DOCKERIZE_VERSION}.tar.gz" && dockerize --version \
+  # Installing `tini` utility:
+  # https://github.com/krallin/tini
+  && wget -O /usr/local/bin/tini "https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini" \
+  && chmod +x /usr/local/bin/tini && tini --version \
+  # Installing `poetry` package manager:
+  # https://github.com/python-poetry/poetry
+  && curl -sSL 'https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py' | python \
+  && poetry --version \
+  # Removing build-time-only dependencies:
+  && apt-get remove -y $BUILD_ONLY_PACKAGES \
+  # Cleaning cache:
+  && apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false \
+  && apt-get clean -y && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /code
+
+# This is a special case. We need to run this script as an entry point:
+COPY ./docker/django/entrypoint.sh /docker-entrypoint.sh
+
+# Setting up proper permissions:
+RUN chmod +x '/docker-entrypoint.sh' \
+  && groupadd -r web && useradd -d /code -r -g web web \
+  && chown web:web -R /code \
+  && mkdir -p /var/www/django/static /var/www/django/media \
+  && chown web:web /var/www/django/static /var/www/django/media
+
+# Copy only requirements, to cache them in docker layer
+COPY --chown=web:web ./poetry.lock ./pyproject.toml /code/
+
+# Project initialization:
+RUN echo "$DJANGO_ENV" \
+  && poetry install \
+    $(if [ "$DJANGO_ENV" = 'production' ]; then echo '--no-dev'; fi) \
+    --no-interaction --no-ansi \
+  # Cleaning poetry installation's cache for production:
+  && if [ "$DJANGO_ENV" = 'production' ]; then rm -rf "$POETRY_CACHE_DIR"; fi
+
+# Running as non-root user:
+USER web
+
+# We customize how our app is loaded with the custom entrypoint:
+ENTRYPOINT ["tini", "--", "/docker-entrypoint.sh"]
+
+
+# The following stage is only for Prod:
+# https://wemake-django-template.readthedocs.io/en/latest/pages/template/production.html
+FROM development_build AS production_build
+COPY --chown=web:web . /code

README.md

-# voxlane-back
+# README #
 
+### Как поднять проект локально? ###
+
+Можно использовать прилагаемый docker-compose файл:
+
+```
+curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python3.9
+cd dev
+docker-compose --project-name voxlane-back -f workspace/voxlane-back/dev/docker-compose.local.yml up```
+
+Для запуска приложения требуется чтобы папка `app` в корне репозитория была добавлена в `PYTHONPATH`.
+
+В Pycharm для этого достаточно отметить её как `Sources Root`.
+
+Затем создайте файл `app/main/settings_local.py` со следующим содержимым:
+
+Прочтите файл, некоторые настройки потребуется заполнить вручную.
+
+```python
+import datetime
+
+DEBUG = True
+
+# убираем настройки безопасности
+ALLOWED_HOSTS = ['*']
+SIMPLE_JWT = {
+    'ACCESS_TOKEN_LIFETIME': datetime.timedelta(days=30),
+    'REFRESH_TOKEN_LIFETIME': datetime.timedelta(hours=3),
+    'AUTH_HEADER_TYPES': ('Bearer',),
+    'ROTATE_REFRESH_TOKENS': True
+}
+AUTH_PASSWORD_VALIDATORS = []
+USE_HTTPS = False
+SESSION_COOKIE_SECURE = False
+CSRF_COOKIE_SECURE = False
+
+# сначала пытаемся аутентифицироваться через Django
+AUTHENTICATION_BACKENDS = [
+    'django.contrib.auth.backends.ModelBackend',
+]
+
+# БД
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.postgresql_psycopg2',
+        'HOST': 'localhost',
+        'PORT': '35432',
+        'NAME': 'voxlane',
+        'USER': 'thirdlane',
+        'PASSWORD': 'thirdlane',
+    }
+}
+
+# исходящая почта
+EMAIL_HOST = 'localhost'
+EMAIL_PORT = '1025'
+
+# redis и celery
+REDIS_HOST = 'localhost'
+REDIS_PORT = '36379'
+REDIS_DB_CELERY = 0
+
+CELERY_BROKER_URL = f"redis://{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB_CELERY}"
+CELERY_RESULT_BACKEND = f"redis://{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB_CELERY}"
+
+CACHES = {
+    "default": {
+        "BACKEND": "django_redis.cache.RedisCache",
+        "LOCATION": f"redis://{REDIS_HOST}:{REDIS_PORT}/1",
+        "OPTIONS": {
+            "CLIENT_CLASS": "django_redis.client.DefaultClient",
+        }
+    }
+}
+
+# упрощает отладку вычисляемых полей в моделях
+COMPUTEDFIELDS_MAP = None
+COMPUTEDFIELDS_ADMIN = True
+```
+Переменные, добавленные в него, будут автоматически добавляться(перезаписывать существующие переменные) в базовых настройках в `app/main/settings.py`
+
+В конфигурацию входит почтовый сервер, можно читать исходящие письма в веб интерфейсе на http://localhost:8025/
+
+Также в конфигурацию входит сервер rabbitmq, админка доступна на http://localhost:8030/ логин/пароль guest/guest
+
+### Фронтенд ###
+
+Фронтенд поднимается отдельно, но по умолчанию настроен на работу с локальным бекендом.
+Репозиторий фронтенда:
+
+### Как запускать celery task'и без отдельного процесса? ###
+
+Добавьте к вашему файлу настроек `CELERY_TASK_ALWAYS_EAGER = True`
+
+### Как запускать celery на windows? ###
+
+Celery на windows запустится, но "из коробки" не будет выполнять таски, нужно запускать следующим образом:
+
+`celery -A main worker --loglevel=INFO --pool=solo`

app/main/__init__.py

+from .celery import *

app/main/asgi.py

+"""
+ASGI config for voxlane-back project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "main.settings")
+
+application = get_asgi_application()

app/main/auth/serializers.py

+from django.contrib.auth import get_user_model
+from rest_framework_simplejwt.serializers import (
+    TokenObtainPairSerializer,
+    TokenVerifySerializer,
+    TokenRefreshSerializer,
+)
+from rest_framework_simplejwt.state import token_backend
+from rest_framework_simplejwt.tokens import RefreshToken
+
+from users.serializers import UserSerializer
+
+User = get_user_model()
+
+
+class TokenObtainPairSerializerEx(TokenObtainPairSerializer):
+    def validate(self, attrs):
+        data = super().validate(attrs)
+        data["user"] = UserSerializer(self.user).data
+        return data
+
+
+class TokenVerifySerializerEx(TokenVerifySerializer):
+    def validate(self, attrs):
+        data = super().validate(attrs)
+        payload = token_backend.decode(attrs["token"], verify=False)
+        user = User.objects.get(id=payload.get("user_id"))
+        data["user"] = UserSerializer(user).data
+        return data
+
+
+class TokenRefreshSerializerEx(TokenRefreshSerializer):
+    def validate(self, attrs):
+        data = super().validate(attrs)
+        refresh = RefreshToken(attrs["refresh"])
+        user = User.objects.get(id=refresh.payload.get("user_id"))
+        data["user"] = UserSerializer(user).data
+        return data

app/main/auth/views.py

+from rest_framework_simplejwt.views import TokenObtainPairView, TokenVerifyView, TokenRefreshView
+
+from main.auth.serializers import TokenObtainPairSerializerEx, TokenVerifySerializerEx, TokenRefreshSerializerEx
+
+
+class TokenObtainPairViewEx(TokenObtainPairView):
+    serializer_class = TokenObtainPairSerializerEx
+
+
+class TokenVerifyViewEx(TokenVerifyView):
+    serializer_class = TokenVerifySerializerEx
+
+
+class TokenRefreshViewEx(TokenRefreshView):
+    serializer_class = TokenRefreshSerializerEx

app/main/celery.py

+import os
+
+from celery import Celery
+from celery.signals import task_failure
+
+# set the default Django settings module for the 'celery' program.
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "main.settings")
+
+app = Celery("voxlane")
+
+# Using a string here means the worker doesn't have to serialize
+# the configuration object to child processes.
+# - namespace='CELERY' means all celery-related configuration keys
+#   should have a `CELERY_` prefix.
+app.config_from_object("django.conf:settings", namespace="CELERY")
+
+
+def periodic(schedule):
+    """
+    Decorator to run a task on a schedule.
+    see https://docs.celeryproject.org/en/v4.4.7/userguide/periodic-tasks.html
+    :param schedule: - interval in seconds/cron/solar
+    """
+
+    def decorator(task):
+        app.add_periodic_task(schedule, task)
+        return task
+
+    return decorator
+
+
+@app.on_after_configure.connect
+def setup_periodic_tasks(sender, **kwargs):
+    # you can add periodic tasks here
+    pass
+
+
+@task_failure.connect
+def celery_task_failure_email(sender, **kwargs):
+    from django.core.mail import mail_admins
+    from django.conf import settings
+
+    queue_name = sender.request.delivery_info.get("routing_key", "celery")
+    subject = f"[Task Failure][{queue_name}@{settings.PRIMARY_HOST}] {sender.name} error"
+    message = (
+        f"Task {sender.name} has failed. \n " f"Task id was: {kwargs['task_id']} \n " f"Traceback: \n {kwargs['einfo']}"
+    )
+    mail_admins(subject, message)
+
+
+# Load task modules from all registered Django app configs.
+app.autodiscover_tasks()

app/main/core/decorators.py

+import logging
+import time
+
+from django.core.cache import cache
+from django.core.mail import mail_admins
+from django.utils.timezone import now
+
+
+from main.core.exceptions import ParallelExecutionException
+from main.core.utils import human_delta
+
+logger = logging.getLogger(__name__)
+
+
+def avoid_parallel_execution(fn_name):
+    def decorator(fn):
+        def wrapper(*args, **kwargs):
+            key = "double_execution_protection:" + fn_name
+            key_value = cache.get(key)
+
+            if key_value is None:
+                cache.set(key, now(), None)
+
+                try:
+                    fn(*args, **kwargs)
+                except BaseException as ex:
+                    raise ex
+                finally:
+                    cache.delete(key)
+            else:
+                msg = "{0}: parallel execution detected. Other cron started at {1}".format(fn_name, key_value)
+                mail_admins("Cron parallel execution detected", msg)
+                logger.error(msg)
+                raise ParallelExecutionException()
+
+            return None
+
+        return wrapper
+
+    return decorator
+
+
+def time_perf(desc="Processing", logger=None):
+    def decorator(fn):
+        def wrapper(*args, **kwargs):
+            logger.info(f"{desc}...")
+            ts = time.perf_counter()
+
+            result = fn(*args, **kwargs)
+
+            te = time.perf_counter()
+            logger.info(f"{desc} done in {human_delta(te - ts)}.")
+
+            return result
+
+        return wrapper
+
+    return decorator

app/main/core/exceptions.py

+from rest_framework.exceptions import APIException
+
+
+class ParallelExecutionException(Exception):
+    pass
+
+
+class BadGateway(APIException):
+    status_code = 502
+    default_detail = "Bad gateway"
+    default_code = "bad_gateway"
+
+
+class ServiceUnavailable(APIException):
+    status_code = 503
+    default_detail = "Service temporarily unavailable"
+    default_code = "service_unavailable"
+
+
+class GatewayTimeout(APIException):
+    status_code = 504
+    default_detail = "Gateway timeout"
+    default_code = "gateway_timeout"

app/main/core/features.py

+from django.conf import settings
+
+from main.core.utils.classes import readonly_class_property
+
+
+class Feature:
+    """
+    Feature-флаги,
+    добавляйте по мере необходимости
+    """
+
+    @readonly_class_property
+    def is_qa(self):
+        return settings.QA
+
+    @readonly_class_property
+    def is_prod(self):
+        return settings.PRODUCTION

app/main/core/fields.py

+from model_utils import FieldTracker
+
+
+class VLNFieldTracker(FieldTracker):
+    def patch_save(self, model):
+        from main.core.models import TrackerMixin
+
+        if not issubclass(model, TrackerMixin):
+            return super().patch_save(model)

app/main/core/filters.py

+from rest_framework.filters import OrderingFilter
+
+
+class NestedOrderingFilter(OrderingFilter):
+    """
+    Extends default ordering filter to allow sorting by related model attributes and queryset annotations
+    without explicitly specifying names for those attributes in ordering_fields
+    Desired nesting level can be specified on the view class via order_nesting_depth property
+    """
+
+    default_nesting_depth = 2
+
+    def get_nesting_depth(self, view):
+        return getattr(view, "order_nesting_depth", self.default_nesting_depth) - 1
+
+    @staticmethod
+    def get_field_verbose_name(field, name: str) -> str:
+        return field.verbose_name if hasattr(field, "verbose_name") else name.replace("__", " ")
+
+    def add_nested_fields(self, sort_fields, fields, depth: int, parent_name=None):
+        for field in fields:
+            field_name = f"{parent_name}__{field.name}" if parent_name else field.name
+            if field.related_model and (field.many_to_one or field.one_to_one) and depth > 0:
+                self.add_nested_fields(sort_fields, field.related_model._meta.get_fields(), depth - 1, field_name)
+            elif parent_name:
+                sort_fields.append((field_name, self.get_field_verbose_name(field, field_name)))
+
+    def get_valid_fields(self, queryset, view, context=None):
+        fields = super(NestedOrderingFilter, self).get_valid_fields(queryset, view, context)
+        valid_field_names = {field[0] for field in fields}
+        max_depth = self.get_nesting_depth(view)
+        model_fields = (field for field in queryset.model._meta.get_fields() if field.name in valid_field_names)
+        self.add_nested_fields(fields, model_fields, max_depth)
+        # implicitly enable sorting for annotations
+        for annotation_name in queryset.query.annotations.keys():
+            fields.append((annotation_name, annotation_name))
+        return fields

app/main/core/helpers/__init__.py

+from .api_client import ApiClient

app/main/core/helpers/api_client.py

+import abc
+import urllib.parse
+from contextlib import contextmanager
+
+import requests
+from requests.exceptions import ConnectionError, HTTPError, Timeout, TooManyRedirects
+from rest_framework.exceptions import ValidationError
+
+from main.core.exceptions import BadGateway, GatewayTimeout
+from main.core.utils.classes import Singleton
+
+
+class ApiClient(Singleton, abc.ABC):
+    service_name = "Service"
+
+    def __init__(self):
+        self.session = requests.Session()
+        self.validate_config()
+        self.authorize()
+
+    def get_shared_kwargs(self):
+        return {}
+
+    def authorize(self):
+        pass
+
+    @abc.abstractmethod
+    def get_host(self) -> str:
+        pass
+
+    def get_endpoint(self, path) -> str:
+        return urllib.parse.urljoin(self.get_host(), path)
+
+    def perform_request(self, method: str, url: str, kwargs):
+        with self.handle_errors():
+            raise_for_status = kwargs.pop("raise_for_status", True)
+            url = self.get_endpoint(url)
+            kwargs = {**self.get_shared_kwargs(), **kwargs}
+            response = getattr(self.session, method)(url, **kwargs)
+            if response.status_code == 401:
+                response = self.unauthorized_hook(response)
+            if raise_for_status:
+                response.raise_for_status()
+        return response
+
+    def get(self, url, **kwargs):
+        return self.perform_request("get", url, kwargs)
+
+    def post(self, url, **kwargs):
+        return self.perform_request("post", url, kwargs)
+
+    def put(self, url, **kwargs):
+        return self.perform_request("put", url, kwargs)
+
+    def patch(self, url, **kwargs):
+        return self.perform_request("patch", url, kwargs)
+
+    def delete(self, url, **kwargs):
+        return self.perform_request("delete", url, kwargs)
+
+    def unauthorized_hook(self, response):
+        return response
+
+    @staticmethod
+    def validate_config():
+        pass
+
+    @classmethod
+    @contextmanager
+    def handle_errors(cls):
+        try:
+            yield
+        except ConnectionError:
+            raise BadGateway("Could not reach %s" % cls.service_name)
+        except TooManyRedirects:
+            raise BadGateway("Could not reach %s (too many redirects)" % cls.service_name)
+        except Timeout:
+            raise GatewayTimeout("Request to %s timed out" % cls.service_name)
+        except HTTPError as err:
+            raise ValidationError(err.response.json())

app/main/core/middleware.py

+import os
+import threading
+
+from django.utils import timezone
+
+from main.core.utils.classes import readonly_class_property
+
+
+class CurrentRequest:
+    """
+    Contains global state tied to request
+    threading.local is not necessary for production, but fixes some `manage.py runsever` inconsistencies
+    """
+
+    state = threading.local()
+
+    @classmethod
+    def use_request(cls, request):
+        cls.state.request = request
+        cls.state.cache = {} if request else None
+
+    @readonly_class_property
+    def exists(cls):
+        return cls.request is not None
+
+    @readonly_class_property
+    def request(cls):
+        return getattr(cls.state, "request", None)
+
+    @readonly_class_property
+    def user(cls):
+        if cls.request:
+            return cls.request.user
+        return None
+
+    @classmethod
+    def cached(cls, func):
+        def wrapped(*args):
+            if getattr(cls.state, "cache", None) is None:
+                return func(*args)
+            if func not in cls.state.cache:
+                cls.state.cache[func] = func(*args)
+            return cls.state.cache[func]
+
+        return wrapped
+
+
+class VLNMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def add_debug_headers(self, response):
+        response["X-SME-WORKER-PID"] = os.getpid()
+        response["X-SME-WORKER-TIME"] = timezone.now()
+        response["X-SME-TIMEZONE"] = timezone.get_default_timezone_name()
+
+    def __call__(self, request):
+        CurrentRequest.use_request(request)
+        response = self.get_response(request)
+        self.add_debug_headers(response)
+        CurrentRequest.use_request(None)
+        return response

app/main/core/models.py

+from main.core.fields import VLNFieldTracker
+
+
+class TrackerMixin:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        tracker = getattr(self.__class__, "tracker", None)
+        if not tracker or not isinstance(tracker, VLNFieldTracker):
+            raise AttributeError("Classes with TrackerMixin must have tracker=VLNFieldTracker()")
+        self._before_save_hooks = []
+
+    def __flush_before_save_hooks(self):
+        for hook in self._before_save_hooks:
+            hook()
+        self._before_save_hooks.clear()
+
+    def enqueue_before_save_hook(self, hook):
+        self._before_save_hooks.append(hook)
+
+    def save(self, *args, **kwargs):
+        """
+        This implementation was copy pasted from FieldTracker.patch_save
+        it correctly reports tracker changes during nested model.save() calls
+        """
+        self.__flush_before_save_hooks()
+        ret = super().save(*args, **kwargs)
+        update_fields = kwargs.get("update_fields")
+        if not update_fields and update_fields is not None:  # () or []
+            fields = update_fields
+        elif update_fields is None:
+            fields = None
+        else:
+            fields = (field for field in update_fields if field in self.tracker.fields)
+        self.tracker.set_saved_fields(fields=fields)
+        return ret
+
+    def save_if_changed(self, **kwargs):
+        if not self._state.adding:
+            if any(self.tracker.changed().keys()):
+                self.save(**kwargs)
+        else:
+            self.save(**kwargs)

app/main/core/pagination.py

+from django.core.paginator import Paginator
+from rest_framework.pagination import PageNumberPagination
+
+
+class VLNPaginator(Paginator):
+    pass
+
+
+class DefaultVLNPagination(PageNumberPagination):
+    django_paginator_class = VLNPaginator
+    pagination_disabled_query_param = None  # 'unpaginated'
+    page_query_param = "page"
+    page_size_query_param = "size"
+    page_size = 50
+    max_page_size = 1000
+
+    def get_page_size(self, request):
+        # disable pagination if query param is present
+        if self.pagination_disabled_query_param and self.pagination_disabled_query_param in request.query_params:
+            return None
+        if self.page_size_query_param and request.query_params.get(self.page_size_query_param) == "max":
+            return self.max_page_size
+        return super().get_page_size(request)

app/main/core/permissions.py

+from copy import deepcopy
+
+from rest_framework.permissions import DjangoModelPermissions
+
+
+def get_custom_method_map():
+    """
+    By default DRF does not check permissions on GET, enable it here
+    """
+    perms = deepcopy(DjangoModelPermissions.perms_map)
+    # Temporarily disabled, if not re-enabled before 7.09.2020, delete this check entirely
+    # perms['GET'].append('%(app_label)s.view_%(model_name)s')
+    return perms
+
+
+class VLNModelPermissions(DjangoModelPermissions):
+    perms_map = get_custom_method_map()
+
+
+def AutoPermissions(app_label, class_name):
+    class Permissions:
+        ADD: str = ".".join((app_label, f"add_{class_name}"))
+        CHANGE: str = ".".join((app_label, f"change_{class_name}"))
+        DELETE: str = ".".join((app_label, f"delete_{class_name}"))
+        VIEW: str = ".".join((app_label, f"view_{class_name}"))
+
+    return Permissions

app/main/core/routers.py

+from rest_framework.routers import Route, DefaultRouter
+from rest_framework_nested.routers import NestedMixin
+
+
+class VLNRelatedViewSetSupportRouterMixin:
+    __extra_routes = [
+        Route(
+            url=r"^{prefix}{trailing_slash}$",
+            mapping={
+                "get": "retrieve_related",
+                "put": "update_related",
+                "patch": "partial_update_related",
+            },
+            name="{basename}-related",
+            detail=False,
+            initkwargs={"suffix": "Related"},
+        )
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.routes = self.__extra_routes + super().routes
+
+
+class VLNRouter(VLNRelatedViewSetSupportRouterMixin, DefaultRouter):
+    pass
+
+
+class VLNNestedRouter(NestedMixin, VLNRouter):
+    pass

app/main/core/serializer_fields.py

+from rest_framework.serializers import Serializer, ListSerializer
+
+from main.core.serializers import CacheAwareSerializerMixin
+
+
+class RecursiveField(Serializer):  # noqa
+    def to_representation(self, value):
+        serializer = self.parent.parent.__class__(value, context=self.context)
+        return serializer.data
+
+
+class CacheAwareListSerializer(CacheAwareSerializerMixin, ListSerializer):  # noqa
+    pass
+
+
+class CacheAwareRecursiveField(CacheAwareSerializerMixin, RecursiveField):  # noqa
+    class Meta:
+        list_serializer_class = CacheAwareListSerializer

app/main/core/serializers.py

+import dataclasses
+
+from django.core.exceptions import ObjectDoesNotExist
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
+from rest_framework.fields import get_attribute
+
+from main.core.utils.models import get_model_manager
+from main.core.utils.views import extract_id
+
+
+class ForeignKeyDeserializerMixin:
+    queryset = None  # mimics rest_framework.relations.RelatedField
+
+    def __init__(self, *args, **kwargs):
+        self.queryset = kwargs.pop("queryset", self.queryset)
+        self._get_custom_queryset = kwargs.pop("get_queryset", None)
+        super().__init__(*args, **kwargs)
+
+    def get_model_manager(self):
+        return get_model_manager(self.Meta.model)
+
+    def _get_queryset(self):
+        if self._get_custom_queryset:
+            return self._get_custom_queryset(self)
+        if self.queryset:
+            return self.queryset
+        else:
+            return self.get_model_manager().all()
+
+    def to_internal_value(self, data):
+        pk = extract_id(data)
+        try:
+            model = self._get_queryset().get(pk=pk)
+        except ObjectDoesNotExist:
+            raise ValidationError("No matching object found in database")
+        return model
+
+
+class NestedRouterForeignKeyDeserializerMixin:
+    """
+    This class only works for relations that are serialized as primary keys
+    It can be extended if needed or used in conjunction with ForeignKeyDeserializerMixin
+
+    Add your nested router lookups to router_lookups and they will be automatically added to serializer data
+    """
+
+    router_lookups = ()
+
+    def _get_relation_pk(self, attr: str):
+        view = self.context.get("view")
+        return view.kwargs.get(f"{attr}_{view.lookup_field}")
+
+    def _inject_relations_from_router(self, data):
+        for attr in self.router_lookups:
+            if isinstance(attr, str):
+                data[attr] = self._get_relation_pk(attr)
+            else:
+                data[attr[0]] = self._get_relation_pk(attr[1])
+        return data
+
+    def to_internal_value(self, data):
+        extended_data = self._inject_relations_from_router(data)
+        return super().to_internal_value(extended_data)
+
+
+class CacheAwareSerializerMixin:
+    cache_context_key = "cache"
+    cache_pk_attr = "id"
+    """
+    Can grab model attribute values from context cache by model id instead of querying the model
+    Init kwargs:
+        consider_empty_on_miss: if true, never try to resolve model attribute on cache miss
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.consider_empty_on_miss = kwargs.pop("consider_empty_on_miss", False)
+        # ListSerializer gets its own set of kwargs, so we need to pluck the attr from child
+        if "child" in kwargs:
+            self.consider_empty_on_miss = getattr(kwargs["child"], "consider_empty_on_miss", False)
+        super().__init__(*args, **kwargs)
+
+    def get_attribute(self, instance):
+        try:
+            cache = get_attribute(self.context.get(self.cache_context_key), self.source_attrs)
+        except (KeyError, AttributeError):
+            cache = None
+        if cache:
+            pk = getattr(instance, self.cache_pk_attr)
+            if pk in cache:
+                return cache[pk]
+            if self.consider_empty_on_miss:
+                return [] if self.many else None
+        return super().get_attribute(instance)
+
+
+class GenericDataclassSerializer(serializers.Serializer):  # noqa
+    def to_representation(self, instance):
+        if not dataclasses.is_dataclass(instance):
+            raise ValueError("This serializer only supports dataclasses")
+        return dataclasses.asdict(instance)

app/main/core/utils/__init__.py

+import asyncio
+import itertools
+import numbers
+import os
+import sys
+import time
+from collections import defaultdict
+from datetime import datetime, timedelta
+from functools import cached_property
+from inspect import stack
+from itertools import groupby
+from typing import Callable, Iterable, Iterator
+
+import pytz
+from django.conf import settings
+from django.db import connection, models, transaction
+from django.http import HttpRequest
+from django.utils import timezone
+from django.utils.duration import _get_duration_components
+from rest_framework.request import Request
+
+tz = pytz.timezone(settings.TIME_ZONE)
+
+
+def get_pk(value):
+    if value:
+        if isinstance(value, str) and value.isdigit():
+            return int(value)
+        if isinstance(value, int):
+            return value
+    return None
+
+
+def some_none(*args):
+    for arg in args:
+        if arg is None:
+            return True
+
+
+# Hack
+def is_request_from_page_of_model(request, model_name):
+    result = False
+    http_referer = request.META.get("HTTP_REFERER")
+    if http_referer:
+        model_name_in_url = "/" + model_name + "/"
+        result = model_name_in_url in http_referer
+    return result
+
+
+# Hack
+def extract_pk_from_request(request, model_name):
+    pk = None
+    http_referer = request.META.get("HTTP_REFERER")
+    if http_referer:
+        splitted_url = http_referer.split("/")[:-1]
+        if splitted_url[-3] == model_name:
+            pk = get_pk(splitted_url[-2])
+    return pk
+
+
+def get_front_url():
+    return _get_url("front")
+
+
+def get_back_url():
+    return _get_url("api")
+
+
+def get_url_to_logo():
+    back = get_back_url()
+    return "{0}{1}{2}".format(back, settings.STATIC_URL, "bkb/img/logo.png")
+
+
+def _get_url(side):
+    front_settings = settings.SITES.get(side, {})
+    return "{0}://{1}".format(front_settings.get("scheme"), front_settings.get("domain"))
+
+
+def group_by(data, key_fn):
+    """
+    Группирует список по ключу
+    :param data: список
+    :param key_fn: функция вычисления ключа
+    :return: list
+    """
+    grouped_data = defaultdict(list)
+    for key, group in groupby(data, key_fn):
+        grouped_data[key] += list(group)
+    return grouped_data
+
+
+def get_request_from_stack():
+    """
+    Tries to find request object among
+    frame records of the caller's stack.
+
+    For more information on the interpreter stack, visit
+    https://docs.python.org/3.4/library/inspect.html#the-interpreter-stack
+
+    Осторожно! При использовании в рекурсивных вызовах может стать причиной падения производительности
+
+    Returns:
+        first found request object or `None`.
+    """
+    for frame_record in stack():
+        request = frame_record[0].f_locals.get("request", None)
+        if request and (isinstance(request, Request) or isinstance(request, HttpRequest)):
+            return request
+    return None
+
+
+def progress_bar(count, total, status="", bar_len=60):
+    """
+    Консольный progress bar
+    link: https://gist.github.com/vladignatyev/06860ec2040cb497f0f3
+    :param count: текущий индекс
+    :param total: общее кол-во
+    :param status:
+    :param bar_len: длина прогесс бара в символах
+    :return:
+    """
+    filled_len = int(round(bar_len * count / float(total)))
+
+    percents = round(100.0 * count / float(total), 1)
+    bar = "=" * filled_len + "-" * (bar_len - filled_len)
+
+    status = status.strip().replace("\n", " ").replace("\r", "")
+
+    sys.stdout.write("[%s] %s%s ...%s\r" % (bar, percents, "%", status))
+    sys.stdout.flush()
+
+
+def date_to_epoch(date_, set_to_end=False):
+    if date_:
+        time_ = datetime.max.time() if set_to_end else datetime.min.time()
+        datetime_ = datetime.combine(date_, time_)
+        date_ = int(datetime_.timestamp())
+    return date_
+
+
+def datetime_to_epoch(datetime_):
+    return int(datetime_.timestamp()) if datetime_ else None
+
+
+def duration_to_epoch(duration):
+    result = None
+    if isinstance(duration, timedelta):
+        result = int(duration.total_seconds())
+    return result
+
+
+def get_datetime_display(datetime_, format_="%Y-%m-%d %H:%M:%S"):
+    return timezone.localtime(datetime_).strftime(format_) if datetime_ else None
+
+
+def get_date_display(date_, format_="%Y-%m-%d"):
+    return date_.strftime(format_) if date_ else None
+
+
+def get_path_to_static_res_by_url(url):
+    """Возвращает путь к статическому ресурсу на диске по его url"""
+    return os.sep.join((settings.STATIC_ROOT, url.split(settings.STATIC_URL)[1]))
+
+
+def get_path_to_media_res_by_url(url, filename):
+    """Возвращает путь к медиа ресурсу на диске по его url"""
+    path = url.split(settings.MEDIA_URL).pop()
+    splitted_path = path.split(os.sep)
+    splitted_path.pop()
+    splitted_path.append(filename)
+    return os.sep.join((settings.MEDIA_ROOT, os.sep.join(splitted_path)))
+
+
+def get_duration_display(duration):
+    result = None
+    if isinstance(duration, timedelta):
+        days, hours, minutes, seconds, microseconds = _get_duration_components(duration)
+        result = "{:d}:{:02d}".format(24 * days + hours, minutes)
+    return result
+
+
+def prepare_values_to_serialization(raw_values):
+    values = {}
+    for key, value in raw_values.items():
+        if isinstance(value, timedelta):
+            value = get_duration_display(value)
+        values[key] = value
+    return values
+
+
+def convert_date_to_datetime(date):
+    """Превращает дату в дату время"""
+    return datetime.combine(date, datetime.min.time())
+
+
+def convert_date_to_max_datetime(date):
+    """Превращает дату в дату время, возвращает конец дня"""
+    return tz.localize(datetime.combine(date, datetime.max.time()))
+
+
+def human_delta(tdelta):
+    """
+    Takes a timedelta object and formats it for humans.
+    Usage:
+        # 149 day(s) 8 hr(s) 36 min 19 sec
+        print human_delta(datetime(2014, 3, 30) - datetime.now())
+    Example Results:
+        23 sec
+        12 min 45 sec
+        1 hr(s) 11 min 2 sec
+        3 day(s) 13 hr(s) 56 min 34 sec
+    :param tdelta: The timedelta object or seconds.
+    :return: The human formatted timedelta
+    """
+    if type(tdelta) is float:
+        tdelta = timedelta(seconds=tdelta)
+
+    d = dict(days=tdelta.days)
+    d["hrs"], rem = divmod(tdelta.seconds, 3600)
+    d["min"], d["sec"] = divmod(rem, 60)
+
+    if d["days"] > 0:
+        fmt = "{days} day(s) {hrs} hr(s) {min} min {sec} sec"
+    elif d["hrs"] > 0:
+        fmt = "{hrs} hr(s) {min} min {sec} sec"
+    elif d["min"] > 0:
+        fmt = "{min} min {sec} sec"
+    else:
+        fmt = "{sec} sec"
+
+    return fmt.format(**d)
+
+
+def get_next_id(model):
+    db_table = model._meta.db_table
+    pk_name = model._meta.pk.column
+    sql = """
+    SELECT nextval(pg_get_serial_sequence(%s, %s));
+    """
+    with connection.cursor() as cursor:
+        cursor.execute(sql, [db_table, pk_name])
+        return cursor.fetchone()[0]
+
+
+def is_prefetched(obj, related_name):
+    """
+    Возвращает True, если поле было подгружено через prefetch_related или select_related.
+    :param obj: экземпляр модели
+    :param related_name: название поля
+    :return: bool
+    """
+    return related_name in getattr(obj, "_prefetched_objects_cache", {}) or related_name in getattr(
+        obj._state, "fields_cache", {}
+    )  # noqa
+
+
+def get_fk_field_names(model):
+    """Возвращает все названия полей модели, которые являются внешними ключами"""
+    return [x.name for x in model._meta.get_fields() if isinstance(x, models.ForeignKey)]
+
+
+def schedule_task_on_commit(celery_task_fn, *args, **kwargs):
+    """
+    Асинхронно запускает celery задачу при успешном завершении текущей транзакции
+    """
+    defer_until_commit(lambda: celery_task_fn.delay(*args, **kwargs))
+
+
+def defer_until_commit(callback: Callable):
+    """
+    Вызывает callback при успешном завершении текущей транзакции,
+    или сразу, если нет активной транзакции
+    """
+    if transaction.get_connection().in_atomic_block and not settings.TEST:
+        transaction.on_commit(callback)
+    else:
+        callback()
+
+
+def get_thread_event_loop():
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    except RuntimeError:
+        loop = asyncio.get_event_loop()  # gets previously set event loop, if possible
+    return loop
+
+
+def getattr_nested(obj, path, default=None, separator="."):
+    tokens = path.split(separator)
+    for token in tokens:
+        obj = getattr(obj, token, None)
+        if obj is None:
+            return default
+    return obj
+
+
+def is_json_primitive(value):
+    return (
+        value is None
+        or isinstance(value, str)
+        or isinstance(value, numbers.Number)
+        or isinstance(value, bool)
+        or isinstance(value, dict)
+    )
+
+
+class writable_cached_property(cached_property):  # noqa
+    def __set__(self, instance, value):
+        if instance is not None:
+            instance.__dict__[self.attrname] = value
+
+    def __delete__(self, instance):
+        instance.__dict__.pop(self.attrname, None)
+
+
+def chunk_iterator(iterable: Iterable, chunk_size: int) -> Iterator[list]:
+    iterator = iter(iterable)
+    while True:
+        chunk = list(itertools.islice(iterator, chunk_size))
+        if not chunk:
+            return
+        yield chunk
+
+
+class PerfTimer:
+    def __init__(self):
+        self.total = 0
+        self.__start = 0
+        self.__last_current = 0
+
+    def __enter__(self):
+        self.__start = time.perf_counter()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.__last_current = self.current
+        self.total += self.__last_current
+        self.__start = 0
+
+    @property
+    def current(self):
+        if not self.__start:
+            return self.__last_current
+        return time.perf_counter() - self.__start

app/main/core/utils/classes.py

+class Singleton:
+    __singleton_instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls.__singleton_instance is None:
+            cls.__singleton_instance = super().__new__(cls)
+        return cls.__singleton_instance
+
+
+class readonly_class_property:  # noqa
+    def __init__(self, getter):
+        self.getter = getter
+
+    def __get__(self, obj, cls):
+        return self.getter(cls)

app/main/core/utils/dicts.py

+def set_in(obj: dict, key: str, value):
+    tokens = key.split("__")
+    current_level = obj
+    if not isinstance(current_level, dict):
+        current_level = {}
+    for token in tokens[:-1]:
+        if token not in current_level or not isinstance(current_level[token], dict):
+            current_level[token] = {}
+        current_level = current_level[token]
+    current_level[tokens[-1]] = value
+    return obj
+
+
+def get_in(obj: dict, key: str, default=None):
+    tokens = key.split("__")
+    current_level = obj
+    if not isinstance(current_level, dict):
+        return default
+    for token in tokens:
+        if token in current_level:
+            current_level = current_level[token]
+        else:
+            return default
+    return current_level
+
+
+def decapitalize_keys(source, recursive=False):
+    """
+    переводит первую букву всех строковых ключей в словаре в нижний регистр
+    :param source:
+    :param recursive:
+    :return:
+    """
+    if recursive and isinstance(source, list):
+        for item in source:
+            decapitalize_keys(item, recursive=recursive)
+    if not isinstance(source, dict):
+        return source
+    for key in list(source.keys()):
+        if isinstance(key, str):
+            value = source.pop(key)
+            source[key[0].lower() + key[1:]] = value
+        else:
+            value = source[key]
+        if recursive:
+            decapitalize_keys(value, recursive=recursive)
+    return source

app/main/core/utils/environment.py

+from django.conf import settings
+
+
+def is_unit_testing():
+    return settings.TEST

app/main/core/utils/models.py

+from typing import List
+
+from django.db import models
+from django.db.models import prefetch_related_objects
+
+from main.core.utils import is_prefetched, chunk_iterator
+
+
+def purify_queryset(queryset: models.QuerySet) -> models.QuerySet:
+    queryset = queryset.prefetch_related(None).select_related(None)
+    queryset.query.annotations.clear()
+    return queryset
+
+
+def get_model_manager(model):
+    return model._default_manager or model.objects  # noqa
+
+
+def patch_attributes(model, **kwargs):
+    for key, value in kwargs.items():
+        setattr(model, key, value)
+
+
+def patch_attributes_diff(model, **kwargs) -> bool:
+    """
+    Patch model attributes and return True if any were changed
+    :param model:
+    :param kwargs:
+    :return: bool
+    """
+    has_diff = False
+    for key, value in kwargs.items():
+        has_attr = hasattr(model, key)
+        current = getattr(model, key, None)
+        if not has_attr or current != value:
+            has_diff = True
+            setattr(model, key, value)
+    return has_diff
+
+
+def fake_prefetch_related(instance, attribute_name: str, value: List):
+    """
+    Inserts a list of objects into the models prefetch cache as if they were fetched via prefetch_related()
+    :param instance:
+    :param attribute_name:
+    :param value:
+    :return: None
+    """
+    cache_attr = "_prefetched_objects_cache"
+    if not hasattr(instance, cache_attr):
+        setattr(instance, cache_attr, {})
+    cache = getattr(instance, cache_attr)
+    field = getattr(instance, attribute_name)
+    prefetch_cache_name = getattr(field, "prefetch_cache_name", cache_attr)
+    cache[prefetch_cache_name] = value
+
+
+def fake_select_related(instance, attribute_name: str, value):
+    state = getattr(instance, "_state")
+    state.fields_cache[attribute_name] = value
+
+
+def prefetch_related_iterator(queryset, *related_lookups, chunk_size=100):
+    """
+    Enables optimization similar to prefetch_related for datasets that may not fit in memory
+    :param queryset:
+    :param related_lookups:
+    :param chunk_size:
+    :return:
+    """
+    qs_iterator = queryset.iterator(chunk_size=chunk_size)
+    chunks = chunk_iterator(qs_iterator, chunk_size)
+    if not related_lookups:
+        related_lookups = getattr(queryset, "_prefetch_related_lookups", [])
+    for chunk in chunks:
+        prefetch_related_objects(chunk, *related_lookups)
+        yield from chunk
+
+
+class SmartRelatedFilter:
+    """
+    Фильтр, который можно применять к загружаемым через prefetch_related Queryset'ам без дополнительного запроса к БД.
+    На выходе будет массив или queryset в зависимости от того подгружен queryset или нет
+    Поддерживаются следующие lookup'ы:
+        id=5
+        id__in=[5,6,7,8]
+    Не поддерживает Q
+    Для неподдерживаемых случаев можно использовать custom_object_filter для фильтрации кэшированных queryset'ов
+    """
+
+    lookups = {"__in": lambda obj, key, collection: getattr(obj, key[:-4]) in collection}
+
+    @staticmethod
+    def default_equals(obj, key, value):
+        return getattr(obj, key) == value
+
+    @classmethod
+    def lookup_fn_from_key(cls, key: str):
+        for lookup_key, lookup_fn in cls.lookups.items():
+            if key.endswith(lookup_key):
+                return lookup_fn
+        return cls.default_equals
+
+    @classmethod
+    def apply(cls, model, qs_attribute, *args, custom_object_filter=None, **kwargs):
+        if is_prefetched(model, qs_attribute):
+            objs = getattr(model, qs_attribute).all()
+            if custom_object_filter is not None:
+                return [obj for obj in objs if custom_object_filter(obj)]
+            return [
+                obj
+                for obj in objs
+                if all(cls.lookup_fn_from_key(key)(obj, key, value) for key, value in kwargs.items())
+            ]
+        else:
+            return getattr(model, qs_attribute).filter(*args, **kwargs)
+
+
+def smart_exists(model, qs_attribute, **kwargs):
+    objs = SmartRelatedFilter.apply(model, qs_attribute, **kwargs)
+    if is_prefetched(model, qs_attribute):
+        return bool(len(objs))
+    else:
+        return objs.exists()
+
+
+def smart_count(model, qs_attribute, **kwargs):
+    objs = SmartRelatedFilter.apply(model, qs_attribute, **kwargs)
+    if is_prefetched(model, qs_attribute):
+        return len(objs)
+    else:
+        return objs.count()
+
+
+def BooleanExpression(**kwargs):
+    return models.Case(
+        models.When(**kwargs, then=models.Value(True)), default=models.Value(False), output_field=models.BooleanField()
+    )

app/main/core/utils/text.py

+import re
+
+import bleach
+
+# TODO: use a different sanitizer implementation
+
+whitespace_line_start_re = re.compile(r"^\s+", flags=re.MULTILINE)
+whitespace_inline_re = re.compile(r"[ \t]+")
+style_re = re.compile(r"<style>(?:.|\n)*</style>", flags=re.MULTILINE)
+
+
+def html2text(html: str):
+    text = bleach.clean(html, tags=["style"], attributes={}, styles=[], strip=True)
+    text = style_re.sub("", text)
+    text = whitespace_line_start_re.sub("", text)
+    text = whitespace_inline_re.sub(" ", text)
+    return text

app/main/core/utils/validators.py

+def get_effective_attribute(attr_name, value, serializer):
+    instance = getattr(serializer, "instance")
+    return value.get(attr_name, getattr(instance, attr_name, None))

app/main/core/utils/views.py

+from rest_framework.exceptions import ValidationError
+from rest_framework.generics import get_object_or_404
+
+from main.core.utils.models import get_model_manager
+
+
+def extract_id(data):
+    if isinstance(data, int):
+        return data
+    elif isinstance(data, dict) and "id" in data:
+        return data["id"]
+    raise ValidationError({"id": "This field is required"})
+
+
+def find_object_for_data(data, model):
+    return get_object_or_404(get_model_manager(model).all(), id=extract_id(data))
+
+
+def find_objects_for_data(data, model):
+    ids = [extract_id(item) for item in data]
+    return get_model_manager(model).filter(id__in=ids).all()
+
+
+def with_headers(response, headers: dict):
+    """
+    Adds all headers to response
+    """
+    for key, value in headers.items():
+        response[key] = value
+    return response
+
+
+class BodyParser:
+    def __init__(self, body: dict):
+        self.body = body
+
+    def _get_item(self, name, consume):
+        return self.body.pop(name, None) if consume else self.body.get(name, None)
+
+    @classmethod
+    def _validate_list(cls, obj, field_name):
+        if not isinstance(obj, list):
+            raise ValidationError({field_name: "Value must be a list"})
+
+    @classmethod
+    def _validate_dict(cls, obj, field_name):
+        if not isinstance(obj, dict):
+            raise ValidationError({field_name: "Value must be a dict"})
+
+    @classmethod
+    def _validate_not_empty(cls, obj, field_name):
+        if not obj:
+            raise ValidationError({field_name: "No valid items provided"})
+
+    def int_list(self, name: str, not_empty=True, consume=True):
+        items = self._get_item(name, consume)
+        self._validate_list(items, name)
+        items_ints = [item for item in items if isinstance(item, int)]
+        if not_empty:
+            self._validate_not_empty(items, name)
+        return items_ints
+
+    def object_list(self, name: str, not_empty=True, consume=True):
+        items = self._get_item(name, consume)
+        self._validate_list(items, name)
+        if not_empty:
+            self._validate_not_empty(items, name)
+        return items
+
+    def object_dict(self, name: str, not_empty=True, consume=True):
+        object_dict = self._get_item(name, consume)
+        self._validate_dict(object_dict, name)
+        if not_empty:
+            self._validate_not_empty(object_dict, name)
+        return object_dict

app/main/core/views.py

+from django.db.models import Q
+from rest_framework.generics import get_object_or_404
+from rest_framework.response import Response
+from rest_framework.viewsets import ModelViewSet, GenericViewSet
+
+
+class VLNViewMixin:
+    @classmethod
+    def __normalize_lookup_key(cls, key):
+        if not key.endswith("_pk"):
+            return key + "_pk"
+        return key
+
+    @classmethod
+    def __normalize_router_lookup(cls, lookup):
+        lookup_pk = lookup
+        filter_keys = lookup
+        second_filter_keys = lookup
+        if not isinstance(lookup, str):
+            lookup_pk = lookup[0]
+            filter_keys = lookup[1]
+            second_filter_keys = lookup[2] if len(lookup) > 2 else None
+        lookup_pk = cls.__normalize_lookup_key(lookup_pk)
+        return lookup_pk, filter_keys, second_filter_keys
+
+    def get_router_lookup(self, key):
+        return self.kwargs.get(self.__normalize_lookup_key(key))
+
+    def get_queryset(self):
+        """
+        Automatically picks up nested router lookups from both serializer and self
+        If serializer has a method to set up prefetching, invokes it automatically with current query set
+        :return: queryset
+        """
+        qs = super().get_queryset()
+        serializer_class = self.get_serializer_class()
+        if hasattr(serializer_class, "setup_eager_loading"):
+            qs = serializer_class.setup_eager_loading(qs)
+        router_lookups = getattr(self, "router_lookups", None) or getattr(serializer_class, "router_lookups", None)
+        if router_lookups:
+            normalized_lookups = (self.__normalize_router_lookup(lookup) for lookup in router_lookups)
+            filter_kwargs = {lookup[1]: self.kwargs[lookup[0]] for lookup in normalized_lookups}
+            second_filter_kwargs = None
+            if len(router_lookups[0]) > 2:
+                normalized_lookups = (self.__normalize_router_lookup(lookup) for lookup in router_lookups)
+                second_filter_kwargs = {lookup[2]: self.kwargs[lookup[0]] for lookup in normalized_lookups}
+            if second_filter_kwargs:
+                filter_kwargs = Q(**filter_kwargs)
+                filter_kwargs |= Q(**second_filter_kwargs)
+                qs = qs.filter(filter_kwargs)
+            else:
+                qs = qs.filter(**filter_kwargs)
+        return qs
+
+
+class VLNModelViewSet(VLNViewMixin, ModelViewSet):
+    pass
+
+
+class VLNRelatedModelViewSetMixin:
+    """
+    This mixin relies on VLNViewMixin nested router lookup resolution feature.
+    You must specify router lookups for this to work (on serializer or view set).
+    Current implementation will only work for one-to-many or many-to-one fields.
+    """
+
+    def get_object(self):
+        queryset = self.filter_queryset(self.get_queryset())
+        obj = get_object_or_404(queryset)
+        self.check_object_permissions(self.request, obj)
+        return obj
+
+    def retrieve_related(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
+
+    def update_related(self, request, *args, **kwargs):
+        partial = kwargs.pop("partial", False)
+        instance = self.get_object()
+        serializer = self.get_serializer(instance, data=request.data, partial=partial)
+        serializer.is_valid(raise_exception=True)
+        self.perform_update_related(serializer)
+        if getattr(instance, "_prefetched_objects_cache", None):
+            instance._prefetched_objects_cache = {}
+        return Response(serializer.data)
+
+    def perform_update_related(self, serializer):
+        serializer.save()
+
+    def partial_update_related(self, request, *args, **kwargs):
+        kwargs["partial"] = True
+        return self.update_related(request, *args, **kwargs)
+
+
+class VLNRelatedModelViewSet(VLNRelatedModelViewSetMixin, VLNViewMixin, GenericViewSet):
+    pass

app/main/settings.py

+"""
+Django settings for voxlane-back project.
+
+Generated by 'django-admin startproject' using Django 3.0.7.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/3.0/ref/settings/
+"""
+import datetime
+import os
+import sys
+import uuid
+
+# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = "48#xjh0!2+k7uq%tb!lt7mz2!1)3wm@2u8q(*(6**45sx^6lcl"
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = os.environ.get("DEBUG", "").lower() == "true"
+DOCKER = bool(os.environ.get("DOCKER", False))
+QA = os.environ.get("QA", "").lower() == "true"
+PRODUCTION = os.environ.get("PRODUCTION", "").lower() == "true"
+TEST = "test" in sys.argv
+
+ALLOWED_HOSTS = [host.strip() for host in os.environ.get("ALLOWED_HOSTS", "").split(",") if host.strip()]
+ADMINS = [(email.strip(), email.strip()) for email in os.environ.get("ADMINS", "").strip().split(",") if email.strip()]
+PRIMARY_HOST = os.environ.get("PRIMARY_HOST", "execution").lower()
+
+# HTTPS
+
+USE_HTTPS = os.environ.get("USE_HTTPS", "true").lower() == "true"
+SESSION_COOKIE_SECURE = USE_HTTPS
+CSRF_COOKIE_SECURE = USE_HTTPS
+# TODO: set up HSTS
+
+APPEND_SLASH = True
+
+# Application definition
+
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    "computedfields",
+    "rest_framework",
+    "django_filters",
+    "django_cron",
+    "corsheaders",
+    "mptt",
+    "users.apps.UsersConfig",  # users should be last in this list, or permission update may fail
+]
+
+REST_FRAMEWORK = {
+    "DEFAULT_PERMISSION_CLASSES": ("rest_framework.permissions.IsAuthenticated",),
+    "DEFAULT_AUTHENTICATION_CLASSES": (
+        "rest_framework_simplejwt.authentication.JWTAuthentication",
+        "rest_framework.authentication.SessionAuthentication",
+        "rest_framework.authentication.BasicAuthentication",
+    ),
+    "DEFAULT_FILTER_BACKENDS": (
+        "django_filters.rest_framework.DjangoFilterBackend",
+        "rest_framework.filters.SearchFilter",
+        "main.core.filters.NestedOrderingFilter",
+    ),
+    "DEFAULT_PAGINATION_CLASS": "main.core.pagination.DefaultVLNPagination",
+}
+
+SIMPLE_JWT = {
+    "ACCESS_TOKEN_LIFETIME": datetime.timedelta(minutes=30),
+    "REFRESH_TOKEN_LIFETIME": datetime.timedelta(hours=3),
+    "AUTH_HEADER_TYPES": ("Bearer",),
+    "ROTATE_REFRESH_TOKENS": True,
+}
+
+MIDDLEWARE = [
+    "django.middleware.security.SecurityMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "corsheaders.middleware.CorsMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+    "main.core.middleware.VLNMiddleware",  # should be last
+]
+
+ROOT_URLCONF = "main.urls"
+
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.debug",
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = "main.wsgi.application"
+
+CORS_ORIGIN_ALLOW_ALL = True  # If this is used then `CORS_ORIGIN_WHITELIST` will not have any effect
+CORS_ALLOW_CREDENTIALS = True
+CORS_ORIGIN_WHITELIST = [
+    "http://localhost:4200",
+]  # If this is used, then not need to use `CORS_ORIGIN_ALLOW_ALL = True`
+CORS_ORIGIN_REGEX_WHITELIST = [
+    "http://localhost:4200",
+]
+
+# Database
+# https://docs.djangoproject.com/en/3.0/ref/settings/#databases
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.postgresql_psycopg2",
+        "HOST": os.environ.get("DB_HOST", "127.0.0.1"),
+        "PORT": os.environ.get("DB_PORT", "5432"),
+        "NAME": os.environ.get("DB_NAME", "voxlane"),
+        "USER": os.environ.get("DB_USER", "thirdlane"),
+        "PASSWORD": os.environ.get("DB_PASSWORD", "thirdlane"),
+    }
+}
+
+
+AUTH_USER_MODEL = "users.User"
+
+AUTHENTICATION_BACKENDS = [
+    "django.contrib.auth.backends.ModelBackend",
+]
+
+# Password validation
+# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
+    },
+]
+
+# Internationalization
+# https://docs.djangoproject.com/en/3.0/topics/i18n/
+
+LANGUAGE_CODE = "en"
+
+LANGUAGES = [
+    ("en", "English"),
+]
+
+TIME_ZONE = "America/New_York"
+
+USE_I18N = True
+
+USE_L10N = True
+
+USE_TZ = True
+
+LOCALE_PATHS = (os.path.join(os.path.dirname(BASE_DIR), "locale"),)
+
+# computed fields
+COMPUTEDFIELDS_MAP = "/computed_fields.map" if DOCKER else None
+COMPUTEDFIELDS_ADMIN = DEBUG
+
+# Integrations
+
+# UI_URL = os.environ.get('UI_URL', '')
+
+# Cron Jobs
+# CRON_CLASSES = [
+#     'integration.crons.ClientCronJob',
+# ]
+DJANGO_CRON_DELETE_LOGS_OLDER_THAN = 14  # days
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/3.0/howto/static-files/
+
+STATIC_URL = "/static/"
+STATIC_ROOT = os.path.join(os.path.dirname(BASE_DIR), "static")
+STATICFILES_DIRS = [
+    os.path.join(os.path.join(BASE_DIR), "static"),
+]
+
+# Mail
+
+EMAIL_HOST = os.environ.get("EMAIL_HOST", "")
+EMAIL_HOST_USER = os.environ.get("EMAIL_HOST_USER", "")
+EMAIL_HOST_PASSWORD = os.environ.get("EMAIL_HOST_PASSWORD", "")
+EMAIL_PORT = os.environ.get("EMAIL_PORT", "25")
+EMAIL_USE_TLS = os.environ.get("EMAIL_USE_TLS", "").lower() == "true"
+DEFAULT_FROM_EMAIL = os.environ.get("DEFAULT_FROM_EMAIL", f"noreply@{PRIMARY_HOST}")
+EMAIL_SUBJECT_PREFIX = os.environ.get("EMAIL_SUBJECT_PREFIX", "[EXEC]")
+EMAIL_REDIRECT_ALL_TO = [
+    email.strip() for email in os.environ.get("EMAIL_REDIRECT_ALL_TO", "").split(",") if email.strip()
+]
+
+REDIS_HOST = os.environ.get("REDIS_HOST", "localhost")
+REDIS_PORT = os.environ.get("REDIS_PORT", "6379")
+REDIS_DB_CELERY = "0"
+REDIS_DB_CACHE = "1"
+
+CELERY_BROKER_URL = f"redis://{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB_CELERY}"
+CELERY_RESULT_BACKEND = f"redis://{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB_CELERY}"
+CELERY_RESULT_EXPIRES = 3600  # seconds
+CELERY_TRACK_STARTED = True
+# CELERY_TIMEZONE = TZ
+
+COMMENT_EDITING_LIFETIME_MIN = os.environ.get("COMMENT_EDITING_LIFETIME_MIN", "30")
+
+CACHES = {
+    "default": {
+        "BACKEND": "django_redis.cache.RedisCache",
+        "LOCATION": f"redis://{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB_CACHE}",
+        "OPTIONS": {
+            "CLIENT_CLASS": "django_redis.client.DefaultClient",
+        },
+    }
+}
+
+LOGGING = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "filters": {
+        "require_debug_false": {
+            "()": "django.utils.log.RequireDebugFalse",
+        },
+        "require_debug_true": {
+            "()": "django.utils.log.RequireDebugTrue",
+        },
+    },
+    "handlers": {
+        "console_debug": {
+            "level": "DEBUG",
+            "class": "logging.StreamHandler",
+            "formatter": "short",
+            "filters": ["require_debug_true"],
+        },
+        "stdout": {
+            "level": "WARNING",
+            "class": "logging.StreamHandler",
+            "formatter": "verbose",
+            "filters": ["require_debug_false"],
+        },
+    },
+    "formatters": {
+        "verbose": {"format": "[%(levelname)s] %(asctime)s %(module)s PID=%(process)d %(message)s"},
+        "short": {"format": "[%(levelname)s] %(message)s"},
+    },
+    "loggers": {
+        "django.request": {
+            "handlers": ["stdout", "console_debug"],
+            "level": "INFO",
+            "propagate": False,
+        },
+        "django.db.backends": {
+            "level": "DEBUG",
+            "handlers": ["console_debug"],
+            "propagate": False,
+        },
+        "": {
+            "handlers": ["stdout", "console_debug"],
+            "level": "INFO",
+            "propagate": False,
+        },
+    },
+}
+
+try:
+    from .settings_local import *
+except ImportError:
+    pass

app/main/urls.py

+"""voxlane-back URL Configuration
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/3.0/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  path('', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
+Including another URLconf
+    1. Import the include() function: from django.urls import include, path
+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
+"""
+from django.contrib import admin
+from django.contrib.auth import views as auth_views
+from django.urls import path, include
+
+
+from main.auth.views import TokenObtainPairViewEx, TokenVerifyViewEx, TokenRefreshViewEx
+from main.core.routers import VLNNestedRouter, VLNRouter
+
+from users.views import UserViewSet
+
+router = VLNRouter()
+router.register("users", UserViewSet, basename="users")
+
+
+api_routes = [
+    path("", include(router.urls)),
+    path("token/auth", TokenObtainPairViewEx.as_view()),
+    path("token/refresh", TokenRefreshViewEx.as_view()),
+    path("token/verify", TokenVerifyViewEx.as_view()),
+]
+
+urlpatterns = [
+    path("api/v1/", include(api_routes)),
+    path("admin/", admin.site.urls),
+    path("accounts/login/", auth_views.LoginView.as_view(**{"template_name": "admin/login.html"})),
+]

app/main/wsgi.py

+"""
+WSGI config for voxlane-back project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "main.settings")
+
+application = get_wsgi_application()

app/manage.py

+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "main.settings")
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()

app/users/admin.py

+from django import forms
+from django.contrib import admin
+from django.contrib.admin import ModelAdmin, widgets
+from django.contrib.admin.sites import NotRegistered
+from django.contrib.auth.models import Group
+
+from users.models import User
+
+
+class UserAdmin(ModelAdmin):
+    search_fields = (
+        "username",
+        "last_name",
+        "first_name",
+    )
+    list_display = (
+        "username",
+        "last_name",
+        "first_name",
+    )
+    list_filter = ("is_active",)
+
+    readonly_fields = ("username", "is_superuser")
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "username",
+                    "last_name",
+                    "first_name",
+                    "email",
+                    "groups",
+                    "is_superuser",
+                    "object_guid",
+                )
+            },
+        ),
+    )
+
+    def has_add_permission(self, request):
+        return False
+
+
+class PairAdmin(ModelAdmin):
+    search_fields = (
+        "user__username",
+        "user__last_name",
+        "user__first_name",
+        "master__username",
+        "master__last_name",
+        "master__first_name",
+    )
+    list_display = (
+        "user",
+        "master",
+    )
+    autocomplete_fields = ["user", "master"]
+
+
+class GroupForm(forms.ModelForm):
+    name = forms.CharField(disabled=True)
+    users = forms.ModelMultipleChoiceField(
+        User.objects.all(), label="Users", required=False, widget=widgets.FilteredSelectMultiple("Users", False)
+    )
+
+    class Meta:
+        model = Group
+        exclude = ["permissions"]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instance.pk:
+            self.fields["users"].initial = self.instance.user_set.all()
+
+    def save(self, *args, **kwargs):
+        instance = super().save(*args, **kwargs)
+        self.instance.user_set.set(self.cleaned_data["users"])
+        return instance
+
+
+class GroupAdmin(admin.ModelAdmin):
+    form = GroupForm
+    search_fields = ("name",)
+    ordering = ("name",)
+
+    def has_delete_permission(self, request, obj=None):
+        return False
+
+    def has_add_permission(self, request):
+        return False
+
+
+admin.site.register(User, UserAdmin)
+
+try:
+    admin.site.unregister(Group)
+    admin.site.register(Group, GroupAdmin)
+except NotRegistered:
+    pass

app/users/apps.py

+from django.apps import AppConfig
+
+from users.constants import APP_LABEL
+
+
+class UsersConfig(AppConfig):
+    name = APP_LABEL
+    verbose_name = "Users"

app/users/constants.py

+from main.core.permissions import AutoPermissions
+
+APP_LABEL = "users"
+
+DELETED_USER_NAME = "__deleted"
+SYSTEM_USER_NAME = "vln-system"
+
+
+class UserGroup:
+    ADMINISTRATOR = "administrator"
+    MANAGER = "manager"
+    OPERATOR = "operator"
+
+
+class UserPermission(AutoPermissions(APP_LABEL, "user")):
+    class Raw:
+        IS_MANAGER = "is_manager"
+        IS_OPERATOR = "is_operator"
+
+    IS_MANAGER = ".".join((APP_LABEL, Raw.IS_MANAGER))
+    IS_OPERATOR = ".".join((APP_LABEL, Raw.IS_OPERATOR))

app/users/filters.py

+from django_filters.rest_framework import FilterSet
+from django_filters.rest_framework.filters import BaseInFilter, BooleanFilter
+from django_filters import NumberFilter
+
+
+class UserFilter(FilterSet):
+    groups = BaseInFilter(field_name="groups__name", lookup_expr="in", distinct=True)
+    masters_of = NumberFilter(field_name="employee_pairs__user_id")
+    is_active = BooleanFilter(field_name="is_active")

app/users/migrations/0001_initial.py

+# Generated by Django 3.1.7 on 2021-03-17 20:22
+
+import django.contrib.auth.models
+import django.contrib.auth.validators
+from django.db import migrations, models
+import django.utils.timezone
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("auth", "0012_alter_user_first_name_max_length"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="User",
+            fields=[
+                ("password", models.CharField(max_length=128, verbose_name="password")),
+                ("last_login", models.DateTimeField(blank=True, null=True, verbose_name="last login")),
+                (
+                    "is_superuser",
+                    models.BooleanField(
+                        default=False,
+                        help_text="Designates that this user has all permissions without explicitly assigning them.",
+                        verbose_name="superuser status",
+                    ),
+                ),
+                (
+                    "username",
+                    models.CharField(
+                        error_messages={"unique": "A user with that username already exists."},
+                        help_text="Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.",
+                        max_length=150,
+                        unique=True,
+                        validators=[django.contrib.auth.validators.UnicodeUsernameValidator()],
+                        verbose_name="username",
+                    ),
+                ),
+                ("first_name", models.CharField(blank=True, max_length=150, verbose_name="first name")),
+                ("last_name", models.CharField(blank=True, max_length=150, verbose_name="last name")),
+                ("email", models.EmailField(blank=True, max_length=254, verbose_name="email address")),
+                (
+                    "is_staff",
+                    models.BooleanField(
+                        default=False,
+                        help_text="Designates whether the user can log into this admin site.",
+                        verbose_name="staff status",
+                    ),
+                ),
+                (
+                    "is_active",
+                    models.BooleanField(
+                        default=True,
+                        help_text="Designates whether this user should be treated as active. Unselect this instead of deleting accounts.",
+                        verbose_name="active",
+                    ),
+                ),
+                ("date_joined", models.DateTimeField(default=django.utils.timezone.now, verbose_name="date joined")),
+                ("id", models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                (
+                    "groups",
+                    models.ManyToManyField(
+                        blank=True,
+                        help_text="The groups this user belongs to. A user will get all permissions granted to each of their groups.",
+                        related_name="user_set",
+                        related_query_name="user",
+                        to="auth.Group",
+                        verbose_name="groups",
+                    ),
+                ),
+                (
+                    "user_permissions",
+                    models.ManyToManyField(
+                        blank=True,
+                        help_text="Specific permissions for this user.",
+                        related_name="user_set",
+                        related_query_name="user",
+                        to="auth.Permission",
+                        verbose_name="user permissions",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "User",
+                "verbose_name_plural": "Users",
+                "permissions": [("is_manager", "MANAGER"), ("is_operator", "OPERATOR")],
+            },
+            managers=[
+                ("objects", django.contrib.auth.models.UserManager()),
+            ],
+        ),
+    ]

app/users/models.py

+import uuid
+
+from django.contrib.auth.models import AbstractUser
+from django.db import models
+
+from users.constants import UserGroup, UserPermission
+
+
+class User(AbstractUser):
+    Group = UserGroup
+    Permission = UserPermission
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+
+    class Meta:
+        verbose_name = "User"
+        verbose_name_plural = "Users"
+        permissions = [
+            (UserPermission.Raw.IS_MANAGER, "MANAGER"),
+            (UserPermission.Raw.IS_OPERATOR, "OPERATOR"),
+        ]
+
+    @property
+    def full_name(self) -> str:
+        if self.first_name or self.last_name:
+            return " ".join([self.last_name, self.first_name])
+        elif self.username:
+            return self.username
+        else:
+            return "Unknown user"

app/users/serializers.py

+from rest_framework import serializers, fields
+from rest_framework.exceptions import ValidationError
+from rest_framework.fields import ReadOnlyField
+
+from main.core.serializers import ForeignKeyDeserializerMixin
+from users.models import User
+
+
+class UserGroupsSerializer(fields.Field):
+    def to_representation(self, value):
+        return [group.name for group in value.all()]
+
+    def to_internal_value(self, data):
+        if not isinstance(data, list):
+            raise ValidationError("Groups must be a list of strings")
+        for name in data:
+            if not isinstance(name, str):
+                raise ValidationError("Group name must be a string")
+        return data
+
+
+class UserShortSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        fields = ("id", "username", "first_name", "last_name", "email")
+
+
+class UserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        read_only_fields = ("object_guid",)
+        exclude = ("date_joined", "last_login", "password", "user_permissions")
+
+    groups = UserGroupsSerializer(read_only=True)
+    permissions = serializers.SerializerMethodField()
+    is_purchase_lead = ReadOnlyField()
+    is_ko_lead = ReadOnlyField()
+    is_do_lead = ReadOnlyField()
+    is_chief_commercial_officer = ReadOnlyField()
+    is_logistics_lead = ReadOnlyField()
+    is_service_lead = ReadOnlyField()
+    is_engineering_lead = ReadOnlyField()
+
+    @staticmethod
+    def get_permissions(user):
+        return user.get_all_permissions()
+
+
+class UserShortSerializerWithFKDeserializer(ForeignKeyDeserializerMixin, UserShortSerializer):
+    pass

app/users/tests/factories.py

+import random
+
+import factory
+from factory.django import DjangoModelFactory
+from faker import Faker
+
+from users.models import User, Pair
+
+fake = Faker()
+
+
+class UserFactory(DjangoModelFactory):
+    class Meta:
+        model = User
+
+    username = factory.LazyAttribute(lambda x: f"{fake.user_name()}_{random.randint(0, 99999)}")
+    first_name = factory.Faker("first_name")
+    last_name = factory.Faker("last_name")
+    email = factory.Faker("safe_email")
+
+
+class PairFactory(DjangoModelFactory):
+    class Meta:
+        model = Pair
+
+    user = factory.SubFactory(UserFactory)
+    master = factory.SubFactory(UserFactory)

app/users/tests/test_models.py

+from django.contrib.auth.models import Group
+from django.test import TestCase
+
+from users.constants import UserGroup
+from users.tests.factories import UserFactory
+
+
+class UserTestCase(TestCase):
+    def test_group_admin_sync(self):
+        admin_group = Group.objects.get(name=UserGroup.ADMINISTRATOR)
+        user = UserFactory(username="test", email="test@example.com", password="secret")
+        self.assertFalse(user.is_superuser)
+        self.assertFalse(user.is_staff)
+
+        user.groups.add(admin_group)
+        user.refresh_from_db()
+        self.assertTrue(user.is_superuser)
+        self.assertTrue(user.is_staff)
+
+        user.groups.remove(admin_group)
+        user.refresh_from_db()
+        self.assertFalse(user.is_superuser)
+        self.assertFalse(user.is_staff)

app/users/utils.py

+import logging
+
+from django.conf import settings
+
+from main.core.middleware import CurrentRequest
+from main.core.utils import get_request_from_stack
+from users.constants import DELETED_USER_NAME, SYSTEM_USER_NAME
+
+logger = logging.getLogger(__name__)
+
+
+def get_permissions_as_dict():
+    from django.apps import apps
+
+    Permission = apps.get_model("auth", "Permission")
+    all_permissions = Permission.objects.select_related("content_type").all()
+    return {f"{p.content_type.app_label}.{p.codename}": p for p in all_permissions}
+
+
+@CurrentRequest.cached
+def get_placeholder_for_deleted_user():
+    from users.models import User
+
+    """
+    This user should own all resources created by deleted users
+    :return: User
+    """
+    return User.objects.get(username=DELETED_USER_NAME)
+
+
+@CurrentRequest.cached
+def get_system_user():
+    from users.models import User
+
+    return User.objects.get(username=SYSTEM_USER_NAME)
+
+
+# @CurrentRequest.cached
+# def get_crm_user():
+#     from users.models import User
+#     return User.objects.get(username=CRM_USER_NAME)
+
+
+def get_actor_user():
+    if CurrentRequest.user:
+        return CurrentRequest.user
+    request = get_request_from_stack()
+    user = getattr(request, "user", None)
+    if user:
+        return user
+    return get_system_user()

app/users/views.py

+from rest_framework.decorators import action
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+
+from main.core.permissions import VLNModelPermissions
+from main.core.views import VLNModelViewSet
+
+from users.filters import UserFilter
+from users.models import User
+from users.serializers import UserSerializer, UserShortSerializer
+
+
+class UserViewSet(VLNModelViewSet):
+    permission_classes = (VLNModelPermissions,)
+    serializer_class = UserShortSerializer
+    filterset_class = UserFilter
+    queryset = User.objects.all()
+    ordering = ["-id"]
+    search_fields = (
+        "username",
+        "last_name",
+        "first_name",
+    )
+
+    @action(methods=("GET",), detail=False, permission_classes=(IsAuthenticated,))
+    def me(self, request):
+        serializer = UserSerializer(self.request.user)
+        return Response(serializer.data)

deploy/etc/logrotate/logrotate.conf

+/app/logs/*.log {
+  daily
+  rotate 21
+  copytruncate
+  dateext
+  missingok
+  notifempty
+  minsize 1048576
+  compress
+  su root root
+}

deploy/etc/uwsgi/apps-enabled/django.ini

+[uwsgi]
+chdir=/app
+module=main.wsgi:application
+env DJANGO_SETTINGS_MODULE=main.settings
+master=True
+pidfile=/tmp/project-master.pid
+processes=5
+uid=1000
+gid=2000
+harakiri=60
+max-requests=5000
+vacuum=True
+single-interpreter=True
+enable-threads=True
+socket=/sock/django.sock
+#socket=0.0.0.0:8001 for a web port socket
+chmod-socket = 666
+logger = file:/app/logs/uwsgi.log
+buffer-size=8192

deploy/var/spool/cron/crontabs/root

+*/5 * * * * cd /app && python manage.py runcrons
+0 0 * * * /usr/sbin/logrotate /etc/logrotate/logrotate.conf -s /app/logs/logrotate.status --verbose

dev/.env.dev

+DB_HOST=db
+DB_PORT=5432
+DB_NAME=voxlane
+DB_USER=thirdlane
+DB_PASSWORD=thirdlane
+#PRIMARY_HOST=execution-dev.evelopers.com
+#EMAIL_HOST=192.168.63.227
+EMAIL_HOST_USER=
+EMAIL_HOST_PASSWORD=
+EMAIL_PORT=1025
+EMAIL_USE_TLS=False
+EMAIL_SUBJECT_PREFIX=[EXEC DEV]
+REDIS_HOST=redis
+USE_HTTPS=False
+ADMINS=apeshkov@thirdlane.com
+#ALLOWED_HOSTS=192.168.99.100,execution-dev.evelopers.com,localhost,django,exec
+ALLOWED_HOSTS=localhost,django

dev/docker-compose.dev.yml

+version: '3.6'
+
+services:
+  db:
+    image: postgres:13.2
+    command: -c fsync=off -c full_page_writes=off -c logging_collector=on -c log_directory=/app/logs/ -c log_filename=postgres.log
+    volumes:
+      - pg_data:/var/lib/postgresql/data
+      - ./logs:/app/logs
+    environment:
+      - POSTGRES_USER=thirdlane
+      - POSTGRES_PASSWORD=thirdlane
+      - POSTGRES_DB=voxlane
+    expose:
+      - 5432/tcp
+    ports:
+      - 5432:5432
+    networks:
+      - back-net
+  redis:
+    image: redis:6.2.1
+    command: redis-server --logfile /app/logs/redis.log
+    volumes:
+      - redis_data:/data
+      - ./logs:/app/logs
+    expose:
+      - 6379/tcp
+    ports:
+      - 6379:6379
+    networks:
+      - back-net
+  django:
+    image: voxlane-back
+    command: uwsgi --ini /etc/uwsgi/apps-enabled/django.ini
+    depends_on:
+      - db
+      - redis
+      - migration
+    ports:
+      - 8000:8000
+    env_file:
+      - ./.env.dev
+    networks:
+      - back-net
+    volumes:
+      - sock:/sock
+      - ./logs:/app/logs/
+      - ./share:/app/share
+  celery:
+    image: voxlane-back
+    command: celery -A main worker --beat --loglevel=INFO --autoscale=3,1 -f /app/logs/celery-%i.log
+    depends_on:
+      - db
+      - redis
+      - migration
+    env_file:
+      - ./.env.dev
+    networks:
+      - back-net
+    volumes:
+      - ./logs:/app/logs/
+      - ./share:/app/share
+  cron:
+    image: voxlane-back
+    command: crond -f -L /app/logs/cron.log -l 1
+    depends_on:
+      - db
+      - redis
+      - migration
+    volumes:
+      - ./logs:/app/logs/
+      - ./share:/app/share
+    env_file:
+      - ./.env.dev
+    networks:
+      - back-net
+  migration:
+    image: voxlane-back
+    command: sh -c "python /app/manage.py collectstatic --noinput && python /app/manage.py migrate --noinput && python /app/manage.py updatedata"
+    depends_on:
+      - db
+      - redis
+    env_file:
+      - ./.env.dev
+    networks:
+      - back-net
+    volumes:
+      - django_static:/static
+      - ./logs:/app/logs/
+volumes:
+  pg_data:
+  redis_data:
+  sock:
+  django_static:
+networks:
+  back-net:
+    name: vln-back

dev/docker-compose.local.yml

+version: '3.6'
+
+services:
+  db:
+    image: postgres:13.2
+    volumes:
+      - pg_data:/var/lib/postgresql/data
+    environment:
+      - POSTGRES_USER=thirdlane
+      - POSTGRES_PASSWORD=thirdlane
+      - POSTGRES_DB=voxlane
+    expose:
+      - 5432/tcp
+    ports:
+      - 5432:5432
+  mail:
+    image: mailhog/mailhog
+    logging:
+      driver: 'none'
+    expose:
+      - 1025/tcp
+    ports:
+      - 127.0.0.1:1025:1025
+      - 8025:8025
+  redis:
+    image: redis:6.2.1
+    volumes:
+      - redis_data:/data
+    ports:
+      - 36379:6379
+volumes:
+  pg_data:
+  redis_data:

docs/api/README.md

+Описываем
+[RAML](https://github.com/raml-org/raml-spec/blob/master/versions/raml-10/raml-10.md/)
+Компилируем
+[raml2html](https://github.com/raml2html/raml2html)
+```bash
+raml2html -i .\exec-api.raml -o .\exec-api.html
+```

env.example

+DB_HOST=
+DB_PORT=
+DB_NAME=
+DB_USER=
+DB_PASSWORD=

poetry.lock

+[[package]]
+name = "amqp"
+version = "5.0.5"
+description = "Low-level AMQP client for Python (fork of amqplib)."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+vine = "5.0.0"
+
+[[package]]
+name = "appdirs"
+version = "1.4.4"
+description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "appnope"
+version = "0.1.2"
+description = "Disable App Nap on macOS >= 10.9"
+category = "dev"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "asgiref"
+version = "3.3.1"
+description = "ASGI specs, helper code, and adapters"
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[package.extras]
+tests = ["pytest", "pytest-asyncio"]
+
+[[package]]
+name = "backcall"
+version = "0.2.0"
+description = "Specifications for callback functions passed in to an API"
+category = "dev"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "billiard"
+version = "3.6.3.0"
+description = "Python multiprocessing fork with improvements and bugfixes"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "celery"
+version = "5.0.5"
+description = "Distributed Task Queue."
+category = "main"
+optional = false
+python-versions = ">=3.6,"
+
+[package.dependencies]
+billiard = ">=3.6.3.0,<4.0"
+click = ">=7.0,<8.0"
+click-didyoumean = ">=0.0.3"
+click-plugins = ">=1.1.1"
+click-repl = ">=0.1.6"
+kombu = ">=5.0.0,<6.0"
+pytz = ">0.0-dev"
+vine = ">=5.0.0,<6.0"
+
+[package.extras]
+arangodb = ["pyArango (>=1.3.2)"]
+auth = ["cryptography"]
+azureblockblob = ["azure-storage (==0.36.0)", "azure-common (==1.1.5)", "azure-storage-common (==1.1.0)"]
+brotli = ["brotli (>=1.0.0)", "brotlipy (>=0.7.0)"]
+cassandra = ["cassandra-driver (<3.21.0)"]
+consul = ["python-consul"]
+cosmosdbsql = ["pydocumentdb (==2.3.2)"]
+couchbase = ["couchbase (>=3.0.0)"]
+couchdb = ["pycouchdb"]
+django = ["Django (>=1.11)"]
+dynamodb = ["boto3 (>=1.9.178)"]
+elasticsearch = ["elasticsearch"]
+eventlet = ["eventlet (>=0.26.1)"]
+gevent = ["gevent (>=1.0.0)"]
+librabbitmq = ["librabbitmq (>=1.5.0)"]
+lzma = ["backports.lzma"]
+memcache = ["pylibmc"]
+mongodb = ["pymongo[srv] (>=3.3.0)"]
+msgpack = ["msgpack"]
+pymemcache = ["python-memcached"]
+pyro = ["pyro4"]
+pytest = ["pytest-celery"]
+redis = ["redis (>=3.2.0)"]
+s3 = ["boto3 (>=1.9.125)"]
+slmq = ["softlayer-messaging (>=1.0.3)"]
+solar = ["ephem"]
+sqlalchemy = ["sqlalchemy"]
+sqs = ["boto3 (>=1.9.125)", "pycurl (==7.43.0.5)"]
+tblib = ["tblib (>=1.3.0)", "tblib (>=1.5.0)"]
+yaml = ["PyYAML (>=3.10)"]
+zookeeper = ["kazoo (>=1.3.1)"]
+zstd = ["zstandard"]
+
+[[package]]
+name = "certifi"
+version = "2020.12.5"
+description = "Python package for providing Mozilla's CA Bundle."
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "cfgv"
+version = "3.2.0"
+description = "Validate configuration and produce human readable error messages."
+category = "main"
+optional = false
+python-versions = ">=3.6.1"
+
+[[package]]
+name = "chardet"
+version = "4.0.0"
+description = "Universal encoding detector for Python 2 and 3"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "click"
+version = "7.1.2"
+description = "Composable command line interface toolkit"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "click-didyoumean"
+version = "0.0.3"
+description = "Enable git-like did-you-mean feature in click."
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+click = "*"
+
+[[package]]
+name = "click-plugins"
+version = "1.1.1"
+description = "An extension module for click to enable registering CLI commands via setuptools entry-points."
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+click = ">=4.0"
+
+[package.extras]
+dev = ["pytest (>=3.6)", "pytest-cov", "wheel", "coveralls"]
+
+[[package]]
+name = "click-repl"
+version = "0.1.6"
+description = "REPL plugin for Click"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+click = "*"
+prompt-toolkit = "*"
+six = "*"
+
+[[package]]
+name = "colorama"
+version = "0.4.4"
+description = "Cross-platform colored terminal text."
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "decorator"
+version = "4.4.2"
+description = "Decorators for Humans"
+category = "dev"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*"
+
+[[package]]
+name = "distlib"
+version = "0.3.1"
+description = "Distribution utilities"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "django"
+version = "3.1.7"
+description = "A high-level Python Web framework that encourages rapid development and clean, pragmatic design."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+asgiref = ">=3.2.10,<4"
+pytz = "*"
+sqlparse = ">=0.2.2"
+
+[package.extras]
+argon2 = ["argon2-cffi (>=16.1.0)"]
+bcrypt = ["bcrypt"]
+
+[[package]]
+name = "django-common-helpers"
+version = "0.9.2"
+description = "Common things every Django app needs!"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+Django = ">=1.8.0"
+
+[[package]]
+name = "django-computedfields"
+version = "0.1.3"
+description = "autoupdated database fields for model methods"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "django-cors-headers"
+version = "3.7.0"
+description = "django-cors-headers is a Django application for handling the server headers required for Cross-Origin Resource Sharing (CORS)."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+Django = ">=2.2"
+
+[[package]]
+name = "django-cron"
+version = "0.5.1"
+description = "Running python crons in a Django project"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+Django = ">=1.8.0"
+django-common-helpers = ">=0.6.4"
+
+[[package]]
+name = "django-extensions"
+version = "3.1.1"
+description = "Extensions for Django"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[[package]]
+name = "django-filter"
+version = "2.4.0"
+description = "Django-filter is a reusable Django application for allowing users to filter querysets dynamically."
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[package.dependencies]
+Django = ">=2.2"
+
+[[package]]
+name = "django-js-asset"
+version = "1.2.2"
+description = "script tag with additional attributes for django.forms.Media"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "django-model-utils"
+version = "4.1.1"
+description = "Django model mixins and utilities"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+Django = ">=2.0.1"
+
+[[package]]
+name = "django-mptt"
+version = "0.12.0"
+description = "Utilities for implementing Modified Preorder Tree Traversal with your Django Models and working with trees of Model instances."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+Django = ">=1.11"
+django-js-asset = "*"
+
+[[package]]
+name = "django-redis"
+version = "4.12.1"
+description = "Full featured redis cache backend for Django."
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[package.dependencies]
+Django = ">=2.2"
+redis = ">=3.0.0"
+
+[[package]]
+name = "djangorestframework"
+version = "3.12.2"
+description = "Web APIs for Django, made easy."
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[package.dependencies]
+django = ">=2.2"
+
+[[package]]
+name = "djangorestframework-simplejwt"
+version = "4.6.0"
+description = "A minimal JSON Web Token authentication plugin for Django REST Framework"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+django = "*"
+djangorestframework = "*"
+pyjwt = "*"
+
+[package.extras]
+dev = ["bumpversion (>=0.5.3,<1)", "pytest-watch", "wheel", "twine", "ipython", "cryptography", "pytest-cov", "pytest-django", "pytest-xdist", "pytest", "tox", "flake8", "pep8", "isort", "Sphinx (>=1.6.5,<2)", "sphinx-rtd-theme (>=0.1.9)", "python-jose (==3.0.0)"]
+doc = ["Sphinx (>=1.6.5,<2)", "sphinx-rtd-theme (>=0.1.9)"]
+lint = ["flake8", "pep8", "isort"]
+python-jose = ["python-jose (==3.0.0)"]
+test = ["cryptography", "pytest-cov", "pytest-django", "pytest-xdist", "pytest", "tox"]
+
+[[package]]
+name = "drf-nested-routers"
+version = "0.93.3"
+description = "Nested resources for the Django Rest Framework"
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[package.dependencies]
+Django = ">=1.11"
+djangorestframework = ">=3.6.0"
+
+[[package]]
+name = "factory-boy"
+version = "3.2.0"
+description = "A versatile test fixtures replacement based on thoughtbot's factory_bot for Ruby."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+Faker = ">=0.7.0"
+
+[package.extras]
+dev = ["coverage", "django", "flake8", "isort", "pillow", "sqlalchemy", "mongoengine", "wheel (>=0.32.0)", "tox", "zest.releaser"]
+doc = ["sphinx", "sphinx-rtd-theme", "sphinxcontrib-spelling"]
+
+[[package]]
+name = "faker"
+version = "6.6.1"
+description = "Faker is a Python package that generates fake data for you."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+python-dateutil = ">=2.4"
+text-unidecode = "1.3"
+
+[[package]]
+name = "filelock"
+version = "3.0.12"
+description = "A platform independent file lock."
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "identify"
+version = "2.1.3"
+description = "File identification library for Python"
+category = "main"
+optional = false
+python-versions = ">=3.6.1"
+
+[package.extras]
+license = ["editdistance"]
+
+[[package]]
+name = "idna"
+version = "2.10"
+description = "Internationalized Domain Names in Applications (IDNA)"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[[package]]
+name = "ipython"
+version = "7.21.0"
+description = "IPython: Productive Interactive Computing"
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+appnope = {version = "*", markers = "sys_platform == \"darwin\""}
+backcall = "*"
+colorama = {version = "*", markers = "sys_platform == \"win32\""}
+decorator = "*"
+jedi = ">=0.16"
+pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""}
+pickleshare = "*"
+prompt-toolkit = ">=2.0.0,<3.0.0 || >3.0.0,<3.0.1 || >3.0.1,<3.1.0"
+pygments = "*"
+traitlets = ">=4.2"
+
+[package.extras]
+all = ["Sphinx (>=1.3)", "ipykernel", "ipyparallel", "ipywidgets", "nbconvert", "nbformat", "nose (>=0.10.1)", "notebook", "numpy (>=1.14)", "pygments", "qtconsole", "requests", "testpath"]
+doc = ["Sphinx (>=1.3)"]
+kernel = ["ipykernel"]
+nbconvert = ["nbconvert"]
+nbformat = ["nbformat"]
+notebook = ["notebook", "ipywidgets"]
+parallel = ["ipyparallel"]
+qtconsole = ["qtconsole"]
+test = ["nose (>=0.10.1)", "requests", "testpath", "pygments", "nbformat", "ipykernel", "numpy (>=1.14)"]
+
+[[package]]
+name = "ipython-genutils"
+version = "0.2.0"
+description = "Vestigial utilities from IPython"
+category = "dev"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "jedi"
+version = "0.18.0"
+description = "An autocompletion tool for Python that can be used for text editors."
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+parso = ">=0.8.0,<0.9.0"
+
+[package.extras]
+qa = ["flake8 (==3.8.3)", "mypy (==0.782)"]
+testing = ["Django (<3.1)", "colorama", "docopt", "pytest (<6.0.0)"]
+
+[[package]]
+name = "kombu"
+version = "5.0.2"
+description = "Messaging library for Python."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+amqp = ">=5.0.0,<6.0.0"
+
+[package.extras]
+azureservicebus = ["azure-servicebus (>=0.21.1)"]
+azurestoragequeues = ["azure-storage-queue"]
+consul = ["python-consul (>=0.6.0)"]
+librabbitmq = ["librabbitmq (>=1.5.2)"]
+mongodb = ["pymongo (>=3.3.0)"]
+msgpack = ["msgpack"]
+pyro = ["pyro4"]
+qpid = ["qpid-python (>=0.26)", "qpid-tools (>=0.26)"]
+redis = ["redis (>=3.3.11)"]
+slmq = ["softlayer-messaging (>=1.0.3)"]
+sqlalchemy = ["sqlalchemy"]
+sqs = ["boto3 (>=1.4.4)", "pycurl (==7.43.0.2)"]
+yaml = ["PyYAML (>=3.10)"]
+zookeeper = ["kazoo (>=1.3.1)"]
+
+[[package]]
+name = "nodeenv"
+version = "1.5.0"
+description = "Node.js virtual environment builder"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "parso"
+version = "0.8.1"
+description = "A Python Parser"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.extras]
+qa = ["flake8 (==3.8.3)", "mypy (==0.782)"]
+testing = ["docopt", "pytest (<6.0.0)"]
+
+[[package]]
+name = "pexpect"
+version = "4.8.0"
+description = "Pexpect allows easy control of interactive console applications."
+category = "dev"
+optional = false
+python-versions = "*"
+
+[package.dependencies]
+ptyprocess = ">=0.5"
+
+[[package]]
+name = "pickleshare"
+version = "0.7.5"
+description = "Tiny 'shelve'-like database with concurrency support"
+category = "dev"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "pre-commit"
+version = "2.11.1"
+description = "A framework for managing and maintaining multi-language pre-commit hooks."
+category = "main"
+optional = false
+python-versions = ">=3.6.1"
+
+[package.dependencies]
+cfgv = ">=2.0.0"
+identify = ">=1.0.0"
+nodeenv = ">=0.11.1"
+pyyaml = ">=5.1"
+toml = "*"
+virtualenv = ">=20.0.8"
+
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.17"
+description = "Library for building powerful interactive command lines in Python"
+category = "main"
+optional = false
+python-versions = ">=3.6.1"
+
+[package.dependencies]
+wcwidth = "*"
+
+[[package]]
+name = "psycopg2"
+version = "2.8.6"
+description = "psycopg2 - Python-PostgreSQL Database Adapter"
+category = "main"
+optional = false
+python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*"
+
+[[package]]
+name = "ptyprocess"
+version = "0.7.0"
+description = "Run a subprocess in a pseudo terminal"
+category = "dev"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "pygments"
+version = "2.8.1"
+description = "Pygments is a syntax highlighting package written in Python."
+category = "dev"
+optional = false
+python-versions = ">=3.5"
+
+[[package]]
+name = "pyjwt"
+version = "2.0.1"
+description = "JSON Web Token implementation in Python"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.extras]
+crypto = ["cryptography (>=3.3.1,<4.0.0)"]
+dev = ["sphinx", "sphinx-rtd-theme", "zope.interface", "cryptography (>=3.3.1,<4.0.0)", "pytest (>=6.0.0,<7.0.0)", "coverage[toml] (==5.0.4)", "mypy", "pre-commit"]
+docs = ["sphinx", "sphinx-rtd-theme", "zope.interface"]
+tests = ["pytest (>=6.0.0,<7.0.0)", "coverage[toml] (==5.0.4)"]
+
+[[package]]
+name = "python-dateutil"
+version = "2.8.1"
+description = "Extensions to the standard Python datetime module"
+category = "main"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
+
+[package.dependencies]
+six = ">=1.5"
+
+[[package]]
+name = "pytz"
+version = "2021.1"
+description = "World timezone definitions, modern and historical"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "pyyaml"
+version = "5.4.1"
+description = "YAML parser and emitter for Python"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*"
+
+[[package]]
+name = "redis"
+version = "3.5.3"
+description = "Python client for Redis key-value store"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.extras]
+hiredis = ["hiredis (>=0.1.3)"]
+
+[[package]]
+name = "requests"
+version = "2.25.1"
+description = "Python HTTP for Humans."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.dependencies]
+certifi = ">=2017.4.17"
+chardet = ">=3.0.2,<5"
+idna = ">=2.5,<3"
+urllib3 = ">=1.21.1,<1.27"
+
+[package.extras]
+security = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)"]
+socks = ["PySocks (>=1.5.6,!=1.5.7)", "win-inet-pton"]
+
+[[package]]
+name = "six"
+version = "1.15.0"
+description = "Python 2 and 3 compatibility utilities"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[[package]]
+name = "sqlparse"
+version = "0.4.1"
+description = "A non-validating SQL parser."
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[[package]]
+name = "text-unidecode"
+version = "1.3"
+description = "The most basic Text::Unidecode port"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "toml"
+version = "0.10.2"
+description = "Python Library for Tom's Obvious, Minimal Language"
+category = "main"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[[package]]
+name = "traitlets"
+version = "5.0.5"
+description = "Traitlets Python configuration system"
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+ipython-genutils = "*"
+
+[package.extras]
+test = ["pytest"]
+
+[[package]]
+name = "urllib3"
+version = "1.26.4"
+description = "HTTP library with thread-safe connection pooling, file post, and more."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4"
+
+[package.extras]
+secure = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "certifi", "ipaddress"]
+socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
+brotli = ["brotlipy (>=0.6.0)"]
+
+[[package]]
+name = "uwsgi"
+version = "2.0.19.1"
+description = "The uWSGI server"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "vine"
+version = "5.0.0"
+description = "Promises, promises, promises."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[[package]]
+name = "virtualenv"
+version = "20.4.3"
+description = "Virtual Python Environment builder"
+category = "main"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7"
+
+[package.dependencies]
+appdirs = ">=1.4.3,<2"
+distlib = ">=0.3.1,<1"
+filelock = ">=3.0.0,<4"
+six = ">=1.9.0,<2"
+
+[package.extras]
+docs = ["proselint (>=0.10.2)", "sphinx (>=3)", "sphinx-argparse (>=0.2.5)", "sphinx-rtd-theme (>=0.4.3)", "towncrier (>=19.9.0rc1)"]
+testing = ["coverage (>=4)", "coverage-enable-subprocess (>=1)", "flaky (>=3)", "pytest (>=4)", "pytest-env (>=0.6.2)", "pytest-freezegun (>=0.4.1)", "pytest-mock (>=2)", "pytest-randomly (>=1)", "pytest-timeout (>=1)", "packaging (>=20.0)", "xonsh (>=0.9.16)"]
+
+[[package]]
+name = "wcwidth"
+version = "0.2.5"
+description = "Measures the displayed width of unicode strings in a terminal"
+category = "main"
+optional = false
+python-versions = "*"
+
+[metadata]
+lock-version = "1.1"
+python-versions = "3.9"
+content-hash = "c46ff9c693223ecfeaca500f8085a4ec29a9f9cefe0b562ee38ad8441cc03557"
+
+[metadata.files]
+amqp = [
+    {file = "amqp-5.0.5-py3-none-any.whl", hash = "sha256:1e759a7f202d910939de6eca45c23a107f6b71111f41d1282c648e9ac3d21901"},
+    {file = "amqp-5.0.5.tar.gz", hash = "sha256:affdd263d8b8eb3c98170b78bf83867cdb6a14901d586e00ddb65bfe2f0c4e60"},
+]
+appdirs = [
+    {file = "appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128"},
+    {file = "appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"},
+]
+appnope = [
+    {file = "appnope-0.1.2-py2.py3-none-any.whl", hash = "sha256:93aa393e9d6c54c5cd570ccadd8edad61ea0c4b9ea7a01409020c9aa019eb442"},
+    {file = "appnope-0.1.2.tar.gz", hash = "sha256:dd83cd4b5b460958838f6eb3000c660b1f9caf2a5b1de4264e941512f603258a"},
+]
+asgiref = [
+    {file = "asgiref-3.3.1-py3-none-any.whl", hash = "sha256:5ee950735509d04eb673bd7f7120f8fa1c9e2df495394992c73234d526907e17"},
+    {file = "asgiref-3.3.1.tar.gz", hash = "sha256:7162a3cb30ab0609f1a4c95938fd73e8604f63bdba516a7f7d64b83ff09478f0"},
+]
+backcall = [
+    {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"},
+    {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"},
+]
+billiard = [
+    {file = "billiard-3.6.3.0-py3-none-any.whl", hash = "sha256:bff575450859a6e0fbc2f9877d9b715b0bbc07c3565bb7ed2280526a0cdf5ede"},
+    {file = "billiard-3.6.3.0.tar.gz", hash = "sha256:d91725ce6425f33a97dfa72fb6bfef0e47d4652acd98a032bd1a7fbf06d5fa6a"},
+]
+celery = [
+    {file = "celery-5.0.5-py3-none-any.whl", hash = "sha256:5e8d364e058554e83bbb116e8377d90c79be254785f357cb2cec026e79febe13"},
+    {file = "celery-5.0.5.tar.gz", hash = "sha256:f4efebe6f8629b0da2b8e529424de376494f5b7a743c321c8a2ddc2b1414921c"},
+]
+certifi = [
+    {file = "certifi-2020.12.5-py2.py3-none-any.whl", hash = "sha256:719a74fb9e33b9bd44cc7f3a8d94bc35e4049deebe19ba7d8e108280cfd59830"},
+    {file = "certifi-2020.12.5.tar.gz", hash = "sha256:1a4995114262bffbc2413b159f2a1a480c969de6e6eb13ee966d470af86af59c"},
+]
+cfgv = [
+    {file = "cfgv-3.2.0-py2.py3-none-any.whl", hash = "sha256:32e43d604bbe7896fe7c248a9c2276447dbef840feb28fe20494f62af110211d"},
+    {file = "cfgv-3.2.0.tar.gz", hash = "sha256:cf22deb93d4bcf92f345a5c3cd39d3d41d6340adc60c78bbbd6588c384fda6a1"},
+]
+chardet = [
+    {file = "chardet-4.0.0-py2.py3-none-any.whl", hash = "sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5"},
+    {file = "chardet-4.0.0.tar.gz", hash = "sha256:0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa"},
+]
+click = [
+    {file = "click-7.1.2-py2.py3-none-any.whl", hash = "sha256:dacca89f4bfadd5de3d7489b7c8a566eee0d3676333fbb50030263894c38c0dc"},
+    {file = "click-7.1.2.tar.gz", hash = "sha256:d2b5255c7c6349bc1bd1e59e08cd12acbbd63ce649f2588755783aa94dfb6b1a"},
+]
+click-didyoumean = [
+    {file = "click-didyoumean-0.0.3.tar.gz", hash = "sha256:112229485c9704ff51362fe34b2d4f0b12fc71cc20f6d2b3afabed4b8bfa6aeb"},
+]
+click-plugins = [
+    {file = "click-plugins-1.1.1.tar.gz", hash = "sha256:46ab999744a9d831159c3411bb0c79346d94a444df9a3a3742e9ed63645f264b"},
+    {file = "click_plugins-1.1.1-py2.py3-none-any.whl", hash = "sha256:5d262006d3222f5057fd81e1623d4443e41dcda5dc815c06b442aa3c02889fc8"},
+]
+click-repl = [
+    {file = "click-repl-0.1.6.tar.gz", hash = "sha256:b9f29d52abc4d6059f8e276132a111ab8d94980afe6a5432b9d996544afa95d5"},
+    {file = "click_repl-0.1.6-py3-none-any.whl", hash = "sha256:9c4c3d022789cae912aad8a3f5e1d7c2cdd016ee1225b5212ad3e8691563cda5"},
+]
+colorama = [
+    {file = "colorama-0.4.4-py2.py3-none-any.whl", hash = "sha256:9f47eda37229f68eee03b24b9748937c7dc3868f906e8ba69fbcbdd3bc5dc3e2"},
+    {file = "colorama-0.4.4.tar.gz", hash = "sha256:5941b2b48a20143d2267e95b1c2a7603ce057ee39fd88e7329b0c292aa16869b"},
+]
+decorator = [
+    {file = "decorator-4.4.2-py2.py3-none-any.whl", hash = "sha256:41fa54c2a0cc4ba648be4fd43cff00aedf5b9465c9bf18d64325bc225f08f760"},
+    {file = "decorator-4.4.2.tar.gz", hash = "sha256:e3a62f0520172440ca0dcc823749319382e377f37f140a0b99ef45fecb84bfe7"},
+]
+distlib = [
+    {file = "distlib-0.3.1-py2.py3-none-any.whl", hash = "sha256:8c09de2c67b3e7deef7184574fc060ab8a793e7adbb183d942c389c8b13c52fb"},
+    {file = "distlib-0.3.1.zip", hash = "sha256:edf6116872c863e1aa9d5bb7cb5e05a022c519a4594dc703843343a9ddd9bff1"},
+]
+django = [
+    {file = "Django-3.1.7-py3-none-any.whl", hash = "sha256:baf099db36ad31f970775d0be5587cc58a6256a6771a44eb795b554d45f211b8"},
+    {file = "Django-3.1.7.tar.gz", hash = "sha256:32ce792ee9b6a0cbbec340123e229ac9f765dff8c2a4ae9247a14b2ba3a365a7"},
+]
+django-common-helpers = [
+    {file = "django-common-helpers-0.9.2.tar.gz", hash = "sha256:2d56be6fa261d829a6a224f189bf276267b9082a17d613fe5f015dd4d65c17b4"},
+]
+django-computedfields = [
+    {file = "django-computedfields-0.1.3.tar.gz", hash = "sha256:933ca7e0f01ae21f8500a05fb6a979363ffc1ee7b63779608b0e5278f1c3a4d8"},
+]
+django-cors-headers = [
+    {file = "django-cors-headers-3.7.0.tar.gz", hash = "sha256:96069c4aaacace786a34ee7894ff680780ec2644e4268b31181044410fecd12e"},
+    {file = "django_cors_headers-3.7.0-py3-none-any.whl", hash = "sha256:1ac2b1213de75a251e2ba04448da15f99bcfcbe164288ae6b5ff929dc49b372f"},
+]
+django-cron = [
+    {file = "django-cron-0.5.1.tar.gz", hash = "sha256:08d22708c8b2ecab8cda989019a66c7e1e2424c59d822796fd45abf7731d261d"},
+]
+django-extensions = [
+    {file = "django-extensions-3.1.1.tar.gz", hash = "sha256:674ad4c3b1587a884881824f40212d51829e662e52f85b012cd83d83fe1271d9"},
+    {file = "django_extensions-3.1.1-py3-none-any.whl", hash = "sha256:9507f8761ee760748938fd8af766d0608fb2738cf368adfa1b2451f61c15ae35"},
+]
+django-filter = [
+    {file = "django-filter-2.4.0.tar.gz", hash = "sha256:84e9d5bb93f237e451db814ed422a3a625751cbc9968b484ecc74964a8696b06"},
+    {file = "django_filter-2.4.0-py3-none-any.whl", hash = "sha256:e00d32cebdb3d54273c48f4f878f898dced8d5dfaad009438fe61ebdf535ace1"},
+]
+django-js-asset = [
+    {file = "django-js-asset-1.2.2.tar.gz", hash = "sha256:c163ae80d2e0b22d8fb598047cd0dcef31f81830e127cfecae278ad574167260"},
+    {file = "django_js_asset-1.2.2-py2.py3-none-any.whl", hash = "sha256:8ec12017f26eec524cab436c64ae73033368a372970af4cf42d9354fcb166bdd"},
+]
+django-model-utils = [
+    {file = "django-model-utils-4.1.1.tar.gz", hash = "sha256:eb5dd05ef7d7ce6bc79cae54ea7c4a221f6f81e2aad7722933aee66489e7264b"},
+    {file = "django_model_utils-4.1.1-py3-none-any.whl", hash = "sha256:ef7c440024e797796a3811432abdd2be8b5225ae64ef346f8bfc6de7d8e5d73c"},
+]
+django-mptt = [
+    {file = "django-mptt-0.12.0.tar.gz", hash = "sha256:8ae6c3821127b529bb2f938de27bf0771b1bcbe9dbccdfba33986af78611f13a"},
+    {file = "django_mptt-0.12.0-py2.py3-none-any.whl", hash = "sha256:63b421a054bceb7406582e2be876a80b3848a5106765baea1003696348ffd628"},
+]
+django-redis = [
+    {file = "django-redis-4.12.1.tar.gz", hash = "sha256:306589c7021e6468b2656edc89f62b8ba67e8d5a1c8877e2688042263daa7a63"},
+    {file = "django_redis-4.12.1-py3-none-any.whl", hash = "sha256:1133b26b75baa3664164c3f44b9d5d133d1b8de45d94d79f38d1adc5b1d502e5"},
+]
+djangorestframework = [
+    {file = "djangorestframework-3.12.2-py3-none-any.whl", hash = "sha256:0209bafcb7b5010fdfec784034f059d512256424de2a0f084cb82b096d6dd6a7"},
+    {file = "djangorestframework-3.12.2.tar.gz", hash = "sha256:0898182b4737a7b584a2c73735d89816343369f259fea932d90dc78e35d8ac33"},
+]
+djangorestframework-simplejwt = [
+    {file = "djangorestframework_simplejwt-4.6.0-py3-none-any.whl", hash = "sha256:bd587700b6ab34a6c6b12d426cce4fa580d57ef1952ad4ba3b79707784619ed3"},
+    {file = "djangorestframework_simplejwt-4.6.0.tar.gz", hash = "sha256:7adc913ba0d2ed7f46e0b9bf6e86f9bd9248f1c4201722b732b8213e0ea66f9f"},
+]
+drf-nested-routers = [
+    {file = "drf-nested-routers-0.93.3.tar.gz", hash = "sha256:5bbb394ce382d8392cb7eb1e24eb8ad169bf095b22b8275b8f0f1e6697000434"},
+    {file = "drf_nested_routers-0.93.3-py2.py3-none-any.whl", hash = "sha256:84e946cd486e9ec1fea12a6ca114adc0c68389ccc66e55f6c0c23ce31362485d"},
+]
+factory-boy = [
+    {file = "factory_boy-3.2.0-py2.py3-none-any.whl", hash = "sha256:1d3db4b44b8c8c54cdd8b83ae4bdb9aeb121e464400035f1f03ae0e1eade56a4"},
+    {file = "factory_boy-3.2.0.tar.gz", hash = "sha256:401cc00ff339a022f84d64a4339503d1689e8263a4478d876e58a3295b155c5b"},
+]
+faker = [
+    {file = "Faker-6.6.1-py3-none-any.whl", hash = "sha256:8814597d2c9d02824d2590e282ea0c57d1f302ae4f91e85ace0b7e710bd628a5"},
+    {file = "Faker-6.6.1.tar.gz", hash = "sha256:14e23b25d00168f09b2cf8182a17d1fe615ab26666f564248b34ef04f060bd42"},
+]
+filelock = [
+    {file = "filelock-3.0.12-py3-none-any.whl", hash = "sha256:929b7d63ec5b7d6b71b0fa5ac14e030b3f70b75747cef1b10da9b879fef15836"},
+    {file = "filelock-3.0.12.tar.gz", hash = "sha256:18d82244ee114f543149c66a6e0c14e9c4f8a1044b5cdaadd0f82159d6a6ff59"},
+]
+identify = [
+    {file = "identify-2.1.3-py2.py3-none-any.whl", hash = "sha256:46d1816c6a4fc2d1e8758f293a5dcc1ae6404ab344179d7c1e73637bf283beb1"},
+    {file = "identify-2.1.3.tar.gz", hash = "sha256:ed4a05fb80e3cbd12e83c959f9ff7f729ba6b66ab8d6178850fd5cb4c1cf6c5d"},
+]
+idna = [
+    {file = "idna-2.10-py2.py3-none-any.whl", hash = "sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0"},
+    {file = "idna-2.10.tar.gz", hash = "sha256:b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6"},
+]
+ipython = [
+    {file = "ipython-7.21.0-py3-none-any.whl", hash = "sha256:34207ffb2f653bced2bc8e3756c1db86e7d93e44ed049daae9814fed66d408ec"},
+    {file = "ipython-7.21.0.tar.gz", hash = "sha256:04323f72d5b85b606330b6d7e2dc8d2683ad46c3905e955aa96ecc7a99388e70"},
+]
+ipython-genutils = [
+    {file = "ipython_genutils-0.2.0-py2.py3-none-any.whl", hash = "sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8"},
+    {file = "ipython_genutils-0.2.0.tar.gz", hash = "sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8"},
+]
+jedi = [
+    {file = "jedi-0.18.0-py2.py3-none-any.whl", hash = "sha256:18456d83f65f400ab0c2d3319e48520420ef43b23a086fdc05dff34132f0fb93"},
+    {file = "jedi-0.18.0.tar.gz", hash = "sha256:92550a404bad8afed881a137ec9a461fed49eca661414be45059329614ed0707"},
+]
+kombu = [
+    {file = "kombu-5.0.2-py2.py3-none-any.whl", hash = "sha256:6dc509178ac4269b0e66ab4881f70a2035c33d3a622e20585f965986a5182006"},
+    {file = "kombu-5.0.2.tar.gz", hash = "sha256:f4965fba0a4718d47d470beeb5d6446e3357a62402b16c510b6a2f251e05ac3c"},
+]
+nodeenv = [
+    {file = "nodeenv-1.5.0-py2.py3-none-any.whl", hash = "sha256:5304d424c529c997bc888453aeaa6362d242b6b4631e90f3d4bf1b290f1c84a9"},
+    {file = "nodeenv-1.5.0.tar.gz", hash = "sha256:ab45090ae383b716c4ef89e690c41ff8c2b257b85b309f01f3654df3d084bd7c"},
+]
+parso = [
+    {file = "parso-0.8.1-py2.py3-none-any.whl", hash = "sha256:15b00182f472319383252c18d5913b69269590616c947747bc50bf4ac768f410"},
+    {file = "parso-0.8.1.tar.gz", hash = "sha256:8519430ad07087d4c997fda3a7918f7cfa27cb58972a8c89c2a0295a1c940e9e"},
+]
+pexpect = [
+    {file = "pexpect-4.8.0-py2.py3-none-any.whl", hash = "sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937"},
+    {file = "pexpect-4.8.0.tar.gz", hash = "sha256:fc65a43959d153d0114afe13997d439c22823a27cefceb5ff35c2178c6784c0c"},
+]
+pickleshare = [
+    {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"},
+    {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"},
+]
+pre-commit = [
+    {file = "pre_commit-2.11.1-py2.py3-none-any.whl", hash = "sha256:94c82f1bf5899d56edb1d926732f4e75a7df29a0c8c092559c77420c9d62428b"},
+    {file = "pre_commit-2.11.1.tar.gz", hash = "sha256:de55c5c72ce80d79106e48beb1b54104d16495ce7f95b0c7b13d4784193a00af"},
+]
+prompt-toolkit = [
+    {file = "prompt_toolkit-3.0.17-py3-none-any.whl", hash = "sha256:4cea7d09e46723885cb8bc54678175453e5071e9449821dce6f017b1d1fbfc1a"},
+    {file = "prompt_toolkit-3.0.17.tar.gz", hash = "sha256:9397a7162cf45449147ad6042fa37983a081b8a73363a5253dd4072666333137"},
+]
+psycopg2 = [
+    {file = "psycopg2-2.8.6-cp27-cp27m-win32.whl", hash = "sha256:068115e13c70dc5982dfc00c5d70437fe37c014c808acce119b5448361c03725"},
+    {file = "psycopg2-2.8.6-cp27-cp27m-win_amd64.whl", hash = "sha256:d160744652e81c80627a909a0e808f3c6653a40af435744de037e3172cf277f5"},
+    {file = "psycopg2-2.8.6-cp34-cp34m-win32.whl", hash = "sha256:b8cae8b2f022efa1f011cc753adb9cbadfa5a184431d09b273fb49b4167561ad"},
+    {file = "psycopg2-2.8.6-cp34-cp34m-win_amd64.whl", hash = "sha256:f22ea9b67aea4f4a1718300908a2fb62b3e4276cf00bd829a97ab5894af42ea3"},
+    {file = "psycopg2-2.8.6-cp35-cp35m-win32.whl", hash = "sha256:26e7fd115a6db75267b325de0fba089b911a4a12ebd3d0b5e7acb7028bc46821"},
+    {file = "psycopg2-2.8.6-cp35-cp35m-win_amd64.whl", hash = "sha256:00195b5f6832dbf2876b8bf77f12bdce648224c89c880719c745b90515233301"},
+    {file = "psycopg2-2.8.6-cp36-cp36m-win32.whl", hash = "sha256:a49833abfdede8985ba3f3ec641f771cca215479f41523e99dace96d5b8cce2a"},
+    {file = "psycopg2-2.8.6-cp36-cp36m-win_amd64.whl", hash = "sha256:f974c96fca34ae9e4f49839ba6b78addf0346777b46c4da27a7bf54f48d3057d"},
+    {file = "psycopg2-2.8.6-cp37-cp37m-win32.whl", hash = "sha256:6a3d9efb6f36f1fe6aa8dbb5af55e067db802502c55a9defa47c5a1dad41df84"},
+    {file = "psycopg2-2.8.6-cp37-cp37m-win_amd64.whl", hash = "sha256:56fee7f818d032f802b8eed81ef0c1232b8b42390df189cab9cfa87573fe52c5"},
+    {file = "psycopg2-2.8.6-cp38-cp38-win32.whl", hash = "sha256:ad2fe8a37be669082e61fb001c185ffb58867fdbb3e7a6b0b0d2ffe232353a3e"},
+    {file = "psycopg2-2.8.6-cp38-cp38-win_amd64.whl", hash = "sha256:56007a226b8e95aa980ada7abdea6b40b75ce62a433bd27cec7a8178d57f4051"},
+    {file = "psycopg2-2.8.6-cp39-cp39-win32.whl", hash = "sha256:2c93d4d16933fea5bbacbe1aaf8fa8c1348740b2e50b3735d1b0bf8154cbf0f3"},
+    {file = "psycopg2-2.8.6-cp39-cp39-win_amd64.whl", hash = "sha256:d5062ae50b222da28253059880a871dc87e099c25cb68acf613d9d227413d6f7"},
+    {file = "psycopg2-2.8.6.tar.gz", hash = "sha256:fb23f6c71107c37fd667cb4ea363ddeb936b348bbd6449278eb92c189699f543"},
+]
+ptyprocess = [
+    {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"},
+    {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"},
+]
+pygments = [
+    {file = "Pygments-2.8.1-py3-none-any.whl", hash = "sha256:534ef71d539ae97d4c3a4cf7d6f110f214b0e687e92f9cb9d2a3b0d3101289c8"},
+    {file = "Pygments-2.8.1.tar.gz", hash = "sha256:2656e1a6edcdabf4275f9a3640db59fd5de107d88e8663c5d4e9a0fa62f77f94"},
+]
+pyjwt = [
+    {file = "PyJWT-2.0.1-py3-none-any.whl", hash = "sha256:b70b15f89dc69b993d8a8d32c299032d5355c82f9b5b7e851d1a6d706dffe847"},
+    {file = "PyJWT-2.0.1.tar.gz", hash = "sha256:a5c70a06e1f33d81ef25eecd50d50bd30e34de1ca8b2b9fa3fe0daaabcf69bf7"},
+]
+python-dateutil = [
+    {file = "python-dateutil-2.8.1.tar.gz", hash = "sha256:73ebfe9dbf22e832286dafa60473e4cd239f8592f699aa5adaf10050e6e1823c"},
+    {file = "python_dateutil-2.8.1-py2.py3-none-any.whl", hash = "sha256:75bb3f31ea686f1197762692a9ee6a7550b59fc6ca3a1f4b5d7e32fb98e2da2a"},
+]
+pytz = [
+    {file = "pytz-2021.1-py2.py3-none-any.whl", hash = "sha256:eb10ce3e7736052ed3623d49975ce333bcd712c7bb19a58b9e2089d4057d0798"},
+    {file = "pytz-2021.1.tar.gz", hash = "sha256:83a4a90894bf38e243cf052c8b58f381bfe9a7a483f6a9cab140bc7f702ac4da"},
+]
+pyyaml = [
+    {file = "PyYAML-5.4.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:3b2b1824fe7112845700f815ff6a489360226a5609b96ec2190a45e62a9fc922"},
+    {file = "PyYAML-5.4.1-cp27-cp27m-win32.whl", hash = "sha256:129def1b7c1bf22faffd67b8f3724645203b79d8f4cc81f674654d9902cb4393"},
+    {file = "PyYAML-5.4.1-cp27-cp27m-win_amd64.whl", hash = "sha256:4465124ef1b18d9ace298060f4eccc64b0850899ac4ac53294547536533800c8"},
+    {file = "PyYAML-5.4.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:bb4191dfc9306777bc594117aee052446b3fa88737cd13b7188d0e7aa8162185"},
+    {file = "PyYAML-5.4.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:6c78645d400265a062508ae399b60b8c167bf003db364ecb26dcab2bda048253"},
+    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:4e0583d24c881e14342eaf4ec5fbc97f934b999a6828693a99157fde912540cc"},
+    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:72a01f726a9c7851ca9bfad6fd09ca4e090a023c00945ea05ba1638c09dc3347"},
+    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux2014_s390x.whl", hash = "sha256:895f61ef02e8fed38159bb70f7e100e00f471eae2bc838cd0f4ebb21e28f8541"},
+    {file = "PyYAML-5.4.1-cp36-cp36m-win32.whl", hash = "sha256:3bd0e463264cf257d1ffd2e40223b197271046d09dadf73a0fe82b9c1fc385a5"},
+    {file = "PyYAML-5.4.1-cp36-cp36m-win_amd64.whl", hash = "sha256:e4fac90784481d221a8e4b1162afa7c47ed953be40d31ab4629ae917510051df"},
+    {file = "PyYAML-5.4.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:5accb17103e43963b80e6f837831f38d314a0495500067cb25afab2e8d7a4018"},
+    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:e1d4970ea66be07ae37a3c2e48b5ec63f7ba6804bdddfdbd3cfd954d25a82e63"},
+    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:cb333c16912324fd5f769fff6bc5de372e9e7a202247b48870bc251ed40239aa"},
+    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux2014_s390x.whl", hash = "sha256:fe69978f3f768926cfa37b867e3843918e012cf83f680806599ddce33c2c68b0"},
+    {file = "PyYAML-5.4.1-cp37-cp37m-win32.whl", hash = "sha256:dd5de0646207f053eb0d6c74ae45ba98c3395a571a2891858e87df7c9b9bd51b"},
+    {file = "PyYAML-5.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:08682f6b72c722394747bddaf0aa62277e02557c0fd1c42cb853016a38f8dedf"},
+    {file = "PyYAML-5.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d2d9808ea7b4af864f35ea216be506ecec180628aced0704e34aca0b040ffe46"},
+    {file = "PyYAML-5.4.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:8c1be557ee92a20f184922c7b6424e8ab6691788e6d86137c5d93c1a6ec1b8fb"},
+    {file = "PyYAML-5.4.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:fd7f6999a8070df521b6384004ef42833b9bd62cfee11a09bda1079b4b704247"},
+    {file = "PyYAML-5.4.1-cp38-cp38-manylinux2014_s390x.whl", hash = "sha256:bfb51918d4ff3d77c1c856a9699f8492c612cde32fd3bcd344af9be34999bfdc"},
+    {file = "PyYAML-5.4.1-cp38-cp38-win32.whl", hash = "sha256:fa5ae20527d8e831e8230cbffd9f8fe952815b2b7dae6ffec25318803a7528fc"},
+    {file = "PyYAML-5.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:0f5f5786c0e09baddcd8b4b45f20a7b5d61a7e7e99846e3c799b05c7c53fa696"},
+    {file = "PyYAML-5.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:294db365efa064d00b8d1ef65d8ea2c3426ac366c0c4368d930bf1c5fb497f77"},
+    {file = "PyYAML-5.4.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:74c1485f7707cf707a7aef42ef6322b8f97921bd89be2ab6317fd782c2d53183"},
+    {file = "PyYAML-5.4.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:d483ad4e639292c90170eb6f7783ad19490e7a8defb3e46f97dfe4bacae89122"},
+    {file = "PyYAML-5.4.1-cp39-cp39-manylinux2014_s390x.whl", hash = "sha256:fdc842473cd33f45ff6bce46aea678a54e3d21f1b61a7750ce3c498eedfe25d6"},
+    {file = "PyYAML-5.4.1-cp39-cp39-win32.whl", hash = "sha256:49d4cdd9065b9b6e206d0595fee27a96b5dd22618e7520c33204a4a3239d5b10"},
+    {file = "PyYAML-5.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:c20cfa2d49991c8b4147af39859b167664f2ad4561704ee74c1de03318e898db"},
+    {file = "PyYAML-5.4.1.tar.gz", hash = "sha256:607774cbba28732bfa802b54baa7484215f530991055bb562efbed5b2f20a45e"},
+]
+redis = [
+    {file = "redis-3.5.3-py2.py3-none-any.whl", hash = "sha256:432b788c4530cfe16d8d943a09d40ca6c16149727e4afe8c2c9d5580c59d9f24"},
+    {file = "redis-3.5.3.tar.gz", hash = "sha256:0e7e0cfca8660dea8b7d5cd8c4f6c5e29e11f31158c0b0ae91a397f00e5a05a2"},
+]
+requests = [
+    {file = "requests-2.25.1-py2.py3-none-any.whl", hash = "sha256:c210084e36a42ae6b9219e00e48287def368a26d03a048ddad7bfee44f75871e"},
+    {file = "requests-2.25.1.tar.gz", hash = "sha256:27973dd4a904a4f13b263a19c866c13b92a39ed1c964655f025f3f8d3d75b804"},
+]
+six = [
+    {file = "six-1.15.0-py2.py3-none-any.whl", hash = "sha256:8b74bedcbbbaca38ff6d7491d76f2b06b3592611af620f8426e82dddb04a5ced"},
+    {file = "six-1.15.0.tar.gz", hash = "sha256:30639c035cdb23534cd4aa2dd52c3bf48f06e5f4a941509c8bafd8ce11080259"},
+]
+sqlparse = [
+    {file = "sqlparse-0.4.1-py3-none-any.whl", hash = "sha256:017cde379adbd6a1f15a61873f43e8274179378e95ef3fede90b5aa64d304ed0"},
+    {file = "sqlparse-0.4.1.tar.gz", hash = "sha256:0f91fd2e829c44362cbcfab3e9ae12e22badaa8a29ad5ff599f9ec109f0454e8"},
+]
+text-unidecode = [
+    {file = "text-unidecode-1.3.tar.gz", hash = "sha256:bad6603bb14d279193107714b288be206cac565dfa49aa5b105294dd5c4aab93"},
+    {file = "text_unidecode-1.3-py2.py3-none-any.whl", hash = "sha256:1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8"},
+]
+toml = [
+    {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
+    {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
+]
+traitlets = [
+    {file = "traitlets-5.0.5-py3-none-any.whl", hash = "sha256:69ff3f9d5351f31a7ad80443c2674b7099df13cc41fc5fa6e2f6d3b0330b0426"},
+    {file = "traitlets-5.0.5.tar.gz", hash = "sha256:178f4ce988f69189f7e523337a3e11d91c786ded9360174a3d9ca83e79bc5396"},
+]
+urllib3 = [
+    {file = "urllib3-1.26.4-py2.py3-none-any.whl", hash = "sha256:2f4da4594db7e1e110a944bb1b551fdf4e6c136ad42e4234131391e21eb5b0df"},
+    {file = "urllib3-1.26.4.tar.gz", hash = "sha256:e7b021f7241115872f92f43c6508082facffbd1c048e3c6e2bb9c2a157e28937"},
+]
+uwsgi = [
+    {file = "uWSGI-2.0.19.1.tar.gz", hash = "sha256:faa85e053c0b1be4d5585b0858d3a511d2cd10201802e8676060fd0a109e5869"},
+]
+vine = [
+    {file = "vine-5.0.0-py2.py3-none-any.whl", hash = "sha256:4c9dceab6f76ed92105027c49c823800dd33cacce13bdedc5b914e3514b7fb30"},
+    {file = "vine-5.0.0.tar.gz", hash = "sha256:7d3b1624a953da82ef63462013bbd271d3eb75751489f9807598e8f340bd637e"},
+]
+virtualenv = [
+    {file = "virtualenv-20.4.3-py2.py3-none-any.whl", hash = "sha256:83f95875d382c7abafe06bd2a4cdd1b363e1bb77e02f155ebe8ac082a916b37c"},
+    {file = "virtualenv-20.4.3.tar.gz", hash = "sha256:49ec4eb4c224c6f7dd81bb6d0a28a09ecae5894f4e593c89b0db0885f565a107"},
+]
+wcwidth = [
+    {file = "wcwidth-0.2.5-py2.py3-none-any.whl", hash = "sha256:beb4802a9cebb9144e99086eff703a642a13d6a0052920003a230f3294bbe784"},
+    {file = "wcwidth-0.2.5.tar.gz", hash = "sha256:c4d647b99872929fdb7bdcaa4fbe7f01413ed3d98077df798530e5b04f116c83"},
+]

pyproject.toml

+[tool.poetry]
+name = "voxlane-back"
+version = "0.1.0"
+description = ""
+authors = ["apeshkov <apeshkov@evelopers.com>"]
+repository = "https://gitlab.thirdlane.com/voxlane-app/voxlane-back"
+
+[tool.poetry.dependencies]
+python = "3.9"
+Django = "3.1.7"
+django-computedfields = "0.1.3"
+django-cors-headers = "3.7.0"
+django-cron = "0.5.1"
+django-model-utils = "4.1.1"
+django-extensions = "3.1.1"
+django-redis = "4.12.1"
+djangorestframework = "3.12.2"
+djangorestframework-simplejwt = "4.6.0"
+drf-nested-routers = "0.93.3"
+django-filter = "2.4.0"
+django-mptt = "0.12.0"
+factory-boy = "3.2.0"
+Faker = "6.6.1"
+psycopg2 = "2.8.6"
+python-dateutil = "2.8.1"
+PyJWT = "2.0.1"
+pytz = "2021.1"
+requests = "2.25.1"
+uWSGI = "2.0.19.1"
+celery = "5.0.5"
+redis = "3.5.3"
+pre-commit = "^2.11.1"
+
+[tool.poetry.dev-dependencies]
+ipython = "^7.21.0"
+
+[tool.black]
+line-length = 120
+include = '\.pyi?$'
+exclude = '/( \.git | \.venv | docs | static )/'
+
+
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

+# bleach==3.2.1
+Django==3.1.7
+django-computedfields==0.1.3
+django-cors-headers==3.7.0
+django-cron==0.5.1
+django-model-utils==4.1.1
+django-extensions==3.1.1
+django-redis==4.12.1
+djangorestframework==3.12.2
+djangorestframework-simplejwt==4.6.0
+drf-nested-routers==0.93.3
+django-filter==2.4.0
+django-mptt==0.12.0
+factory_boy==3.2.0
+# graphviz==0.16
+Faker==6.6.1
+# openpyxl==3.0.7
+psycopg2==2.8.6
+python-dateutil==2.8.1
+PyJWT==2.0.1
+# for windows venv/Scripts/python_ldap-3.2.0-cp38-cp38-win32.whl from https://www.lfd.uci.edu/~gohlke/pythonlibs/#python-ldap
+pytz==2021.1
+requests==2.25.1
+# sqlparse==0.4.1
+uwsgi==2.0.19.1
+celery==5.0.5
+redis==3.5.3
+# pika==1.1.0