utg-base 1.0.0__py3-none-any.whl

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/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/authentications/__init__.py

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

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/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/logging.py

@@ -0,0 +1,135 @@
+import logging
+import os
+
+
+class UtgBaseFilter(logging.Filter):
+    BASE_DIR = os.getcwd()
+
+    def filter(self, record):
+        sp = '/site-packages/'
+        path = record.pathname
+
+        if record.pathname.startswith(str(self.BASE_DIR)):
+            path = record.pathname[len(str(self.BASE_DIR)):]
+        elif sp in path:
+            path = path[path.index(sp, 0) + len(sp):]
+
+        path = path.replace('/', '.')
+        path = path.removeprefix('.')
+        record.path = path
+        return record
+
+
+class UtgBaseLogging:
+    enable_file = int(os.environ.get('LOGGING_FILE', False))
+    enable_console_info = int(os.environ.get('LOGGING_CONSOLE_INFO', True))
+    enable_db_debug = int(os.environ.get('LOGGING_DB_DEBUG', False))
+    enable_loki = int(os.environ.get('LOGGING_LOKI', True))
+    enable_loki_debug = int(os.environ.get('LOGGING_LOKI_DEBUG', False))
+
+    logger = logging.getLogger('main')
+
+    format = '[%(asctime)s] %(levelname)s [%(path)s:%(lineno)s] [%(funcName)s] %(message)s'
+
+    __LOGGING = {
+        'version': 1,
+        'disable_existing_loggers': False,
+        'filters': {
+            'trim_path': {
+                '()': 'utg_base.logging.UtgBaseFilter',
+            },
+        },
+        'formatters': {
+            'simple': {
+                'format': format,
+                'datefmt': '%Y-%m-%d %H:%M:%S',
+            },
+            'loki': {
+                'class': 'django_loki.LokiFormatter',  # required
+                'format': format,  # optional, default is logging.BASIC_FORMAT
+                'datefmt': '%Y-%m-%d %H:%M:%S',  # optional, default is '%Y-%m-%d %H:%M:%S'
+            },
+        },
+        'handlers': {
+            'file': {
+                'level': 'ERROR',
+                'class': 'logging.FileHandler',
+                'filename': 'logs/django-error.log',
+                'formatter': 'simple',
+                'filters': ['trim_path'],
+            },
+            'console_info': {
+                'level': 'INFO',
+                'class': 'logging.StreamHandler',
+                'formatter': 'simple',
+                'filters': ['trim_path'],
+            },
+            'console_debug': {
+                'level': 'DEBUG',
+                'class': 'logging.StreamHandler',
+                'formatter': 'simple',
+                'filters': ['trim_path'],
+            },
+            'loki': {
+                'level': os.environ.get('LOKI_LEVEL', 'ERROR'),  # required
+                'class': 'django_loki.LokiHttpHandler',  # required
+                'host': os.environ.get('LOKI_HOST', os.environ.get('DB_HOST')),
+                # required, your grafana/Loki server host, e.g:192.168.25.30
+                'formatter': 'loki',  # required, loki formatter,
+                'port': int(os.environ.get('LOKI_PORT', 3100)),
+                # optional, your grafana/Loki server port, default is 3100
+                'timeout': float(os.environ.get('LOKI_TIMEOUT', 0.5)),
+                # optional, request Loki-server by http or https time out, default is 0.5
+                'protocol': os.environ.get('LOKI_PROTOCOL', 'http'),
+                # optional, Loki-server protocol, default is http
+                'source': os.environ.get('LOKI_SOURCE', 'Loki'),  # optional, label name for Loki, default is Loki
+                'src_host': os.environ.get('LOKI_SRC_HOST', 'localhost'),
+                # optional, label name for Loki, default is localhost
+                'tz': 'Asia/Tashkent',
+                # optional, timezone for formatting timestamp, default is UTC, e.g:Asia/Shanghai
+                'filters': ['trim_path'],
+            },
+        },
+        'loggers': {
+            'django': {
+                'handlers': [],
+                'level': 'DEBUG',
+                'propagate': True,
+            },
+            'django.db.backends': {
+                'handlers': [],
+                'level': 'DEBUG',
+                'propagate': True,
+            },
+            'main': {
+                'handlers': [],
+                'level': 'DEBUG',
+                'propagate': True,
+            }
+        },
+    }
+
+    # noinspection PyUnresolvedReferences
+    @classmethod
+    def logging(cls):
+        _logging = cls.__LOGGING.copy()
+
+        if cls.enable_file:
+            _logging['loggers']['django']['handlers'].append('file')
+        if cls.enable_console_info:
+            _logging['loggers']['django']['handlers'].append('console_info')
+        if cls.enable_db_debug:
+            _logging['loggers']['django.db.backends']['handlers'].append('console_debug')
+        if cls.enable_loki:
+            _logging['loggers']['django']['handlers'].append('loki')
+        if cls.enable_loki_debug:
+            _logging['handlers']['loki_debug'] = _logging['handlers']['loki'].copy()
+            _logging['handlers']['loki_debug']['level'] = 'DEBUG'
+            _logging['loggers']['main']['handlers'].append('loki_debug')
+            _logging['loggers']['main']['handlers'].append('console_debug')
+
+        return _logging
+
+
+LOGGING = UtgBaseLogging.logging()
+logger = UtgBaseLogging.logger

utg_base-1.0.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: utg-base
+Version: 1.0.0
+Summary: UTG Base Package
+Author: Rovshen
+Author-email: rovshenashirov1619@gmail.com
+Requires-Python: >=3.14,<4.0
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: croniter (>=2.0.3,<3.0.0)
+Requires-Dist: django (>=5.2.7,<6.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.3.1,<6.0.0)
+Requires-Dist: drf-spectacular[sidecar] (>=0.27.1,<0.28.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.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+utg_base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utg_base/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utg_base/api/pagination.py,sha256=zzIUwW3iF5G_11gFsno9y1DmgFiULQIWRHUj0LKhYfE,854
+utg_base/api/routers.py,sha256=lU54MVN2BF_q1AWp9EdXkG3m_ivYRtvbNGXFIRKz7u0,177
+utg_base/authentications/__init__.py,sha256=a6twO_bBf8FAHYl7PXawfR2UbBwwdueG1uS_dbq2g_I,109
+utg_base/authentications/microservice_authentication.py,sha256=6aAncxIpA4FcyRegd7QqRYvW5Wn8FxyPU0nQqCVuEs4,976
+utg_base/authentications/models.py,sha256=JQonSdXeSeoF003QlmPvH58nWmVJRKlWWjW_ySqXaYg,2496
+utg_base/logging.py,sha256=MNPUQ9Hdg-0YTFlJBOwhajqKz-8Y5P4POkqRNIU9ga8,5078
+utg_base-1.0.0.dist-info/METADATA,sha256=QXsVK0dVPdjm4Bxm2k5DrdY26eydmrX-gC5LYlu9_qI,660
+utg_base-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+utg_base-1.0.0.dist-info/RECORD,,

utg_base-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any