sso-nebus 0.1.0__tar.gz → 0.1.2__tar.gz

{sso_nebus-0.1.0 → sso_nebus-0.1.2}/PKG-INFO

@@ -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.0 → sso_nebus-0.1.2}/README.md

@@ -11,7 +11,7 @@ pip install -e .
 Или если пакет опубликован:
 
 ```bash
-pip install sso-nebus-client
+pip install sso_nebus
 ```
 
 ## Быстрый старт
@@ -150,6 +150,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.0 → sso_nebus-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sso-nebus"
-version = "0.1.0"
+version = "0.1.2"
 description = "Python клиент для взаимодействия с MS Auth Service API"
 authors = [
     {name = "Артем Костюченко",email = "kostyuchenko.work@gmail.com"}

{sso_nebus-0.1.0 → sso_nebus-0.1.2}/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-0.1.2/sso_nebus/base.py

@@ -0,0 +1,618 @@
+"""Базовый класс для SSO клиентов"""
+
+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 (
+    APIError,
+    AuthenticationError,
+    AuthorizationError,
+    TokenError,
+)
+
+
+class BaseClient(ABC):
+    """Базовый класс для всех SSO клиентов"""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_version: str = "v1",
+        timeout: int = 30,
+        session: Optional[ClientSession] = None,
+        auto_refresh_token: bool = True,
+    ):
+        """
+        Инициализация базового клиента
+
+        Args:
+            base_url: Базовый URL API (например, "http://localhost:8000")
+            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:
+        """Базовый URL для API endpoints"""
+        return urljoin(self.base_url, f"/api/{self.api_version}/")
+
+    @property
+    def session(self) -> ClientSession:
+        """Получить или создать aiohttp сессию"""
+        if self._session is None:
+            self._session = aiohttp.ClientSession(timeout=self.timeout)
+            self._own_session = True
+        elif self._session.closed:
+            # Если сессия закрыта, создаем новую
+            self._session = aiohttp.ClientSession(timeout=self.timeout)
+            self._own_session = True
+        return self._session
+
+    async def close(self):
+        """Закрыть сессию (если она была создана клиентом)"""
+        if self._own_session and self._session and not self._session.closed:
+            await self._session.close()
+
+    async def __aenter__(self):
+        """Поддержка async context manager"""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Закрытие сессии при выходе из context manager"""
+        await self.close()
+
+    def _build_url(self, endpoint: str) -> str:
+        """Построить полный URL для endpoint"""
+        endpoint = endpoint.lstrip("/")
+        return urljoin(self.api_base_url, endpoint)
+
+    def _get_headers(self, access_token: Optional[str] = None) -> Dict[str, str]:
+        """Получить заголовки для запроса"""
+        headers = {"Content-Type": "application/json"}
+        if access_token:
+            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 ответ
+
+        Args:
+            response: aiohttp ClientResponse
+
+        Returns:
+            Распарсенный JSON ответ
+
+        Raises:
+            APIError: При ошибках API
+            AuthenticationError: При ошибках аутентификации (401)
+            AuthorizationError: При ошибках авторизации (403)
+        """
+        try:
+            data = await response.json()
+        except aiohttp.ContentTypeError:
+            # Если ответ не JSON, пытаемся получить текст
+            text = await response.text()
+            data = {"detail": text} if text else {
+                "detail": "Неизвестная ошибка"}
+
+        if response.status == 401:
+            detail = data.get("detail", "Ошибка аутентификации")
+            raise AuthenticationError(detail)
+
+        if response.status == 403:
+            detail = data.get("detail", "Ошибка авторизации")
+            raise AuthorizationError(detail)
+
+        if not response.ok:
+            detail = data.get("detail", f"Ошибка API: {response.status}")
+            raise APIError(detail, status_code=response.status)
+
+        return data
+
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        access_token: Optional[str] = None,
+        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 запрос с автоматическим обновлением токена при 401
+
+        Args:
+            method: HTTP метод (GET, POST, etc.)
+            endpoint: API endpoint (например, "auth/me")
+            access_token: Access token для авторизации (опционально)
+            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)
+
+        # Если form_data, меняем Content-Type
+        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)
+
+    async def get(
+        self,
+        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,
+            retry_on_401=use_auto_refresh,
+        )
+
+    async def post(
+        self,
+        endpoint: str,
+        access_token: Optional[str] = None,
+        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(
+            "POST",
+            endpoint,
+            access_token=access_token,
+            json_data=json_data,
+            form_data=form_data,
+            params=params,
+            retry_on_401=use_auto_refresh,
+        )
+
+    async def put(
+        self,
+        endpoint: str,
+        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,
+            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,
+            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-0.1.2/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-0.1.0 → sso_nebus-0.1.2}/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-0.1.0 → sso_nebus-0.1.2}/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-0.1.0 → sso_nebus-0.1.2}/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/sso_nebus/base.py

@@ -1,204 +0,0 @@
-"""Базовый класс для SSO клиентов"""
-
-from typing import Optional, Dict, Any
-from urllib.parse import urljoin
-
-import aiohttp
-from aiohttp import ClientSession, ClientResponse
-
-from exceptions import (
-    APIError,
-    AuthenticationError,
-    AuthorizationError,
-)
-
-
-class BaseClient:
-    """Базовый класс для всех SSO клиентов"""
-
-    def __init__(
-        self,
-        base_url: str,
-        api_version: str = "v1",
-        timeout: int = 30,
-        session: Optional[ClientSession] = None,
-    ):
-        """
-        Инициализация базового клиента
-
-        Args:
-            base_url: Базовый URL API (например, "http://localhost:8000")
-            api_version: Версия API (по умолчанию "v1")
-            timeout: Таймаут запросов в секундах
-            session: Опциональная aiohttp сессия (если не указана, создается новая)
-        """
-        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
-
-    @property
-    def api_base_url(self) -> str:
-        """Базовый URL для API endpoints"""
-        return urljoin(self.base_url, f"/api/{self.api_version}/")
-
-    @property
-    def session(self) -> ClientSession:
-        """Получить или создать aiohttp сессию"""
-        if self._session is None:
-            self._session = aiohttp.ClientSession(timeout=self.timeout)
-            self._own_session = True
-        elif self._session.closed:
-            # Если сессия закрыта, создаем новую
-            self._session = aiohttp.ClientSession(timeout=self.timeout)
-            self._own_session = True
-        return self._session
-
-    async def close(self):
-        """Закрыть сессию (если она была создана клиентом)"""
-        if self._own_session and self._session and not self._session.closed:
-            await self._session.close()
-
-    async def __aenter__(self):
-        """Поддержка async context manager"""
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Закрытие сессии при выходе из context manager"""
-        await self.close()
-
-    def _build_url(self, endpoint: str) -> str:
-        """Построить полный URL для endpoint"""
-        endpoint = endpoint.lstrip("/")
-        return urljoin(self.api_base_url, endpoint)
-
-    def _get_headers(self, access_token: Optional[str] = None) -> Dict[str, str]:
-        """Получить заголовки для запроса"""
-        headers = {"Content-Type": "application/json"}
-        if access_token:
-            headers["Authorization"] = f"Bearer {access_token}"
-        return headers
-
-    async def _handle_response(self, response: ClientResponse) -> Dict[str, Any]:
-        """
-        Обработать HTTP ответ
-
-        Args:
-            response: aiohttp ClientResponse
-
-        Returns:
-            Распарсенный JSON ответ
-
-        Raises:
-            APIError: При ошибках API
-            AuthenticationError: При ошибках аутентификации (401)
-            AuthorizationError: При ошибках авторизации (403)
-        """
-        try:
-            data = await response.json()
-        except aiohttp.ContentTypeError:
-            # Если ответ не JSON, пытаемся получить текст
-            text = await response.text()
-            data = {"detail": text} if text else {
-                "detail": "Неизвестная ошибка"}
-
-        if response.status == 401:
-            detail = data.get("detail", "Ошибка аутентификации")
-            raise AuthenticationError(detail)
-
-        if response.status == 403:
-            detail = data.get("detail", "Ошибка авторизации")
-            raise AuthorizationError(detail)
-
-        if not response.ok:
-            detail = data.get("detail", f"Ошибка API: {response.status}")
-            raise APIError(detail, status_code=response.status)
-
-        return data
-
-    async def _request(
-        self,
-        method: str,
-        endpoint: str,
-        access_token: Optional[str] = None,
-        json_data: Optional[Dict[str, Any]] = None,
-        form_data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """
-        Выполнить HTTP запрос
-
-        Args:
-            method: HTTP метод (GET, POST, etc.)
-            endpoint: API endpoint (например, "auth/me")
-            access_token: Access token для авторизации (опционально)
-            json_data: JSON данные для тела запроса
-            form_data: Form data для тела запроса
-            params: Query параметры
-
-        Returns:
-            Распарсенный JSON ответ
-        """
-        url = self._build_url(endpoint)
-        headers = self._get_headers(access_token)
-
-        # Если form_data, меняем Content-Type
-        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:
-            return await self._handle_response(response)
-
-    async def get(
-        self,
-        endpoint: str,
-        access_token: Optional[str] = None,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """Выполнить GET запрос"""
-        return await self._request("GET", endpoint, access_token=access_token, params=params)
-
-    async def post(
-        self,
-        endpoint: str,
-        access_token: Optional[str] = None,
-        json_data: Optional[Dict[str, Any]] = None,
-        form_data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """Выполнить POST запрос"""
-        return await self._request(
-            "POST",
-            endpoint,
-            access_token=access_token,
-            json_data=json_data,
-            form_data=form_data,
-            params=params,
-        )
-
-    async def put(
-        self,
-        endpoint: str,
-        access_token: Optional[str] = None,
-        json_data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """Выполнить PUT запрос"""
-        return await self._request("PUT", endpoint, access_token=access_token, json_data=json_data, params=params)
-
-    async def delete(
-        self,
-        endpoint: str,
-        access_token: Optional[str] = None,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """Выполнить DELETE запрос"""
-        return await self._request("DELETE", endpoint, access_token=access_token, params=params)