utg-base 1.5.1__tar.gz

utg_base-1.5.1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: utg-base
+Version: 1.5.1
+Summary: UTG Base Package
+Author: Rovshen
+Author-email: rovshenashirov1619@gmail.com
+Requires-Python: >=3.14,<4.0
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: celery (>=5.5.3,<6.0.0)
+Requires-Dist: croniter (>=2.0.3,<3.0.0)
+Requires-Dist: django (>=5.2.7,<6.0.0)
+Requires-Dist: django-celery-beat (>=2.8.1,<3.0.0)
+Requires-Dist: django-celery-results (>=2.6.0,<3.0.0)
+Requires-Dist: django-filter (>=23.5,<24.0)
+Requires-Dist: djangorestframework (>=3.16.1,<4.0.0)
+Requires-Dist: djangorestframework-simplejwt[crypto] (>=5.5.1,<6.0.0)
+Requires-Dist: dotenv (>=0.9.9,<0.10.0)
+Requires-Dist: drf-spectacular[sidecar] (>=0.29.0,<0.30.0)
+Requires-Dist: hvac (>=2.4.0,<3.0.0)
+Requires-Dist: inflect (>=7.2.1,<8.0.0)
+Requires-Dist: openpyxl (>=3.1.2,<4.0.0)
+Description-Content-Type: text/markdown
+
+# UzTransGas Base

utg_base-1.5.1/README.md

@@ -0,0 +1 @@
+# UzTransGas Base

utg_base-1.5.1/pyproject.toml

@@ -0,0 +1,30 @@
+[tool.poetry]
+name = "utg-base"
+version = "1.5.1"
+description = "UTG Base Package"
+authors = ["Rovshen <rovshenashirov1619@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.14"
+djangorestframework = "^3.16.1"
+djangorestframework-simplejwt = {extras = ["crypto"], version = "^5.5.1"}
+django = "^5.2.7"
+django-filter = "^23.5"
+croniter = "^2.0.3"
+drf-spectacular = {extras = ["sidecar"], version = "^0.29.0"}
+openpyxl = "^3.1.2"
+inflect = "^7.2.1"
+celery = "^5.5.3"
+django-celery-beat = "^2.8.1"
+django-celery-results = "^2.6.0"
+hvac = "^2.4.0"
+dotenv = "^0.9.9"
+
+[[tool.poetry.source]]
+name = "PyPI"
+priority = "primary"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

utg_base-1.5.1/src/utg_base/api/base.py

@@ -0,0 +1,73 @@
+from django.utils import timezone
+from django.utils.translation import activate, get_language
+from rest_framework.request import Request
+from rest_framework.views import APIView
+
+from utg_base.constants import AVAILABLE_LANGUAGES
+from utg_base.models import JWTUser
+
+
+class BaseRequest(Request):
+
+    @property
+    def user(self) -> JWTUser:
+        return super(BaseRequest, self).user()
+
+
+class BaseAPIView(APIView):
+    user_id_assign_fields_on_create = []
+    user_id_assign_fields_on_update = []
+    user_id_assign_fields_on_delete = []
+    deleted_at_field = None
+
+    def __init__(self, **kwargs):
+        # Check user_id_assign_fields_on_create
+        assert isinstance(self.user_id_assign_fields_on_create, list), (
+            'Expected iterable user_id_assign_fields_on_create field'
+        )
+
+        # Check user_id_assign_fields_on_update
+        assert isinstance(self.user_id_assign_fields_on_update, list), (
+            'Expected iterable user_id_assign_fields_on_update field'
+        )
+
+        # Check user_id_assign_fields_on_delete
+        assert isinstance(self.user_id_assign_fields_on_delete, list), (
+            'Expected iterable user_id_assign_fields_on_delete field'
+        )
+
+        # Check deleted_at_field
+        assert isinstance(self.deleted_at_field, (str, type(None))), (
+            'Expected str | None deleted_at_field field'
+        )
+        super().__init__(**kwargs)
+        self.request: BaseRequest | None = None
+
+    def perform_create(self, serializer):
+        kws = {}
+        for attr in getattr(self, 'user_id_assign_fields_on_create', []):
+            kws[attr] = self.request.user.id
+        serializer.save(**kws)
+
+    def perform_update(self, serializer):
+        kws = {}
+        for attr in getattr(self, 'user_id_assign_fields_on_update', []):
+            kws[attr] = self.request.user.id
+        serializer.save(**kws)
+
+    def perform_destroy(self, instance):
+        for attr in getattr(self, 'user_id_assign_fields_on_delete', []):
+            setattr(instance, attr, self.request.user.id)
+        if self.deleted_at_field and hasattr(instance, self.deleted_at_field):
+            setattr(instance, self.deleted_at_field, timezone.now())
+        instance.save()
+
+    def update_lang(self):
+        activate(self.get_language())
+
+    def get_language(self):
+        if lang_from_header := self.request.headers.get('accept-language'):
+            if lang_from_header and lang_from_header not in AVAILABLE_LANGUAGES:
+                lang_from_header = 'ru'
+
+        return lang_from_header or get_language()

utg_base-1.5.1/src/utg_base/api/pagination.py

@@ -0,0 +1,33 @@
+from rest_framework.pagination import PageNumberPagination
+from rest_framework.response import Response
+
+
+class Pagination(PageNumberPagination):
+    page_size_query_param = 'page_size'
+    max_page_size = 200
+
+    def get_paginated_response(self, data):
+        return Response({
+            'page': self.page.number,
+            'pageSize': self.page.paginator.per_page,
+            'count': self.page.end_index() - self.page.start_index() + 1,
+            'total': self.page.paginator.count,
+            'pagesCount': self.page.paginator.num_pages,
+            'data': data,
+        })
+
+
+class LargeResultsSetPagination(Pagination):
+    page_size = 50
+
+
+class StandardResultsSetPagination(Pagination):
+    page_size = 20
+
+
+class SmallResultsSetPagination(Pagination):
+    page_size = 10
+
+
+class MiniResultsSetPagination(Pagination):
+    page_size = 5

utg_base-1.5.1/src/utg_base/api/permissions.py

@@ -0,0 +1,11 @@
+from rest_framework.permissions import BasePermission
+
+
+class IsSuperUser(BasePermission):
+    """
+    Custom permission to allow access only to superusers.
+    """
+
+    def has_permission(self, request, view):
+        # Check if the requesting user is a superuser
+        return request.user and request.user.is_superuser

utg_base-1.5.1/src/utg_base/api/routers.py

@@ -0,0 +1,7 @@
+from rest_framework.routers import SimpleRouter
+
+
+class OptionalSlashRouter(SimpleRouter):
+    def __init__(self):
+        super().__init__()
+        self.trailing_slash = '/?'

utg_base-1.5.1/src/utg_base/api/serializers.py

@@ -0,0 +1,39 @@
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
+
+from utg_base.utils.date import to_udate, to_udatetime
+from utg_base.utils.translation import translate as _
+
+
+class UDateField(serializers.DateField):
+    def to_internal_value(self, value):
+        return to_udate(super().to_internal_value(value))
+
+
+class UDateTimeField(serializers.DateTimeField):
+    def to_internal_value(self, value):
+        return to_udatetime(super().to_internal_value(value))
+
+
+class DateSerializer(serializers.Serializer):
+    dt = UDateField()
+
+
+class DatePeriodSerializer(DateSerializer):
+    period = serializers.ChoiceField(choices=['daily', 'monthly', 'yearly'], default='daily')
+
+
+class DateTimePeriodSerializer(DateSerializer):
+    dt = UDateTimeField(required=False)
+    period = serializers.ChoiceField(choices=['hourly', 'today', 'daily', 'monthly', 'yearly'], default='daily')
+
+    def validate(self, attrs):
+        period = attrs.get('period', 'daily')
+        dt = attrs.get('dt')
+
+        if period != 'today' and dt is None:
+            raise ValidationError({
+                'dt': _('This field is required when period is not "today".')
+            })
+        return attrs
+

utg_base-1.5.1/src/utg_base/api/views.py

@@ -0,0 +1,13 @@
+
+from django.db.models import Manager
+from rest_framework import generics
+
+from .base import BaseAPIView
+
+
+class TranslatedListView(generics.ListAPIView, BaseAPIView):
+    manager: Manager
+
+    def get_queryset(self):
+        self.update_lang()
+        return self.manager.all()

utg_base-1.5.1/src/utg_base/authentications/__init__.py

@@ -0,0 +1,2 @@
+from .models import MicroserviceUser
+from .microservice_authentication import MicroserviceUserAuthentication

utg_base-1.5.1/src/utg_base/authentications/microservice_authentication.py

@@ -0,0 +1,29 @@
+from ipaddress import ip_address, ip_network
+
+from rest_framework import authentication
+
+from . import MicroserviceUser
+
+
+class MicroserviceUserAuthentication(authentication.BaseAuthentication):
+    # List of local IP address ranges
+    local_ip_ranges = [
+        '127.0.0.0/8',  # Loopback addresses
+        '10.0.0.0/8',  # Private network addresses
+        '172.16.0.0/12',  # Private network addresses
+        '192.168.0.0/16',  # Private network addresses
+        # Add more local ranges if needed
+    ]
+
+    def authenticate(self, request):
+        client_ip = request.META.get('REMOTE_ADDR', None)
+        server_ip = request.META.get('SERVER_ADDR', None)
+
+        if any(ip_address(client_ip) in ip_network(ip_range, strict=False) for ip_range in self.local_ip_ranges):
+            return self.get_user(), None
+
+        if client_ip == server_ip:
+            return self.get_user(), None
+
+    def get_user(self) -> MicroserviceUser:
+        return MicroserviceUser()

utg_base-1.5.1/src/utg_base/authentications/models.py

@@ -0,0 +1,92 @@
+from typing import List, Optional, Union
+
+from django.contrib.auth import models as auth_models
+from django.db.models.manager import EmptyManager
+from django.utils.functional import cached_property
+
+
+class MicroserviceUser:
+    is_active = True
+
+    _groups = EmptyManager(auth_models.Group)
+    _user_permissions = EmptyManager(auth_models.Permission)
+
+    def __str__(self) -> str:
+        return f"{self.id}"
+
+    @cached_property
+    def id(self) -> Union[int, str]:
+        return -1
+
+    @cached_property
+    def pk(self) -> Union[int, str]:
+        return self.id
+
+    @cached_property
+    def username(self) -> str:
+        return 'microservice'
+
+    @cached_property
+    def is_staff(self) -> bool:
+        return True
+
+    @cached_property
+    def is_superuser(self) -> bool:
+        return True
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, MicroserviceUser):
+            return NotImplemented
+        return self.id == other.id
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    def save(self) -> None:
+        raise NotImplementedError("Microservice users have no DB representation")
+
+    def delete(self) -> None:
+        raise NotImplementedError("Microservice users have no DB representation")
+
+    def set_password(self, raw_password: str) -> None:
+        raise NotImplementedError("Microservice users have no DB representation")
+
+    def check_password(self, raw_password: str) -> None:
+        raise NotImplementedError("Microservice users have no DB representation")
+
+    @property
+    def groups(self) -> auth_models.Group:
+        return self._groups
+
+    @property
+    def user_permissions(self) -> auth_models.Permission:
+        return self._user_permissions
+
+    def get_group_permissions(self, obj: Optional[object] = None) -> set:
+        return set()
+
+    def get_all_permissions(self, obj: Optional[object] = None) -> set:
+        return set()
+
+    def has_perm(self, perm: str, obj: Optional[object] = None) -> bool:
+        return False
+
+    def has_perms(self, perm_list: List[str], obj: Optional[object] = None) -> bool:
+        return False
+
+    def has_module_perms(self, module: str) -> bool:
+        return False
+
+    @property
+    def is_anonymous(self) -> bool:
+        return False
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    def get_username(self) -> str:
+        return self.username

utg_base-1.5.1/src/utg_base/celery/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class QApiConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "utg_base.celery"

utg_base-1.5.1/src/utg_base/celery/filters/__init__.py

@@ -0,0 +1 @@
+from .task_result import TaskResultFilterSet

utg_base-1.5.1/src/utg_base/celery/filters/task_result.py

@@ -0,0 +1,5 @@
+from django_filters import rest_framework as filters
+
+
+class TaskResultFilterSet(filters.FilterSet):
+    status = filters.BooleanFilter()

utg_base-1.5.1/src/utg_base/celery/management/commands/migrate_tasks.py

@@ -0,0 +1,45 @@
+import importlib
+import json
+
+from django.core.management.base import BaseCommand
+from django_celery_beat.models import CrontabSchedule, PeriodicTask
+
+
+class Command(BaseCommand):
+    help = "Migrate tasks"
+
+    def add_arguments(self, parser):
+        parser.add_argument('--app', type=str, help="An optional argument", required=True)
+
+    def handle(self, *args, **options):
+        try:
+            tasks = importlib.import_module(f"{options['app']}.tasks")
+            tasks = tasks.tasks
+            for task in tasks:
+                celery_task, _ = PeriodicTask.objects.update_or_create(
+                    name=task['name'],
+                    defaults={
+                        'crontab': self.get_crontab_schedule(task['crontab']),
+                        'task': task['task'].name,
+                        'args': json.dumps(task.get('args') or []),
+                        'kwargs': json.dumps(task.get('kwargs') or {}),
+                        'enabled': task.get('enabled', True),
+                    }
+                )
+            self.stdout.write(
+                self.style.SUCCESS('Successfully migrated tasks')
+            )
+        except ModuleNotFoundError:
+            self.stdout.write(self.style.ERROR("Tasks module not found"))
+
+    @staticmethod
+    def get_crontab_schedule(crontab='* * * * *'):
+        minute, hour, day_of_month, month_of_year, day_of_week = crontab.split(' ')
+        cron, _ = CrontabSchedule.objects.get_or_create(
+            minute=minute,
+            hour=hour,
+            day_of_month=day_of_month,
+            month_of_year=month_of_year,
+            day_of_week=day_of_week,
+        )
+        return cron

utg_base-1.5.1/src/utg_base/celery/serializers/__init__.py

@@ -0,0 +1,2 @@
+from .task_result import TaskResultSerializer
+from .periodic_task import PeriodicTaskSerializer

utg_base-1.5.1/src/utg_base/celery/serializers/periodic_task.py

@@ -0,0 +1,38 @@
+from django_celery_beat.models import PeriodicTask, CrontabSchedule
+from django_celery_results.models import TaskResult
+from rest_framework import serializers
+
+
+from utg_base.celery.serializers import TaskResultSerializer
+
+
+class CrontabScheduleSerializer(serializers.ModelSerializer):
+    timezone = serializers.SerializerMethodField()
+
+    class Meta:
+        model = CrontabSchedule
+        fields = '__all__'
+
+    def get_timezone(self, obj):
+        return str(obj.timezone) if obj.timezone else None
+
+
+class PeriodicTaskSerializer(serializers.ModelSerializer):
+    crontab = CrontabScheduleSerializer(read_only=True)
+    task_result = serializers.SerializerMethodField(read_only=True)
+
+    class Meta:
+        model = PeriodicTask
+        fields = '__all__'
+        read_only_fields = ['name', 'task', 'args', 'kwargs', 'queue', 'exchange', 'routing_key', 'headers', 'priority',
+                            'expires', 'expire_seconds', 'one_off', 'start_time', 'interval', 'solar', 'clocked']
+
+    def get_task_result(self, obj):
+        latest_task_result = TaskResult.objects.filter(
+            periodic_task_name=obj.name
+        ).order_by('-date_created').first()
+
+        if not latest_task_result:
+            return None
+
+        return TaskResultSerializer(latest_task_result).data

utg_base-1.5.1/src/utg_base/celery/serializers/task_result.py

@@ -0,0 +1,8 @@
+from django_celery_results.models import TaskResult
+from rest_framework import serializers
+
+
+class TaskResultSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = TaskResult
+        fields = '__all__'

utg_base-1.5.1/src/utg_base/celery/urls.py

@@ -0,0 +1,14 @@
+from django.urls import path
+
+from utg_base.api.routers import OptionalSlashRouter
+from utg_base.celery.views import TaskResultViewSet, PeriodicTaskViewSet, PeriodicTaskRunNowView
+
+router = OptionalSlashRouter()
+router.register('task-results', TaskResultViewSet, basename='task-results')
+router.register('periodic-tasks', PeriodicTaskViewSet, basename='periodic-tasks')
+
+urlpatterns = [
+    path('periodic-tasks/<pk>/run-now/', PeriodicTaskRunNowView.as_view(), name='periodic-tasks-run-now'),
+]
+
+urlpatterns += router.urls

utg_base-1.5.1/src/utg_base/celery/views/__init__.py

@@ -0,0 +1,2 @@
+from .periodic_task import PeriodicTaskViewSet, PeriodicTaskRunNowView
+from .task_result import TaskResultViewSet

utg_base-1.5.1/src/utg_base/celery/views/periodic_task.py

@@ -0,0 +1,56 @@
+import json
+
+from celery import current_app
+from django_celery_beat.models import PeriodicTask
+from drf_spectacular.utils import extend_schema
+from rest_framework import viewsets, filters
+from rest_framework.exceptions import NotFound, ValidationError
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from utg_base.api.permissions import IsSuperUser
+from utg_base.celery.serializers import PeriodicTaskSerializer
+from utg_base.utils.translation import translate as _
+
+
+@extend_schema(tags=['admin/periodic-tasks'])
+class PeriodicTaskViewSet(viewsets.ModelViewSet):
+    http_method_names = ['get', 'patch']
+    queryset = PeriodicTask.objects.all()
+    serializer_class = PeriodicTaskSerializer
+    permission_classes = [IsSuperUser]
+    filter_backends = [filters.SearchFilter]
+    search_fields = ['name']
+
+
+@extend_schema(tags=['admin/periodic-tasks'])
+class PeriodicTaskRunNowView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def patch(self, request, pk):
+        try:
+            periodic_task = PeriodicTask.objects.get(pk=pk)
+        except PeriodicTask.DoesNotExist:
+            raise NotFound(detail=_("Periodic task not found"))
+
+        if not periodic_task.enabled:
+            raise ValidationError(detail=_("Task is disabled"))
+
+        args = json.loads(periodic_task.args) if periodic_task.args else []
+        kwargs = json.loads(periodic_task.kwargs) if periodic_task.kwargs else {}
+
+        task = current_app.send_task(
+            periodic_task.task,
+            args=args,
+            kwargs=kwargs,
+            countdown=0,
+            headers = {'periodic_task_name': periodic_task.name}
+        )
+
+        return Response({
+            "detail": _("Task successfully triggered"),
+            "task_id": task.id,
+            "task_name": periodic_task.name,
+            "celery_task": periodic_task.task,
+        })

utg_base-1.5.1/src/utg_base/celery/views/task_result.py

@@ -0,0 +1,18 @@
+import django_filters
+from django_celery_results.models import TaskResult
+from drf_spectacular.utils import extend_schema
+from rest_framework import viewsets, filters
+
+from utg_base.celery.filters import TaskResultFilterSet
+from utg_base.api.permissions import IsSuperUser
+from utg_base.celery.serializers import TaskResultSerializer
+
+
+@extend_schema(tags=['admin/task-results'])
+class TaskResultViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = TaskResult.objects.all()
+    serializer_class = TaskResultSerializer
+    permission_classes = [IsSuperUser]
+    filterset_class = TaskResultFilterSet
+    filter_backends = [filters.SearchFilter, django_filters.rest_framework.DjangoFilterBackend]
+    search_fields = ['name']

utg_base-1.5.1/src/utg_base/constants/__init__.py

@@ -0,0 +1 @@
+from .available_languages import AVAILABLE_LANGUAGES

utg_base-1.5.1/src/utg_base/constants/available_languages.py

@@ -0,0 +1,5 @@
+AVAILABLE_LANGUAGES = [
+    'uz',
+    'ru',
+    'crl'
+]

utg_base-1.5.1/src/utg_base/env.py

@@ -0,0 +1,27 @@
+import os
+
+import dotenv
+import hvac
+from django.conf import settings
+
+dotenv.load_dotenv(settings.BASE_DIR / '.env')
+
+client = hvac.Client(
+    url=os.environ.get("VAULT_URL"),
+    token=os.environ.get("VAULT_TOKEN"),
+    verify=False
+)
+if not client.is_authenticated():
+    raise Exception("Vault authentication failed")
+
+envs = client.secrets.kv.read_secret_version(
+    path=os.environ.get("VAULT_PATH"),
+    mount_point="utg-scada"
+)['data']['data']
+
+
+def env(key, default=None):
+    if key in os.environ:
+        return os.environ.get(key, default)
+    else:
+        return envs.get(key, default)