sso-nebus 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

sso_nebus/__init__.py

@@ -6,9 +6,9 @@ SSO Nebus Client - Python клиент для взаимодействия с MS
 - ServiceClient: для микросервисного взаимодействия (Client Credentials)
 """
 
-from user_client import UserClient
-from service_client import ServiceClient
-from exceptions import (
+from .user_client import UserClient
+from .service_client import ServiceClient
+from .exceptions import (
     SSOClientError,
     AuthenticationError,
     AuthorizationError,

sso_nebus/base.py

@@ -2,18 +2,20 @@
 
 from typing import Optional, Dict, Any
 from urllib.parse import urljoin
+from abc import ABC, abstractmethod
 
 import aiohttp
 from aiohttp import ClientSession, ClientResponse
 
-from exceptions import (
+from .exceptions import (
     APIError,
     AuthenticationError,
     AuthorizationError,
+    TokenError,
 )
 
 
-class BaseClient:
+class BaseClient(ABC):
     """Базовый класс для всех SSO клиентов"""
 
     def __init__(
@@ -22,6 +24,7 @@ class BaseClient:
         api_version: str = "v1",
         timeout: int = 30,
         session: Optional[ClientSession] = None,
+        auto_refresh_token: bool = True,
     ):
         """
         Инициализация базового клиента
@@ -31,12 +34,15 @@ class BaseClient:
             api_version: Версия API (по умолчанию "v1")
             timeout: Таймаут запросов в секундах
             session: Опциональная aiohttp сессия (если не указана, создается новая)
+            auto_refresh_token: Автоматически обновлять токен при получении 401 ошибки
         """
         self.base_url = base_url.rstrip("/")
         self.api_version = api_version
         self.timeout = aiohttp.ClientTimeout(total=timeout)
         self._session = session
         self._own_session = session is None
+        self.auto_refresh_token = auto_refresh_token
+        self._refreshing = False  # Флаг для предотвращения рекурсивных обновлений
 
     @property
     def api_base_url(self) -> str:
@@ -80,6 +86,21 @@ class BaseClient:
             headers["Authorization"] = f"Bearer {access_token}"
         return headers
 
+    @abstractmethod
+    async def _refresh_token(self) -> None:
+        """
+        Абстрактный метод для обновления токена.
+        Должен быть реализован в дочерних классах.
+        """
+        pass
+
+    def _get_access_token(self) -> Optional[str]:
+        """
+        Получить текущий access token.
+        Должен быть переопределен в дочерних классах.
+        """
+        return None
+
     async def _handle_response(self, response: ClientResponse) -> Dict[str, Any]:
         """
         Обработать HTTP ответ
@@ -125,9 +146,10 @@ class BaseClient:
         json_data: Optional[Dict[str, Any]] = None,
         form_data: Optional[Dict[str, Any]] = None,
         params: Optional[Dict[str, Any]] = None,
+        retry_on_401: bool = True,
     ) -> Dict[str, Any]:
         """
-        Выполнить HTTP запрос
+        Выполнить HTTP запрос с автоматическим обновлением токена при 401
 
         Args:
             method: HTTP метод (GET, POST, etc.)
@@ -136,10 +158,15 @@ class BaseClient:
             json_data: JSON данные для тела запроса
             form_data: Form data для тела запроса
             params: Query параметры
+            retry_on_401: Повторить запрос после обновления токена при 401
 
         Returns:
             Распарсенный JSON ответ
         """
+        # Используем сохраненный токен, если не передан явно
+        if access_token is None:
+            access_token = self._get_access_token()
+
         url = self._build_url(endpoint)
         headers = self._get_headers(access_token)
 
@@ -155,6 +182,40 @@ class BaseClient:
             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)
 
     async def get(
@@ -162,9 +223,16 @@ class BaseClient:
         endpoint: str,
         access_token: Optional[str] = None,
         params: Optional[Dict[str, Any]] = None,
+        use_auto_refresh: bool = True,
     ) -> Dict[str, Any]:
         """Выполнить GET запрос"""
-        return await self._request("GET", endpoint, access_token=access_token, params=params)
+        return await self._request(
+            "GET",
+            endpoint,
+            access_token=access_token,
+            params=params,
+            retry_on_401=use_auto_refresh,
+        )
 
     async def post(
         self,
@@ -173,6 +241,7 @@ class BaseClient:
         json_data: Optional[Dict[str, Any]] = None,
         form_data: Optional[Dict[str, Any]] = None,
         params: Optional[Dict[str, Any]] = None,
+        use_auto_refresh: bool = True,
     ) -> Dict[str, Any]:
         """Выполнить POST запрос"""
         return await self._request(
@@ -182,6 +251,7 @@ class BaseClient:
             json_data=json_data,
             form_data=form_data,
             params=params,
+            retry_on_401=use_auto_refresh,
         )
 
     async def put(
@@ -190,15 +260,359 @@ class BaseClient:
         access_token: Optional[str] = None,
         json_data: Optional[Dict[str, Any]] = None,
         params: Optional[Dict[str, Any]] = None,
+        use_auto_refresh: bool = True,
     ) -> Dict[str, Any]:
         """Выполнить PUT запрос"""
-        return await self._request("PUT", endpoint, access_token=access_token, json_data=json_data, params=params)
+        return await self._request(
+            "PUT",
+            endpoint,
+            access_token=access_token,
+            json_data=json_data,
+            params=params,
+            retry_on_401=use_auto_refresh,
+        )
 
     async def delete(
         self,
         endpoint: str,
         access_token: Optional[str] = None,
         params: Optional[Dict[str, Any]] = None,
+        use_auto_refresh: bool = True,
     ) -> Dict[str, Any]:
         """Выполнить DELETE запрос"""
-        return await self._request("DELETE", endpoint, access_token=access_token, params=params)
+        return await self._request(
+            "DELETE",
+            endpoint,
+            access_token=access_token,
+            params=params,
+            retry_on_401=use_auto_refresh,
+        )
+
+    # ========== Админские методы ==========
+
+    # Пользователи
+    async def create_user(
+        self,
+        login: str,
+        email: str,
+        password: str,
+        name: str,
+        surname: str,
+        lastname: Optional[str] = None,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Создать нового пользователя (требует sso.admin.create)"""
+        json_data = {
+            "login": login,
+            "email": email,
+            "password": password,
+            "name": name,
+            "surname": surname,
+        }
+        if lastname:
+            json_data["lastname"] = lastname
+        return await self.post("admin/users", access_token=access_token, json_data=json_data)
+
+    async def get_users(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить список пользователей (требует sso.admin.read)"""
+        return await self.get(
+            "admin/users",
+            access_token=access_token,
+            params={"skip": skip, "limit": limit},
+        )
+
+    async def get_user(self, user_id: int, access_token: Optional[str] = None) -> Dict[str, Any]:
+        """Получить пользователя по ID (требует sso.admin.read)"""
+        return await self.get(f"admin/users/{user_id}", access_token=access_token)
+
+    async def update_user(
+        self,
+        user_id: int,
+        access_token: Optional[str] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Обновить пользователя (требует sso.admin.edit)"""
+        return await self.put(f"admin/users/{user_id}", access_token=access_token, json_data=kwargs)
+
+    async def delete_user(self, user_id: int, access_token: Optional[str] = None) -> Dict[str, Any]:
+        """Удалить пользователя (требует sso.admin.delete)"""
+        return await self.delete(f"admin/users/{user_id}", access_token=access_token)
+
+    # Роли
+    async def create_role(
+        self,
+        name: str,
+        display_name: str,
+        description: Optional[str] = None,
+        client_id: Optional[str] = None,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Создать новую роль (требует sso.admin.create)"""
+        json_data = {"name": name, "display_name": display_name}
+        if description:
+            json_data["description"] = description
+        if client_id:
+            json_data["client_id"] = client_id
+        return await self.post("admin/roles", access_token=access_token, json_data=json_data)
+
+    async def get_roles(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        client_id: Optional[str] = None,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить список ролей (требует sso.admin.read)"""
+        params = {"skip": skip, "limit": limit}
+        if client_id:
+            params["client_id"] = client_id
+        return await self.get("admin/roles", access_token=access_token, params=params)
+
+    async def get_role(self, role_id: int, access_token: Optional[str] = None) -> Dict[str, Any]:
+        """Получить роль по ID (требует sso.admin.read)"""
+        return await self.get(f"admin/roles/{role_id}", access_token=access_token)
+
+    async def update_role(
+        self,
+        role_id: int,
+        access_token: Optional[str] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Обновить роль (требует sso.admin.edit)"""
+        return await self.put(f"admin/roles/{role_id}", access_token=access_token, json_data=kwargs)
+
+    async def delete_role(self, role_id: int, access_token: Optional[str] = None) -> Dict[str, Any]:
+        """Удалить роль (требует sso.admin.delete)"""
+        return await self.delete(f"admin/roles/{role_id}", access_token=access_token)
+
+    # Разрешения (Scopes)
+    async def create_scope(
+        self,
+        name: str,
+        service_name: str,
+        resource: 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,
+        }
+        if description:
+            json_data["description"] = description
+        return await self.post("admin/scopes", access_token=access_token, json_data=json_data)
+
+    async def get_scopes(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить список разрешений (требует sso.admin.read)"""
+        return await self.get(
+            "admin/scopes",
+            access_token=access_token,
+            params={"skip": skip, "limit": limit},
+        )
+
+    async def get_scope(self, scope_id: int, access_token: Optional[str] = None) -> Dict[str, Any]:
+        """Получить разрешение по ID (требует sso.admin.read)"""
+        return await self.get(f"admin/scopes/{scope_id}", access_token=access_token)
+
+    async def update_scope(
+        self,
+        scope_id: int,
+        access_token: Optional[str] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Обновить разрешение (требует sso.admin.edit)"""
+        return await self.put(f"admin/scopes/{scope_id}", access_token=access_token, json_data=kwargs)
+
+    async def delete_scope(self, scope_id: int, access_token: Optional[str] = None) -> Dict[str, Any]:
+        """Удалить разрешение (требует sso.admin.delete)"""
+        return await self.delete(f"admin/scopes/{scope_id}", access_token=access_token)
+
+    # Микросервисы (Clients)
+    async def create_client(
+        self,
+        service_name: str,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Создать новый микросервис (требует sso.admin.create)"""
+        return await self.post("admin/clients", access_token=access_token, json_data={"service_name": service_name})
+
+    async def get_clients(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить список клиентов (требует sso.admin.read)"""
+        return await self.get(
+            "admin/clients",
+            access_token=access_token,
+            params={"skip": skip, "limit": limit},
+        )
+
+    async def get_client(self, client_id: str, access_token: Optional[str] = None) -> Dict[str, Any]:
+        """Получить клиента по ID (требует sso.admin.read)"""
+        return await self.get(f"admin/clients/{client_id}", access_token=access_token)
+
+    async def update_client(
+        self,
+        client_id: str,
+        access_token: Optional[str] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Обновить клиента (требует sso.admin.edit)"""
+        return await self.put(f"admin/clients/{client_id}", access_token=access_token, json_data=kwargs)
+
+    async def assign_scopes_to_client(
+        self,
+        client_id: str,
+        scope_ids: list[int],
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Назначить разрешения клиенту (требует 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 rotate_client_secret(
+        self,
+        client_id: str,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Ротация client_secret (требует sso.admin.edit)"""
+        return await self.post(f"admin/clients/{client_id}/rotate-secret", access_token=access_token)
+
+    # Назначение ролей пользователям
+    async def assign_role_to_user(
+        self,
+        user_id: int,
+        role_id: int,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Назначить роль пользователю (требует sso.admin.create)"""
+        return await self.post(
+            f"admin/user-roles/{user_id}/roles",
+            access_token=access_token,
+            json_data={"role_id": role_id},
+        )
+
+    async def revoke_role_from_user(
+        self,
+        user_id: int,
+        role_id: int,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Отозвать роль у пользователя (требует sso.admin.delete)"""
+        return await self.delete(
+            f"admin/user-roles/{user_id}/roles/{role_id}",
+            access_token=access_token,
+        )
+
+    async def get_user_roles(
+        self,
+        user_id: int,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить роли пользователя (требует sso.admin.read)"""
+        return await self.get(f"admin/user-roles/{user_id}/roles", access_token=access_token)
+
+    async def get_user_scopes(
+        self,
+        user_id: int,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить разрешения пользователя (требует sso.admin.read)"""
+        return await self.get(f"admin/user-roles/{user_id}/scopes", access_token=access_token)
+
+    async def get_users_with_roles(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить список пользователей с их ролями (требует sso.admin.read)"""
+        return await self.get(
+            "admin/user-roles",
+            access_token=access_token,
+            params={"skip": skip, "limit": limit},
+        )
+
+    # Логи
+    async def get_role_logs(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        user_id: Optional[int] = None,
+        search: Optional[str] = None,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить логи действий с ролями (требует sso.admin.read)"""
+        params = {"skip": skip, "limit": limit}
+        if user_id:
+            params["user_id"] = user_id
+        if search:
+            params["search"] = search
+        return await self.get("logs/role", access_token=access_token, params=params)
+
+    async def get_user_logs(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        user_id: Optional[int] = None,
+        search: Optional[str] = None,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить логи действий с пользователями (требует sso.admin.read)"""
+        params = {"skip": skip, "limit": limit}
+        if user_id:
+            params["user_id"] = user_id
+        if search:
+            params["search"] = search
+        return await self.get("logs/user", access_token=access_token, params=params)
+
+    async def get_auth_logs(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        user_id: Optional[int] = None,
+        search: Optional[str] = None,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить логи действий авторизации (требует sso.admin.read)"""
+        params = {"skip": skip, "limit": limit}
+        if user_id:
+            params["user_id"] = user_id
+        if search:
+            params["search"] = search
+        return await self.get("logs/auth", access_token=access_token, params=params)
+
+    async def get_service_logs(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        user_id: Optional[int] = None,
+        search: Optional[str] = None,
+        access_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Получить логи действий сервисов (требует sso.admin.read)"""
+        params = {"skip": skip, "limit": limit}
+        if user_id:
+            params["user_id"] = user_id
+        if search:
+            params["search"] = search
+        return await self.get("logs/service", access_token=access_token, params=params)

sso_nebus/exmples/example_admin.py

@@ -0,0 +1,53 @@
+"""Пример использования UserClient"""
+
+import asyncio
+
+from user_client import UserClient
+
+
+async def main():
+    # Создаем клиент
+    client = UserClient(
+        base_url="http://localhost:8000",
+        client_id="your_client_id"
+    )
+
+    try:
+        # Полный цикл авторизации
+        token_response = await client.full_auth_flow(
+            login="admin",
+            password="SecretPassword123!",
+            scope="sso.admin.read sso.admin.create",
+        )
+
+        print(f"Access token: {token_response.access_token[:50]}...")
+        print(
+            f"Refresh token: {token_response.refresh_token[:50] if token_response.refresh_token else None}...")
+        print(f"Expires in: {token_response.expires_in} seconds")
+
+        # Получаем информацию о пользователе
+        user_info = await client.get_current_user()
+        print(f"\nПользователь: {user_info.name} {user_info.surname}")
+        print(f"Email: {user_info.email}")
+        print(f"Scopes: {user_info.scopes}")
+
+        # Обновляем токен
+        new_token = await client.refresh_access_token()
+        print(
+            f"\nНовый access token получен: {new_token.access_token[:50]}...")
+
+        # Получаем список доступных сервисов
+        services = await client.get_available_services()
+        print(f"\nДоступно сервисов: {len(services.services)}")
+        for service in services.services:
+            print(f"  - {service.name} ({service.client_id})")
+
+    except Exception as e:
+        print(f"Ошибка: {e}")
+
+    finally:
+        await client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

sso_nebus/exmples/example_user.py

@@ -16,8 +16,8 @@ async def main():
     try:
         # Полный цикл авторизации
         token_response = await client.full_auth_flow(
-            login="user@example.com",
-            password="password123",
+            login="user",
+            password="SimplePassword123!",
             scope="sso.admin.read sso.admin.create",
         )
 

sso_nebus/service_client.py

@@ -2,9 +2,9 @@
 
 from typing import Optional
 
-from base import BaseClient
-from models import TokenResponse, UserInfo
-from exceptions import TokenError
+from .base import BaseClient
+from .models import TokenResponse, UserInfo
+from .exceptions import TokenError
 
 
 class ServiceClient(BaseClient):
@@ -18,6 +18,8 @@ class ServiceClient(BaseClient):
         api_version: str = "v1",
         timeout: int = 30,
         session=None,
+        auto_refresh_token: bool = True,
+        default_scope: Optional[str] = None,
     ):
         """
         Инициализация клиента для микросервисов
@@ -29,11 +31,14 @@ class ServiceClient(BaseClient):
             api_version: Версия API
             timeout: Таймаут запросов
             session: Опциональная aiohttp сессия
+            auto_refresh_token: Автоматически обновлять токен при получении 401 ошибки
+            default_scope: Scope по умолчанию для автоматического получения токена
         """
-        super().__init__(base_url, api_version, timeout, session)
+        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:
         """
@@ -90,6 +95,14 @@ class ServiceClient(BaseClient):
         """
         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

sso_nebus/user_client.py

@@ -5,8 +5,8 @@ import hashlib
 import base64
 import secrets
 
-from base import BaseClient
-from models import (
+from .base import BaseClient
+from .models import (
     PKCEParams,
     TokenResponse,
     UserInfo,
@@ -14,7 +14,7 @@ from models import (
     LoginResponse,
     ServicesList,
 )
-from exceptions import TokenError
+from .exceptions import TokenError
 
 
 class UserClient(BaseClient):
@@ -28,6 +28,7 @@ class UserClient(BaseClient):
         api_version: str = "v1",
         timeout: int = 30,
         session=None,
+        auto_refresh_token: bool = True,
     ):
         """
         Инициализация клиента для пользователей
@@ -39,8 +40,9 @@ class UserClient(BaseClient):
             api_version: Версия API
             timeout: Таймаут запросов
             session: Опциональная aiohttp сессия
+            auto_refresh_token: Автоматически обновлять токен при получении 401 ошибки
         """
-        super().__init__(base_url, api_version, timeout, session)
+        super().__init__(base_url, api_version, timeout, session, auto_refresh_token)
         self.client_id = client_id
         self.redirect_uri = redirect_uri
         self._pkce_params: Optional[PKCEParams] = None
@@ -70,7 +72,7 @@ class UserClient(BaseClient):
         Returns:
             PKCEParams с code_verifier, code_challenge и state
         """
-        data = await self.get("auth/pkce-params")
+        data = await self.get("pkce-params")
         self._pkce_params = PKCEParams(**data)
         return self._pkce_params
 
@@ -116,7 +118,7 @@ class UserClient(BaseClient):
         if scope:
             params["scope"] = scope
 
-        data = await self.get("auth/authorize", params=params)
+        data = await self.get("authorize", params=params)
         return AuthorizeResponse(**data)
 
     async def login(
@@ -142,7 +144,7 @@ class UserClient(BaseClient):
             "password": password,
         }
 
-        data = await self.post("auth/login", json_data=json_data)
+        data = await self.post("login", json_data=json_data)
         return LoginResponse(**data)
 
     async def exchange_code_for_tokens(
@@ -180,7 +182,7 @@ class UserClient(BaseClient):
         if redirect_uri:
             form_data["redirect_uri"] = redirect_uri
 
-        data = await self.post("auth/token", form_data=form_data)
+        data = await self.post("token", form_data=form_data)
         token_response = TokenResponse(**data)
 
         # Сохраняем токены
@@ -211,7 +213,7 @@ class UserClient(BaseClient):
             "client_id": self.client_id,
         }
 
-        data = await self.post("auth/token", form_data=form_data)
+        data = await self.post("token", form_data=form_data)
         token_response = TokenResponse(**data)
 
         # Обновляем токены
@@ -236,7 +238,7 @@ class UserClient(BaseClient):
             raise TokenError(
                 "Access token не найден. Выполните авторизацию сначала.")
 
-        data = await self.get("auth/me", access_token=access_token)
+        data = await self.get("me", access_token=access_token)
         return UserInfo(**data)
 
     async def logout(self, refresh_token: Optional[str] = None) -> dict:
@@ -256,7 +258,7 @@ class UserClient(BaseClient):
 
         form_data = {"refresh_token": refresh_token}
 
-        data = await self.post("auth/logout", form_data=form_data)
+        data = await self.post("logout", form_data=form_data)
 
         # Очищаем токены
         self._access_token = None
@@ -272,9 +274,19 @@ class UserClient(BaseClient):
         Returns:
             ServicesList со списком активных микросервисов
         """
-        data = await self.get("auth/services")
+        data = await self.get("services")
         return ServicesList(**data)
 
+    def _get_access_token(self) -> Optional[str]:
+        """Получить текущий access token (для BaseClient)"""
+        return self._access_token
+
+    async def _refresh_token(self) -> None:
+        """Обновить access token используя refresh token (для авто-рефреша)"""
+        if not self._refresh_token:
+            raise TokenError("Refresh token не найден. Выполните авторизацию сначала.")
+        await self.refresh_access_token(self._refresh_token)
+
     def get_access_token(self) -> Optional[str]:
         """Получить текущий access token"""
         return self._access_token

{sso_nebus-0.1.0.dist-info → sso_nebus-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sso-nebus
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python клиент для взаимодействия с MS Auth Service API
 License: LICENSE
 License-File: LICENSE
@@ -29,7 +29,7 @@ pip install -e .
 Или если пакет опубликован:
 
 ```bash
-pip install sso-nebus-client
+pip install sso_nebus
 ```
 
 ## Быстрый старт
@@ -168,6 +168,54 @@ async def main():
 asyncio.run(main())
 ```
 
+Пример для получения информации по пользвателю для подстановки в Depends
+```
+from fastapi import FastAPI, Header, HTTPException
+from typing import Optional
+
+app = FastAPI()
+
+sso_client = ServiceClient(
+    base_url="http://localhost:8000",
+    client_id="your_service_id",
+    client_secret="your_service_secret"
+)
+
+async def get_current_user(authorization: Optional[str] = Header(None)):
+    """
+    Dependency для получения текущего пользователя из токена
+    """
+    if not authorization:
+        raise HTTPException(status_code=401, detail="Токен не предоставлен")
+    
+    # Извлекаем токен из заголовка "Bearer <token>"
+    try:
+        token = authorization.split(" ")[1]
+    except IndexError:
+        raise HTTPException(status_code=401, detail="Неверный формат токена")
+    
+    try:
+        user_info = await sso_client.get_current_user(access_token=token)
+        return user_info
+    except AuthenticationError:
+        raise HTTPException(status_code=401, detail="Невалидный токен")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Ошибка при проверке токена: {e}")
+
+@app.get("/protected")
+async def protected_endpoint(current_user = Depends(get_current_user)):
+    """
+    Защищенный endpoint, который требует валидный токен пользователя
+    """
+    return {
+        "message": f"Привет, {current_user.name} {current_user.surname}!",
+        "user_id": current_user.id,
+        "email": current_user.email,
+        "scopes": current_user.scopes
+    }
+
+```
+
 ## API Reference
 
 ### UserClient

sso_nebus-0.1.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+sso_nebus/__init__.py,sha256=B7X9F074caljXhvE8Fpq1SwO-gVxzFUurOdbIkNLxp0,872
+sso_nebus/base.py,sha256=4LQ7-qxxonGILktmX3uQCraolrVnWZ_kqRfKO8EOcmk,24213
+sso_nebus/exceptions.py,sha256=XHrvfGGvs3eKMzkpwRxXyDngjpMSp7X7E8EUXwv26NA,1262
+sso_nebus/exmples/example_admin.py,sha256=eAqkS4J5YyJneP4EPUrBlvNbGlK7rHEO39kCklt_WQM,1822
+sso_nebus/exmples/example_service.py,sha256=19NNTmbaRSaWLpDQffGWNDmXkDJXdLOgD2WkV32xUu8,1778
+sso_nebus/exmples/example_user.py,sha256=c_Uf36FDHIXvv_vdqsO5XvXkvu1YOUsqaTO44_8DqVM,1878
+sso_nebus/models.py,sha256=0xIE5RvnxV2sAxO7_GTCes6HlHbdzGwHIjWVe1X7-ks,3024
+sso_nebus/service_client.py,sha256=RUmnwVJBXfEqFfidCwHfwZo-2S_tyz_n9Ojuje7j4F4,5470
+sso_nebus/user_client.py,sha256=-3pJmvZxJgyEo3moGQvZVAOhJMOIC6NuE8NgJ33Fyfs,12976
+sso_nebus-0.1.2.dist-info/licenses/LICENSE,sha256=dCbOm3zpH8T7vLDC2K7QJLu-LEl2zqaSuyARbqfGsEY,1863
+sso_nebus-0.1.2.dist-info/METADATA,sha256=hed0VrJyId6el7rcpUs4ecjqyh2-c3D372CXzJvaGk0,8406
+sso_nebus-0.1.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+sso_nebus-0.1.2.dist-info/RECORD,,

sso_nebus-0.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-sso_nebus/__init__.py,sha256=tmKUfBVcL4-AzsschcI2nFX9eWnnZfJ4SxlMSBvmF7o,869
-sso_nebus/base.py,sha256=DssaeMXU9kNyIiF4WllvLyLGwqSwKSXMd_rrjGoPHGc,7522
-sso_nebus/exceptions.py,sha256=XHrvfGGvs3eKMzkpwRxXyDngjpMSp7X7E8EUXwv26NA,1262
-sso_nebus/exmples/example_service.py,sha256=19NNTmbaRSaWLpDQffGWNDmXkDJXdLOgD2WkV32xUu8,1778
-sso_nebus/exmples/example_user.py,sha256=HXVV6FZTrnHwKoD_9OlXXlRJ9PsL9FL36bYSK7ztSNo,1883
-sso_nebus/models.py,sha256=0xIE5RvnxV2sAxO7_GTCes6HlHbdzGwHIjWVe1X7-ks,3024
-sso_nebus/service_client.py,sha256=gO6oyvu8x-r7B-T5lD65gybaQY-Ze1DYZbOXRkH-WTA,4704
-sso_nebus/user_client.py,sha256=X4jxWf_XeKDAlw_we552kElyIrdKf3WXgl7QTqroPrM,12269
-sso_nebus-0.1.0.dist-info/licenses/LICENSE,sha256=dCbOm3zpH8T7vLDC2K7QJLu-LEl2zqaSuyARbqfGsEY,1863
-sso_nebus-0.1.0.dist-info/METADATA,sha256=BocwVBRAyPSSXCh7vdHymr368CvEsBLy5HMN7v4Wa_I,6656
-sso_nebus-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-sso_nebus-0.1.0.dist-info/RECORD,,