utg-base 1.5.1__tar.gz → 1.8.1__tar.gz

{utg_base-1.5.1 → utg_base-1.8.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: utg-base
-Version: 1.5.1
+Version: 1.8.1
 Summary: UTG Base Package
-Author: Rovshen
-Author-email: rovshenashirov1619@gmail.com
+Author: Olimboy
+Author-email: shavkatov.olimboy@mail.ru
 Requires-Python: >=3.14,<4.0
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: celery (>=5.5.3,<6.0.0)
@@ -21,4 +21,4 @@ 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

utg_base-1.8.1/README.md

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

{utg_base-1.5.1 → utg_base-1.8.1}/pyproject.toml

@@ -1,8 +1,8 @@
 [tool.poetry]
 name = "utg-base"
-version = "1.5.1"
+version = "1.8.1"
 description = "UTG Base Package"
-authors = ["Rovshen <rovshenashirov1619@gmail.com>"]
+authors = ["Olimboy <shavkatov.olimboy@mail.ru>", "Rovshen <rovshenashirov1619@gmail.com>"]
 readme = "README.md"
 
 [tool.poetry.dependencies]

utg_base-1.8.1/src/utg_base/api/spectacular.py

@@ -0,0 +1,33 @@
+from django.conf import settings
+from django.http import HttpResponseForbidden
+from django.urls import path
+from drf_spectacular.views import SpectacularAPIView, SpectacularSwaggerView
+from rest_framework.views import APIView
+
+from utg_base.env import env
+
+
+class DebugTokenRequiredMixin(APIView):
+    """
+    If Request header X-Debug-Token not found then 403
+    """
+
+    def dispatch(self, request, *args, **kwargs):
+        token = request.headers.get("X-Debug-Token")
+        if not settings.DEBUG and token != env("DJANGO_SECRET_KEY"):
+            return HttpResponseForbidden("Forbidden")
+        return super().dispatch(request, *args, **kwargs)
+
+
+class ProtectedSpectacularAPIView(DebugTokenRequiredMixin, SpectacularAPIView):
+    pass
+
+
+class ProtectedSpectacularSwaggerView(DebugTokenRequiredMixin, SpectacularSwaggerView):
+    pass
+
+
+urlpatterns = [
+    path('api/swagger/schema/', ProtectedSpectacularAPIView.as_view(), name='schema'),
+    path('api/docs/', ProtectedSpectacularSwaggerView.as_view(url_name='schema'), name='docs'),
+]

{utg_base-1.5.1 → utg_base-1.8.1}/src/utg_base/celery/apps.py

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

{utg_base-1.5.1 → utg_base-1.8.1}/src/utg_base/env.py

@@ -6,6 +6,10 @@ from django.conf import settings
 
 dotenv.load_dotenv(settings.BASE_DIR / '.env')
 
+assert os.environ.get('VAULT_URL') is not None, ("VAULT_URL not defined, please set VAULT_URL on .env file")
+assert os.environ.get('VAULT_TOKEN') is not None, ("VAULT_TOKEN not defined, please set VAULT_TOKEN on .env file")
+assert os.environ.get('VAULT_PATH') is not None, ("VAULT_PATH not defined, please set VAULT_PATH on .env file")
+
 client = hvac.Client(
     url=os.environ.get("VAULT_URL"),
     token=os.environ.get("VAULT_TOKEN"),

{utg_base-1.5.1 → utg_base-1.8.1}/src/utg_base/logging.py

@@ -1,6 +1,8 @@
 import logging
 import os
 
+from utg_base.env import env
+
 
 class UtgBaseFilter(logging.Filter):
     BASE_DIR = os.getcwd()
@@ -21,10 +23,10 @@ class UtgBaseFilter(logging.Filter):
 
 
 class UtgBaseLogging:
-    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))
+    enable_console_info = int(env('LOGGING_CONSOLE_INFO', True))
+    enable_db_debug = int(env('LOGGING_DB_DEBUG', False))
+    enable_loki = int(env('LOGGING_LOKI', True))
+    enable_loki_debug = int(env('LOGGING_LOKI_DEBUG', False))
 
     logger = logging.getLogger('main')
 
@@ -63,19 +65,19 @@ class UtgBaseLogging:
                 'filters': ['trim_path'],
             },
             'loki': {
-                'level': os.environ.get('LOKI_LEVEL', 'ERROR'),  # required
+                'level': env('LOKI_LEVEL', 'ERROR'),  # required
                 'class': 'django_loki.LokiHttpHandler',  # required
-                'host': os.environ.get('LOKI_HOST', os.environ.get('DB_HOST')),
+                'host': env('LOKI_HOST', env('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)),
+                'port': int(env('LOKI_PORT', 3100)),
                 # optional, your grafana/Loki server port, default is 3100
-                'timeout': float(os.environ.get('LOKI_TIMEOUT', 0.5)),
+                'timeout': float(env('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'),
+                'protocol': env('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'),
+                'source': env('LOKI_SOURCE', 'Loki'),  # optional, label name for Loki, default is Loki
+                'src_host': env('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

utg_base-1.8.1/src/utg_base/middleware/debug.py

@@ -0,0 +1,10 @@
+from django.utils.deprecation import MiddlewareMixin
+
+from utg_base.env import env
+
+
+class DebugOverrideMiddleware(MiddlewareMixin):
+    def process_exception(self, request, exception):
+        if request.headers.get("X-Debug-Token") == env("DJANGO_SECRET_KEY"):
+            from django.views import debug
+            return debug.technical_500_response(request, type(exception), exception, exception.__traceback__)

utg_base-1.8.1/src/utg_base/migration/apps.py

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

utg_base-1.8.1/src/utg_base/migration/management/commands/makemigrations.py

@@ -0,0 +1,94 @@
+import os
+
+from django.core.management.commands.makemigrations import Command as BaseMakeMigrations
+from django.core.management.utils import run_formatters
+from django.db.migrations.writer import MigrationWriter
+from django.db.migrations.operations import CreateModel
+
+
+class Command(BaseMakeMigrations):
+
+    def write_migration_files(self, changes, update_previous_migration_paths=None):
+        """
+        Take a changes dict and write them out as migration files.
+        """
+        directory_created = {}
+        for app_label, app_migrations in changes.items():
+            if self.verbosity >= 1:
+                self.log(self.style.MIGRATE_HEADING("Migrations for '%s':" % app_label))
+            for migration in app_migrations:
+                # Describe the migration
+                writer = MigrationWriter(migration, self.include_header)
+
+                # BEGIN Customizing
+                # fix 'created_at', 'updated_at' fields order
+                for operation in migration.operations:
+                    if not isinstance(operation, CreateModel):
+                        continue
+                    _fields = []
+                    _end_fields = []
+                    for field_name, field in operation.fields:
+                        if field_name in ['created_at', 'updated_at']:
+                            _end_fields.append((field_name, field))
+                        else:
+                            _fields.append((field_name, field))
+
+                    operation.fields = _fields + _end_fields
+
+                # END Customizing
+
+                if self.verbosity >= 1:
+                    # Display a relative path if it's below the current working
+                    # directory, or an absolute path otherwise.
+                    migration_string = self.get_relative_path(writer.path)
+                    self.log("  %s\n" % self.style.MIGRATE_LABEL(migration_string))
+                    for operation in migration.operations:
+                        self.log("    %s" % operation.formatted_description())
+                    if self.scriptable:
+                        self.stdout.write(migration_string)
+                if not self.dry_run:
+                    # Write the migrations file to the disk.
+                    migrations_directory = os.path.dirname(writer.path)
+                    if not directory_created.get(app_label):
+                        os.makedirs(migrations_directory, exist_ok=True)
+                        init_path = os.path.join(migrations_directory, "__init__.py")
+                        if not os.path.isfile(init_path):
+                            open(init_path, "w").close()
+                        # We just do this once per app
+                        directory_created[app_label] = True
+                    migration_string = writer.as_string()
+                    with open(writer.path, "w", encoding="utf-8") as fh:
+                        fh.write(migration_string)
+                        self.written_files.append(writer.path)
+                    if update_previous_migration_paths:
+                        prev_path = update_previous_migration_paths[app_label]
+                        rel_prev_path = self.get_relative_path(prev_path)
+                        if writer.needs_manual_porting:
+                            migration_path = self.get_relative_path(writer.path)
+                            self.log(
+                                self.style.WARNING(
+                                    f"Updated migration {migration_path} requires "
+                                    f"manual porting.\n"
+                                    f"Previous migration {rel_prev_path} was kept and "
+                                    f"must be deleted after porting functions manually."
+                                )
+                            )
+                        else:
+                            os.remove(prev_path)
+                            self.log(f"Deleted {rel_prev_path}")
+                elif self.verbosity == 3:
+                    # Alternatively, makemigrations --dry-run --verbosity 3
+                    # will log the migrations rather than saving the file to
+                    # the disk.
+                    self.log(
+                        self.style.MIGRATE_HEADING(
+                            "Full migrations file '%s':" % writer.filename
+                        )
+                    )
+                    self.log(writer.as_string())
+        run_formatters(self.written_files, stderr=self.stderr)
+
+    def handle(self, *args, **options):
+        self.written_files = []
+        result = super().handle(*args, **options)
+        return result

{utg_base-1.5.1 → utg_base-1.8.1}/src/utg_base/references_api/utils.py

@@ -102,7 +102,7 @@ def create_view_set(model: Model):
 
 
 def create_serializer_for_create(model: Model):
-    @extend_schema_serializer(component_name='Admin' + get_serializer_name(model))
+    @extend_schema_serializer(component_name='Admin1' + get_serializer_name(model))
     class Serializer(serializers.ModelSerializer):
         class Meta:
             fields = '__all__'
@@ -114,7 +114,7 @@ def create_serializer_for_create(model: Model):
 def create_serializer_for_partial_update(model: Model):
     fields_list = get_model_fields_list(model)
 
-    @extend_schema_serializer(component_name='Admin' + get_serializer_name(model))
+    @extend_schema_serializer(component_name='Admin2' + get_serializer_name(model))
     class Serializer(serializers.ModelSerializer):
         class Meta:
             fields = '__all__'
@@ -147,7 +147,7 @@ def create_serializer(model: Model, depth=0):
             parsed_url = urlparse(value.url)
             return f'{parsed_url.path}?{parsed_url.query}'
 
-    @extend_schema_serializer(component_name='Admin' + get_serializer_name(model))
+    @extend_schema_serializer(component_name='Admin3' + get_serializer_name(model))
     class Serializer(serializers.ModelSerializer):
         def __init__(self, *args, **kwargs):
             super().__init__(*args, **kwargs)

{utg_base-1.5.1 → utg_base-1.8.1}/src/utg_base/services/base_api.py

@@ -14,10 +14,19 @@ class BaseServiceAPI:
     base_url: str = None
     default_response_processor: Callable[[Response], Any] = None
 
-    def request(self, method, path, data=None, json=None, params=None, headers=None,
-                authenticator: Callable[[dict], dict] | None = 'default',
-                response_processor: Callable[[Response], Any] | None = 'default',
-                **kwargs):
+    @classmethod
+    def request(
+            cls,
+            method,
+            path,
+            data=None,
+            json=None,
+            params=None,
+            headers=None,
+            authenticator: Callable[[dict], dict] | None = 'default',
+            response_processor: Callable[[Response], Any] | None = 'default',
+            **kwargs
+    ):
         """
         Make an HTTP request using the requests' library.
 
@@ -53,12 +62,12 @@ class BaseServiceAPI:
         if callable(authenticator):
             headers = authenticator(headers)
 
-        if authenticator == 'default' and hasattr(self, 'authenticate') and callable(self.authenticate):
-            headers = self.authenticate(headers)
+        if authenticator == 'default' and hasattr(cls, 'authenticate') and callable(cls.authenticate):
+            headers = cls.authenticate(headers)
 
         response = requests.request(
             method=method,
-            url=self.base_url + path,
+            url=cls.base_url + path,
             data=data,
             json=json,
             params=params,
@@ -68,8 +77,8 @@ class BaseServiceAPI:
         )
 
         if response_processor == 'default':
-            if hasattr(self, 'default_response_processor') and callable(self.default_response_processor):
-                return self.default_response_processor(response)
+            if hasattr(cls, 'default_response_processor') and callable(cls.default_response_processor):
+                return cls.default_response_processor(response)
             return response
 
         if response_processor is not None:
@@ -77,8 +86,9 @@ class BaseServiceAPI:
 
         return response
 
-    def call(self, method, path, data=None, json=None, params=None, headers=None):
-        data = self.request(
+    @classmethod
+    def call(cls, method, path, data=None, json=None, params=None, headers=None):
+        data = cls.request(
             method=method,
             path=path,
             data=data,
@@ -88,7 +98,7 @@ class BaseServiceAPI:
             response_processor=call_processor
         )
         return {
-            'path': self.base_url + path,
+            'path': cls.base_url + path,
             'method': method,
             'status': data['status'],
             'reason': data['reason'],
@@ -96,10 +106,11 @@ class BaseServiceAPI:
             'response': data['response'],
         }
 
-    def authenticate(self, headers: dict) -> dict:
+    @classmethod
+    def authenticate(cls, headers: dict) -> dict:
         """
         Example authenticate method:
-            authenticate(self, headers):
+            authenticate(cls, headers):
                 headers['Authorization'] = 'Bearer YOUR_ACCESS_TOKEN'
                 return headers
         :param headers:
@@ -107,22 +118,53 @@ class BaseServiceAPI:
         """
         return headers
 
-    def get(self, path, data=None, json=None, params=None, headers=None,
+    @classmethod
+    def get(
+            cls,
+            path,
+            data=None,
+            json=None,
+            params=None,
+            headers=None,
             authenticator: Callable[[dict], dict] | None = 'default',
-            response_processor: Callable[[Response], Any] | None = 'default'):
-        return self.request('get', path, data, json, params, headers, authenticator, response_processor)
-
-    def post(self, path, data=None, json=None, params=None, headers=None,
-             authenticator: Callable[[dict], dict] | None = 'default',
-             response_processor: Callable[[Response], Any] | None = 'default'):
-        return self.request('post', path, data, json, params, headers, authenticator, response_processor)
-
-    def put(self, path, data=None, json=None, params=None, headers=None,
+            response_processor: Callable[[Response], Any] | None = 'default'
+    ):
+        return cls.request('get', path, data, json, params, headers, authenticator, response_processor)
+
+    @classmethod
+    def post(
+            cls,
+            path,
+            data=None,
+            json=None,
+            params=None,
+            headers=None,
             authenticator: Callable[[dict], dict] | None = 'default',
-            response_processor: Callable[[Response], Any] | None = 'default'):
-        return self.request('put', path, data, json, params, headers, authenticator, response_processor)
-
-    def patch(self, path, data=None, json=None, params=None, headers=None,
-              authenticator: Callable[[dict], dict] | None = 'default',
-              response_processor: Callable[[Response], Any] | None = 'default'):
-        return self.request('patch', path, data, json, params, headers, authenticator, response_processor)
+            response_processor: Callable[[Response], Any] | None = 'default'
+    ):
+        return cls.request('post', path, data, json, params, headers, authenticator, response_processor)
+
+    @classmethod
+    def put(
+            cls,
+            path,
+            data=None,
+            json=None,
+            params=None,
+            headers=None,
+            authenticator: Callable[[dict], dict] | None = 'default',
+            response_processor: Callable[[Response], Any] | None = 'default'
+    ):
+        return cls.request('put', path, data, json, params, headers, authenticator, response_processor)
+
+    @classmethod
+    def patch(
+            cls,
+            path,
+            data=None,
+            json=None,
+            params=None, headers=None,
+            authenticator: Callable[[dict], dict] | None = 'default',
+            response_processor: Callable[[Response], Any] | None = 'default'
+    ):
+        return cls.request('patch', path, data, json, params, headers, authenticator, response_processor)

utg_base-1.8.1/src/utg_base/utils/thread.py

@@ -0,0 +1,67 @@
+import multiprocessing
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Callable, Any, Iterable, Tuple, Dict, Union
+
+
+class ThreadPoolException(Exception):
+    """Exception to wrap the error in each task."""
+
+    def __init__(self, func: str, exception: Exception):
+        self.func = func
+        self.exception = exception
+        super().__init__(f"Exception in {func}: {exception}")
+
+
+def parallel_execute(
+        *tasks: Union[
+            Callable,  # func
+            Tuple[Callable, Iterable],  # (func, args)
+            Tuple[Callable, Iterable, Dict[str, Any]]  # (func, args, kwargs)
+        ],
+        max_workers: int = None
+) -> list[Any]:
+    """
+    Executes multiple functions in parallel.
+    Each can be without arguments or with args/kwargs.
+
+    Example:
+        parallel_execute(func1, func2)
+        parallel_execute((func1, (1, 2)), (func2, (), {"x": 5}))
+
+    The sequence is preserved.
+
+    :return: Result list or ThreadPoolException objects
+    """
+    if not tasks:
+        return []
+
+    cpu_count = multiprocessing.cpu_count()
+    max_workers = max_workers or min(cpu_count * 10, len(tasks))
+    results = [None] * len(tasks)
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {}
+
+        for i, task in enumerate(tasks):
+            # Task unpacking
+            if callable(task):
+                func, args, kwargs = task, (), {}
+            elif isinstance(task, tuple):
+                func = task[0]
+                args = task[1] if len(task) > 1 else ()
+                kwargs = task[2] if len(task) > 2 else {}
+            else:
+                raise ValueError(f"Invalid task format: {task}")
+
+            futures[executor.submit(func, *args, **kwargs)] = i
+
+        for future in as_completed(futures):
+            idx = futures[future]
+            func = tasks[idx][0] if isinstance(tasks[idx], tuple) else tasks[idx]
+            func_name = getattr(func, "__name__", str(func))
+            try:
+                results[idx] = future.result()
+            except Exception as e:
+                results[idx] = ThreadPoolException(func=func_name, exception=e)
+
+    return results

{utg_base-1.5.1 → utg_base-1.8.1}/src/utg_base/utils/translation.py

@@ -1,13 +1,12 @@
-import os
-
 import requests
 from django.utils.translation import get_language
 
 from utg_base.constants import AVAILABLE_LANGUAGES
+from utg_base.env import env
 
 
 def translate(key: str) -> str:
-    base_url = os.environ.get('TRANSLATION_SERVICE_URL')
+    base_url = env('TRANSLATION_SERVICE_URL')
     lang = get_language()
     if lang == 'uz-cyr':
         lang = 'crl'

utg_base-1.5.1/README.md

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