utg-base 1.0.0__tar.gz

utg_base-1.0.0/PKG-INFO

@@ -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/README.md

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

utg_base-1.0.0/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "utg-base"
+version = "1.0.0"
+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.3.1" }
+django = "^5.2.7"
+django-filter = "^23.5"
+croniter = "^2.0.3"
+drf-spectacular = {extras = ["sidecar"], version = "^0.27.1"}
+openpyxl = "^3.1.2"
+inflect = "^7.2.1"
+
+[[tool.poetry.source]]
+name = "PyPI"
+priority = "primary"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

utg_base-1.0.0/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.0.0/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.0.0/src/utg_base/authentications/__init__.py

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

utg_base-1.0.0/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.0.0/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.0.0/src/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