utg-base 1.10.1__tar.gz → 1.11.1__tar.gz

{utg_base-1.10.1 → utg_base-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utg-base
-Version: 1.10.1
+Version: 1.11.1
 Summary: UTG Base Package
 Author: Olimboy
 Author-email: shavkatov.olimboy@mail.ru

{utg_base-1.10.1 → utg_base-1.11.1}/pyproject.toml

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

utg_base-1.11.1/src/utg_base/permissions/decorators.py

@@ -0,0 +1,25 @@
+from functools import wraps
+from typing import Literal
+
+from rest_framework.exceptions import PermissionDenied
+
+from .utils import has_perms as has_permissions
+
+
+def has_perm(*permission: str, operator: Literal["OR", "AND"] = "OR"):
+    """
+    Usage:
+        has_perm('PERM1')
+        has_perm('PERM1', 'PERM2')
+
+    :param permission: One or many permissions.
+    """
+    def decorator(view_func):
+        view_func._perms = permission
+        @wraps(view_func)
+        def _wrapped_view(self, request, *args, **kwargs):
+            if not has_permissions(user_id=request.user.id, perms=list(permission), operator=operator):
+                raise PermissionDenied
+            return view_func(self, request, *args, **kwargs)
+        return _wrapped_view
+    return decorator

utg_base-1.11.1/src/utg_base/permissions/utils.py

@@ -0,0 +1,76 @@
+from typing import Literal
+
+from django.http import HttpRequest
+from django.urls import URLResolver, URLPattern, get_resolver
+from django_redis import get_redis_connection
+from redis.client import Redis
+from rest_framework.request import Request
+
+from utg_base.env import env
+from utg_base.u_services import u_requests
+from utg_base.u_services.constants import UServices
+from utg_base.utils import to_snake_case
+from utg_base.utils.data import safe_get
+
+
+def generate_perm_cache_key(user_id: str):
+    return f"user:{user_id}:permissions"
+
+
+def has_perm(user_id, perm):
+    redis_conn: Redis = get_redis_connection("shared")
+
+    return bool(redis_conn.sismember(f'user:{user_id}:permissions', perm))
+
+
+def has_perms(user_id: str, perms: list[str], operator: Literal["OR", "AND"] = "OR"):
+    redis_conn: Redis = get_redis_connection("shared")
+
+    result = redis_conn.smismember(f'user:{user_id}:permissions', perms)
+
+    if operator == "OR":
+        return any(result)
+    return all(result)
+
+
+def _get_permissions(url_patterns):
+    permissions = set()
+
+    for item in url_patterns:
+        if isinstance(item, URLPattern):
+            view = item.callback
+
+            view_cls = safe_get(view, 'view_class')
+            # for View
+            if view_cls:
+                for method_name in ["get", "post", "put", "patch", "delete"]:
+                    perms = safe_get(view_cls, f'{method_name}._perms', set())
+                    permissions.update(perms)
+            # for ViewSet
+            else:
+                view_cls = safe_get(view, 'cls')
+                actions: dict = safe_get(view, 'actions', {})
+                for method_name in actions.values():
+                    perms = safe_get(view_cls, f'{method_name}._perms', set())
+                    permissions.update(perms)
+
+        elif isinstance(item, URLResolver):
+            permissions.update(_get_permissions(
+                item.url_patterns
+            ))
+
+    return permissions
+
+
+def sync_permissions():
+    resolver = get_resolver()
+    perm_codes = list(_get_permissions(resolver.url_patterns))
+
+    request = Request(HttpRequest())
+    try:
+        u_requests.post(request, UServices.USER_MANAGEMENT, '/api/permissions/', data={
+            "service": to_snake_case(env('APP_NAME')),
+            "codes": perm_codes
+        })
+    except Exception as e:
+        print(e)

{utg_base-1.10.1 → utg_base-1.11.1}/src/utg_base/utils/__init__.py

@@ -1,2 +1,3 @@
 from .data import deep_map, deep_round, safe_sum, safe_subtract
 from .dict_util import get_by_dotted
+from .string import to_snake_case

{utg_base-1.10.1 → utg_base-1.11.1}/src/utg_base/utils/data.py

@@ -104,3 +104,46 @@ def safe_divide(*args, allow_null=False):
         result /= value
 
     return result
+
+
+def safe_get(obj, dotted_path: str, default=None):
+    """
+    Universal safe getter: supports dicts, objects, lists, and mixes of them.
+
+    Args:
+        obj: Any object, dict, list, etc.
+        dotted_path (str): Path like 'a.b.c' or 'items.0.name'.
+        default: Returned if path does not exist.
+
+    Returns:
+        Any: The resolved value or default.
+    """
+    parts = dotted_path.split('.')
+
+    for part in parts:
+        if obj is None:
+            return default
+
+        # --- Handle LIST index ---
+        if isinstance(obj, (list, tuple)) and part.isdigit():
+            idx = int(part)
+            if 0 <= idx < len(obj):
+                obj = obj[idx]
+            else:
+                return default
+
+        # --- Handle DICT ---
+        elif isinstance(obj, dict):
+            if part in obj:
+                obj = obj.get(part)
+            else:
+                return default
+
+        # --- Handle OBJECT attribute ---
+        else:
+            if hasattr(obj, part):
+                obj = getattr(obj, part)
+            else:
+                return default
+
+    return obj

utg_base-1.11.1/src/utg_base/utils/string.py

@@ -0,0 +1,41 @@
+import re
+
+def to_snake_case(s: str) -> str:
+    """
+    Convert any string into snake_case.
+    Handles:
+      - camelCase / PascalCase
+      - mixed separators (-, space, ., !, etc.)
+      - multiple underscores
+      - trims leading/trailing separators
+    """
+    if not isinstance(s, str):
+        raise TypeError("Input must be a string")
+
+    # Trim spaces
+    s = s.strip()
+    if not s:
+        return ""
+
+    # Insert underscore between lower/number and upper case letters
+    # "helloWorld" -> "hello_World"
+    s = re.sub(r'(?<=[0-9a-z])(?=[A-Z])', '_', s)
+
+    # Insert underscore between acronyms and normal words
+    # "HTTPResponse" -> "HTTP_Response"
+    s = re.sub(r'(?<=[A-Z])(?=[A-Z][a-z])', '_', s)
+
+    # Replace all non-word chars with underscore
+    # \W = anything except letters, digits, underscore
+    s = re.sub(r'\W+', '_', s)
+
+    # Replace spaces if any remain
+    s = s.replace(" ", "_")
+
+    # Collapse multiple underscores
+    s = re.sub(r'_+', '_', s)
+
+    # Remove leading/trailing underscores
+    s = s.strip('_')
+
+    return s.lower()

utg_base-1.10.1/src/utg_base/utils/permission.py

@@ -1,24 +0,0 @@
-from typing import Literal
-
-from django_redis import get_redis_connection
-from redis.client import Redis
-
-
-def generate_perm_cache_key(user_id: str):
-    return f"user:{user_id}:permissions"
-
-
-def has_perm(user_id, perm):
-    redis_conn: Redis = get_redis_connection("shared")
-
-    return bool(redis_conn.sismember(f'user:{user_id}:permissions', perm))
-
-
-def has_perms(user_id: str, perms: list[str], operator: Literal["OR", "AND"] = "OR"):
-    redis_conn: Redis = get_redis_connection("shared")
-
-    result = redis_conn.smismember(f'user:{user_id}:permissions', perms)
-
-    if operator == "OR":
-        return any(result)
-    return all(result)