sso-nebus 0.1.4__tar.gz → 0.1.6__tar.gz

{sso_nebus-0.1.4 → sso_nebus-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sso-nebus
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python клиент для взаимодействия с MS Auth Service API
 License: LICENSE
 License-File: LICENSE
@@ -12,8 +12,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: dev
 Requires-Dist: aiohttp (>=3.13.2,<4.0.0)
 Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Requires-Dist: pytest (>=8.0.0) ; extra == "dev"
+Requires-Dist: pytest-asyncio (>=0.24.0) ; extra == "dev"
+Requires-Dist: python-dotenv (>=1.0.0) ; extra == "dev"
 Description-Content-Type: text/markdown
 
 # SSO Nebus Client

{sso_nebus-0.1.4 → sso_nebus-0.1.6}/pyproject.toml

@@ -1,19 +1,35 @@
-[project]
-name = "sso-nebus"
-version = "0.1.4"
-description = "Python клиент для взаимодействия с MS Auth Service API"
-authors = [
-    {name = "Артем Костюченко",email = "kostyuchenko.work@gmail.com"}
-]
-license = "LICENSE"
-readme = "README.md"
-requires-python = ">=3.12"
-dependencies = [
-    "aiohttp (>=3.13.2,<4.0.0)",
-    "pydantic (>=2.12.5,<3.0.0)"
-]
-
-
-[build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"
+[project]
+name = "sso-nebus"
+version = "0.1.6"
+description = "Python клиент для взаимодействия с MS Auth Service API"
+authors = [
+    {name = "Артем Костюченко",email = "kostyuchenko.work@gmail.com"}
+]
+license = "LICENSE"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "aiohttp (>=3.13.2,<4.0.0)",
+    "pydantic (>=2.12.5,<3.0.0)"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest (>=8.0.0)",
+    "pytest-asyncio (>=0.24.0)",
+    "python-dotenv (>=1.0.0)",
+]
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=8.0.0"
+pytest-asyncio = ">=0.24.0"
+python-dotenv = ">=1.0.0"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

{sso_nebus-0.1.4 → sso_nebus-0.1.6}/sso_nebus/base.py

@@ -1,6 +1,6 @@
 """Базовый класс для SSO клиентов"""
 
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 from urllib.parse import urljoin
 from abc import ABC, abstractmethod
 
@@ -174,49 +174,54 @@ class BaseClient(ABC):
         if form_data:
             headers.pop("Content-Type", None)
 
-        async with self.session.request(
-            method=method,
-            url=url,
-            headers=headers,
-            json=json_data,
-            data=form_data,
-            params=params,
-        ) as response:
-            # Если получили 401 и включен авто-рефреш, пытаемся обновить токен
-            if (
-                response.status == 401
-                and self.auto_refresh_token
-                and retry_on_401
-                and not self._refreshing
-                and access_token
-            ):
-                try:
-                    # Пытаемся обновить токен
-                    self._refreshing = True
-                    await self._refresh_token()
-                    # Получаем новый токен
-                    new_token = self._get_access_token()
-                    if new_token and new_token != access_token:
-                        # Повторяем запрос с новым токеном
-                        headers = self._get_headers(new_token)
-                        if form_data:
-                            headers.pop("Content-Type", None)
-                        async with self.session.request(
-                            method=method,
-                            url=url,
-                            headers=headers,
-                            json=json_data,
-                            data=form_data,
-                            params=params,
-                        ) as retry_response:
-                            return await self._handle_response(retry_response)
-                except Exception:
-                    # Если обновление не удалось, пробрасываем оригинальную ошибку
-                    pass
-                finally:
-                    self._refreshing = False
-
-            return await self._handle_response(response)
+        try:
+            async with self.session.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=json_data,
+                data=form_data,
+                params=params,
+            ) as response:
+                # Если получили 401 и включен авто-рефреш, пытаемся обновить токен
+                if (
+                    response.status == 401
+                    and self.auto_refresh_token
+                    and retry_on_401
+                    and not self._refreshing
+                    and access_token
+                ):
+                    try:
+                        # Пытаемся обновить токен
+                        self._refreshing = True
+                        await self._refresh_token()
+                        # Получаем новый токен
+                        new_token = self._get_access_token()
+                        if new_token and new_token != access_token:
+                            # Повторяем запрос с новым токеном
+                            headers = self._get_headers(new_token)
+                            if form_data:
+                                headers.pop("Content-Type", None)
+                            async with self.session.request(
+                                method=method,
+                                url=url,
+                                headers=headers,
+                                json=json_data,
+                                data=form_data,
+                                params=params,
+                            ) as retry_response:
+                                return await self._handle_response(retry_response)
+                    except Exception:
+                        # Если обновление не удалось, пробрасываем оригинальную ошибку
+                        pass
+                    finally:
+                        self._refreshing = False
+
+                return await self._handle_response(response)
+        finally:
+            # Закрываем сессию после взаимодействия (если она наша), чтобы избежать "Unclosed client session"
+            if self._own_session and self._session and not self._session.closed:
+                await self._session.close()
 
     async def get(
         self,
@@ -394,18 +399,17 @@ class BaseClient(ABC):
     async def create_scope(
         self,
         name: str,
-        service_name: str,
-        resource: str,
+        client: str,
+        role: str,
         action: str,
         description: Optional[str] = None,
         access_token: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Создать новое разрешение (требует sso.admin.create)"""
         json_data = {
-            "name": name,
-            "service_name": service_name,
-            "resource": resource,
-            "action": action,
+            "client": client,
+            "role": role,
+            "action": action
         }
         if description:
             json_data["description"] = description
@@ -479,16 +483,29 @@ class BaseClient(ABC):
     async def assign_scopes_to_client(
         self,
         client_id: str,
-        scope_ids: list[int],
+        scope_ids: List[int],
         access_token: Optional[str] = None,
     ) -> Dict[str, Any]:
-        """Назначить разрешения клиенту (требует sso.admin.edit)"""
+        """Назначить разрешения (scopes) клиенту (требует sso.admin.edit)"""
         return await self.post(
             f"admin/clients/{client_id}/scopes",
             access_token=access_token,
             json_data={"scope_ids": scope_ids},
         )
 
+    async def assign_roles_to_client(
+        self,
+        client_id: str,
+        role_ids: List[int],
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Привязать роли к микросервису (клиенту). POST admin/clients/{client_id}/roles, body: role_ids (требует sso.admin.edit)"""
+        return await self.post(
+            f"admin/clients/{client_id}/roles",
+            access_token=access_token,
+            json_data={"role_ids": role_ids},
+        )
+
     async def rotate_client_secret(
         self,
         client_id: str,

{sso_nebus-0.1.4 → sso_nebus-0.1.6}/sso_nebus/service_client.py

@@ -1,197 +1,197 @@
-"""Клиент для микросервисного взаимодействия (Client Credentials)"""
-
-import base64
-import json
-from typing import Any, Dict, Optional
-
-from .base import BaseClient
-from .models import TokenResponse, UserInfo
-from .exceptions import TokenError
-
-
-def _decode_jwt_payload(token: str) -> Dict[str, Any]:
-    """
-    Декодирует payload JWT без проверки подписи (только чтение полей).
-    Токен получен от SSO, используется для извлечения claim service_name.
-    """
-    try:
-        parts = token.split(".")
-        if len(parts) != 3:
-            return {}
-        payload_b64 = parts[1]
-        padding = 4 - len(payload_b64) % 4
-        if padding != 4:
-            payload_b64 += "=" * padding
-        payload_bytes = base64.urlsafe_b64decode(payload_b64)
-        return json.loads(payload_bytes.decode("utf-8"))
-    except Exception:
-        return {}
-
-
-class ServiceClient(BaseClient):
-    """Клиент для микросервисного взаимодействия с Client Credentials Grant"""
-
-    def __init__(
-        self,
-        base_url: str,
-        client_id: str,
-        client_secret: str,
-        api_version: str = "v1",
-        timeout: int = 30,
-        session=None,
-        auto_refresh_token: bool = True,
-        default_scope: Optional[str] = None,
-    ):
-        """
-        Инициализация клиента для микросервисов
-
-        Args:
-            base_url: Базовый URL API
-            client_id: ID микросервиса
-            client_secret: Секрет микросервиса
-            api_version: Версия API
-            timeout: Таймаут запросов
-            session: Опциональная aiohttp сессия
-            auto_refresh_token: Автоматически обновлять токен при получении 401 ошибки
-            default_scope: Scope по умолчанию для автоматического получения токена
-        """
-        super().__init__(base_url, api_version, timeout, session, auto_refresh_token)
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self._access_token: Optional[str] = None
-        self.default_scope = default_scope
-
-    async def get_access_token(self, scope: Optional[str] = None) -> TokenResponse:
-        """
-        Получить access token используя Client Credentials Grant
-
-        Args:
-            scope: Запрашиваемые разрешения (разделенные пробелом)
-
-        Returns:
-            TokenResponse с access_token
-        """
-        form_data = {
-            "grant_type": "client_credentials",
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-        }
-
-        if scope:
-            form_data["scope"] = scope
-
-        data = await self.post("token", form_data=form_data)
-        token_response = TokenResponse(**data)
-
-        # Сохраняем токен
-        self._access_token = token_response.access_token
-
-        return token_response
-
-    async def get_current_user(self, access_token: Optional[str] = None) -> UserInfo:
-        """
-        Получить информацию о текущем пользователе/сервисе
-
-        Args:
-            access_token: Access token (если не указан, используется сохраненный)
-
-        Returns:
-            UserInfo с информацией (для микросервисов может быть ограниченная информация)
-        """
-        access_token = access_token or self._access_token
-
-        if not access_token:
-            raise TokenError(
-                "Access token не найден. Вызовите get_access_token() сначала.")
-
-        data = await self.get("me", access_token=access_token)
-        return UserInfo(**data)
-
-    def set_access_token(self, access_token: str):
-        """
-        Установить access token вручную
-
-        Args:
-            access_token: Access token
-        """
-        self._access_token = access_token
-
-    def _get_access_token(self) -> Optional[str]:
-        """Получить текущий access token (для BaseClient)"""
-        return self._access_token
-
-    async def _refresh_token(self) -> None:
-        """Обновить access token (для авто-рефреша)"""
-        await self.get_access_token(self.default_scope)
-
-    def get_token(self) -> Optional[str]:
-        """Получить текущий access token"""
-        return self._access_token
-
-    def get_token_payload(self, access_token: Optional[str] = None) -> Dict[str, Any]:
-        """
-        Получить payload текущего JWT токена (без проверки подписи).
-        Удобно для чтения полей, вшитых SSO (например service_name).
-
-        Args:
-            access_token: Токен (если не указан, используется сохранённый)
-
-        Returns:
-            Словарь с полями payload или пустой словарь при ошибке
-        """
-        token = access_token or self._access_token
-        if not token:
-            return {}
-        return _decode_jwt_payload(token)
-
-    def get_service_name(self, access_token: Optional[str] = None) -> Optional[str]:
-        """
-        Получить название сервиса из JWT токена (поле service_name, вшитое SSO).
-
-        Args:
-            access_token: Токен (если не указан, используется сохранённый)
-
-        Returns:
-            Название сервиса или None, если токена нет или поле отсутствует
-        """
-        payload = self.get_token_payload(access_token)
-        return payload.get("service_name")
-
-    async def request_with_auth(
-        self,
-        method: str,
-        endpoint: str,
-        json_data: Optional[dict] = None,
-        params: Optional[dict] = None,
-        auto_refresh: bool = True,
-    ) -> dict:
-        """
-        Выполнить запрос с автоматической авторизацией
-
-        Args:
-            method: HTTP метод (GET, POST, PUT, DELETE)
-            endpoint: API endpoint
-            json_data: JSON данные для тела запроса
-            params: Query параметры
-            auto_refresh: Автоматически получать токен, если его нет
-
-        Returns:
-            Распарсенный JSON ответ
-        """
-        access_token = self._access_token
-
-        if not access_token and auto_refresh:
-            await self.get_access_token()
-            access_token = self._access_token
-
-        if not access_token:
-            raise TokenError(
-                "Access token не найден. Вызовите get_access_token() сначала.")
-
-        return await self._request(
-            method=method,
-            endpoint=endpoint,
-            access_token=access_token,
-            json_data=json_data,
-            params=params,
-        )
+"""Клиент для микросервисного взаимодействия (Client Credentials)"""
+
+import base64
+import json
+from typing import Any, Dict, Optional
+
+from .base import BaseClient
+from .models import TokenResponse, UserInfo
+from .exceptions import TokenError
+
+
+def _decode_jwt_payload(token: str) -> Dict[str, Any]:
+    """
+    Декодирует payload JWT без проверки подписи (только чтение полей).
+    Токен получен от SSO, используется для извлечения claim service_name.
+    """
+    try:
+        parts = token.split(".")
+        if len(parts) != 3:
+            return {}
+        payload_b64 = parts[1]
+        padding = 4 - len(payload_b64) % 4
+        if padding != 4:
+            payload_b64 += "=" * padding
+        payload_bytes = base64.urlsafe_b64decode(payload_b64)
+        return json.loads(payload_bytes.decode("utf-8"))
+    except Exception:
+        return {}
+
+
+class ServiceClient(BaseClient):
+    """Клиент для микросервисного взаимодействия с Client Credentials Grant"""
+
+    def __init__(
+        self,
+        base_url: str,
+        client_id: str,
+        client_secret: str,
+        api_version: str = "v1",
+        timeout: int = 30,
+        session=None,
+        auto_refresh_token: bool = True,
+        default_scope: Optional[str] = None,
+    ):
+        """
+        Инициализация клиента для микросервисов
+
+        Args:
+            base_url: Базовый URL API
+            client_id: ID микросервиса
+            client_secret: Секрет микросервиса
+            api_version: Версия API
+            timeout: Таймаут запросов
+            session: Опциональная aiohttp сессия
+            auto_refresh_token: Автоматически обновлять токен при получении 401 ошибки
+            default_scope: Scope по умолчанию для автоматического получения токена
+        """
+        super().__init__(base_url, api_version, timeout, session, auto_refresh_token)
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self._access_token: Optional[str] = None
+        self.default_scope = default_scope
+
+    async def get_access_token(self, scope: Optional[str] = None) -> TokenResponse:
+        """
+        Получить access token используя Client Credentials Grant
+
+        Args:
+            scope: Запрашиваемые разрешения (разделенные пробелом)
+
+        Returns:
+            TokenResponse с access_token
+        """
+        form_data = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+        }
+
+        if scope:
+            form_data["scope"] = scope
+
+        data = await self.post("token", form_data=form_data)
+        token_response = TokenResponse(**data)
+
+        # Сохраняем токен
+        self._access_token = token_response.access_token
+
+        return token_response
+
+    async def get_current_user(self, access_token: Optional[str] = None) -> UserInfo:
+        """
+        Получить информацию о текущем пользователе/сервисе
+
+        Args:
+            access_token: Access token (если не указан, используется сохраненный)
+
+        Returns:
+            UserInfo с информацией (для микросервисов может быть ограниченная информация)
+        """
+        access_token = access_token or self._access_token
+
+        if not access_token:
+            raise TokenError(
+                "Access token не найден. Вызовите get_access_token() сначала.")
+
+        data = await self.get("me", access_token=access_token)
+        return UserInfo(**data)
+
+    def set_access_token(self, access_token: str):
+        """
+        Установить access token вручную
+
+        Args:
+            access_token: Access token
+        """
+        self._access_token = access_token
+
+    def _get_access_token(self) -> Optional[str]:
+        """Получить текущий access token (для BaseClient)"""
+        return self._access_token
+
+    async def _refresh_token(self) -> None:
+        """Обновить access token (для авто-рефреша)"""
+        await self.get_access_token(self.default_scope)
+
+    def get_token(self) -> Optional[str]:
+        """Получить текущий access token"""
+        return self._access_token
+
+    def get_token_payload(self, access_token: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Получить payload текущего JWT токена (без проверки подписи).
+        Удобно для чтения полей, вшитых SSO (например service_name).
+
+        Args:
+            access_token: Токен (если не указан, используется сохранённый)
+
+        Returns:
+            Словарь с полями payload или пустой словарь при ошибке
+        """
+        token = access_token or self._access_token
+        if not token:
+            return {}
+        return _decode_jwt_payload(token)
+
+    def get_service_name(self, access_token: Optional[str] = None) -> Optional[str]:
+        """
+        Получить название сервиса из JWT токена (поле service_name, вшитое SSO).
+
+        Args:
+            access_token: Токен (если не указан, используется сохранённый)
+
+        Returns:
+            Название сервиса или None, если токена нет или поле отсутствует
+        """
+        payload = self.get_token_payload(access_token)
+        return payload.get("service_name")
+
+    async def request_with_auth(
+        self,
+        method: str,
+        endpoint: str,
+        json_data: Optional[dict] = None,
+        params: Optional[dict] = None,
+        auto_refresh: bool = True,
+    ) -> dict:
+        """
+        Выполнить запрос с автоматической авторизацией
+
+        Args:
+            method: HTTP метод (GET, POST, PUT, DELETE)
+            endpoint: API endpoint
+            json_data: JSON данные для тела запроса
+            params: Query параметры
+            auto_refresh: Автоматически получать токен, если его нет
+
+        Returns:
+            Распарсенный JSON ответ
+        """
+        access_token = self._access_token
+
+        if not access_token and auto_refresh:
+            await self.get_access_token()
+            access_token = self._access_token
+
+        if not access_token:
+            raise TokenError(
+                "Access token не найден. Вызовите get_access_token() сначала.")
+
+        return await self._request(
+            method=method,
+            endpoint=endpoint,
+            access_token=access_token,
+            json_data=json_data,
+            params=params,
+        )