sso-nebus 0.1.0__py3-none-any.whl

sso_nebus/__init__.py

@@ -0,0 +1,30 @@
+"""
+SSO Nebus Client - Python клиент для взаимодействия с MS Auth Service API
+
+Этот пакет предоставляет удобные классы для работы с API аутентификации:
+- UserClient: для пользовательского взаимодействия (OAuth 2.0 с PKCE)
+- ServiceClient: для микросервисного взаимодействия (Client Credentials)
+"""
+
+from user_client import UserClient
+from service_client import ServiceClient
+from exceptions import (
+    SSOClientError,
+    AuthenticationError,
+    AuthorizationError,
+    APIError,
+    TokenError,
+)
+
+__all__ = [
+    "UserClient",
+    "ServiceClient",
+    "SSOClientError",
+    "AuthenticationError",
+    "AuthorizationError",
+    "APIError",
+    "TokenError",
+]
+
+__version__ = "0.1.0"
+

sso_nebus/base.py

@@ -0,0 +1,204 @@
+"""Базовый класс для 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)

sso_nebus/exceptions.py

@@ -0,0 +1,38 @@
+"""Исключения для SSO клиента"""
+
+
+class SSOClientError(Exception):
+    """Базовое исключение для всех ошибок клиента"""
+
+    def __init__(self, message: str, status_code: int | None = None):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+
+
+class AuthenticationError(SSOClientError):
+    """Ошибка аутентификации (401)"""
+
+    def __init__(self, message: str = "Ошибка аутентификации"):
+        super().__init__(message, status_code=401)
+
+
+class AuthorizationError(SSOClientError):
+    """Ошибка авторизации (403)"""
+
+    def __init__(self, message: str = "Ошибка авторизации"):
+        super().__init__(message, status_code=403)
+
+
+class APIError(SSOClientError):
+    """Ошибка API (4xx, 5xx)"""
+
+    def __init__(self, message: str, status_code: int):
+        super().__init__(message, status_code=status_code)
+
+
+class TokenError(SSOClientError):
+    """Ошибка работы с токенами"""
+
+    def __init__(self, message: str = "Ошибка работы с токеном"):
+        super().__init__(message)

sso_nebus/exmples/example_service.py

@@ -0,0 +1,50 @@
+"""Пример использования ServiceClient"""
+
+import asyncio
+from service_client import ServiceClient
+ 
+
+async def main():
+    # Создаем клиент для микросервиса
+    client = ServiceClient(
+        base_url="http://localhost:8000",
+        client_id="service_id",
+        client_secret="service_secret",
+    )
+
+    try:
+        # Получаем access token
+        token_response = await client.get_access_token(
+            scope="system.client.read system.client.edit",
+        )
+
+        print(f"Access token: {token_response.access_token[:50]}...")
+        print(f"Expires in: {token_response.expires_in} seconds")
+        print(f"Scope: {token_response.scope}")
+
+        # Получаем информацию о текущем пользователе/сервисе
+        user_info = await client.get_current_user()
+        print(f"\nClient ID: {user_info.id if hasattr(user_info, 'id') else 'N/A'}")
+
+        # Выполняем запросы с авторизацией
+        # Пример: получение списка пользователей (требует админских прав)
+        try:
+            data = await client.request_with_auth(
+                method="GET",
+                endpoint="admin/users",
+                params={"skip": 0, "limit": 10},
+            )
+            print(f"\nПолучено пользователей: {len(data) if isinstance(data, list) else 'N/A'}")
+        except Exception as e:
+            print(f"\nОшибка при запросе: {e}")
+
+    except Exception as e:
+        print(f"Ошибка: {e}")
+
+    finally:
+        await client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

sso_nebus/exmples/example_user.py

@@ -0,0 +1,54 @@
+"""Пример использования UserClient"""
+
+import asyncio
+
+from user_client import UserClient
+
+
+async def main():
+    # Создаем клиент
+    client = UserClient(
+        base_url="http://localhost:8000",
+        client_id="your_client_id",
+        redirect_uri="http://localhost:3000/callback",
+    )
+
+    try:
+        # Полный цикл авторизации
+        token_response = await client.full_auth_flow(
+            login="user@example.com",
+            password="password123",
+            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/models.py

@@ -0,0 +1,67 @@
+"""Pydantic модели для SSO клиента"""
+
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class PKCEParams(BaseModel):
+    """PKCE параметры для OAuth 2.0"""
+
+    code_verifier: str = Field(..., description="Code verifier для PKCE")
+    code_challenge: str = Field(..., description="Code challenge для PKCE")
+    state: str = Field(..., description="State parameter для CSRF защиты")
+
+
+class TokenResponse(BaseModel):
+    """Ответ с токенами"""
+
+    access_token: str = Field(..., description="Access token")
+    token_type: str = Field(default="Bearer", description="Тип токена")
+    expires_in: int = Field(..., description="Время жизни токена в секундах")
+    refresh_token: Optional[str] = Field(
+        None, description="Refresh token (только для пользователей)")
+    scope: Optional[str] = Field(None, description="Разрешения (scopes)")
+
+
+class UserInfo(BaseModel):
+    """Информация о пользователе"""
+
+    id: int = Field(..., description="ID пользователя")
+    email: str = Field(..., description="Email пользователя")
+    name: str = Field(..., description="Имя пользователя")
+    surname: str = Field(..., description="Фамилия пользователя")
+    lastname: Optional[str] = Field(None, description="Отчество пользователя")
+    scopes: list[str] = Field(default_factory=list,
+                              description="Список разрешений пользователя")
+
+
+class ServiceInfo(BaseModel):
+    """Информация о сервисе"""
+
+    client_id: str = Field(..., description="Уникальный идентификатор клиента")
+    name: Optional[str] = Field(None, description="Название сервиса")
+
+
+class ServicesList(BaseModel):
+    """Список доступных сервисов"""
+
+    services: list[ServiceInfo] = Field(...,
+                                        description="Список всех активных микросервисов")
+
+
+class AuthorizeResponse(BaseModel):
+    """Ответ на запрос авторизации"""
+
+    session_id: str = Field(...,
+                            description="ID сессии для последующего логина")
+    message: str = Field(..., description="Сообщение для клиента")
+
+
+class LoginResponse(BaseModel):
+    """Ответ на запрос логина"""
+
+    success: bool = Field(..., description="Успешность операции")
+    message: str = Field(..., description="Сообщение")
+    authorization_code: str = Field(...,
+                                    description="Authorization code для обмена на токены")
+    state: str = Field(..., description="State parameter для проверки")

sso_nebus/service_client.py

@@ -0,0 +1,134 @@
+"""Клиент для микросервисного взаимодействия (Client Credentials)"""
+
+from typing import Optional
+
+from base import BaseClient
+from models import TokenResponse, UserInfo
+from exceptions import TokenError
+
+
+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,
+    ):
+        """
+        Инициализация клиента для микросервисов
+
+        Args:
+            base_url: Базовый URL API
+            client_id: ID микросервиса
+            client_secret: Секрет микросервиса
+            api_version: Версия API
+            timeout: Таймаут запросов
+            session: Опциональная aiohttp сессия
+        """
+        super().__init__(base_url, api_version, timeout, session)
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self._access_token: Optional[str] = None
+
+    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("auth/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("auth/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_token(self) -> Optional[str]:
+        """Получить текущий access token"""
+        return self._access_token
+
+    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,
+        )

sso_nebus/user_client.py

@@ -0,0 +1,341 @@
+"""Клиент для пользовательского взаимодействия (OAuth 2.0 с PKCE)"""
+
+from typing import Optional
+import hashlib
+import base64
+import secrets
+
+from base import BaseClient
+from models import (
+    PKCEParams,
+    TokenResponse,
+    UserInfo,
+    AuthorizeResponse,
+    LoginResponse,
+    ServicesList,
+)
+from exceptions import TokenError
+
+
+class UserClient(BaseClient):
+    """Клиент для пользовательского взаимодействия с OAuth 2.0 Authorization Code Flow с PKCE"""
+
+    def __init__(
+        self,
+        base_url: str,
+        client_id: str,
+        redirect_uri: Optional[str] = None,
+        api_version: str = "v1",
+        timeout: int = 30,
+        session=None,
+    ):
+        """
+        Инициализация клиента для пользователей
+
+        Args:
+            base_url: Базовый URL API
+            client_id: ID OAuth клиента
+            redirect_uri: URI для редиректа (опционально)
+            api_version: Версия API
+            timeout: Таймаут запросов
+            session: Опциональная aiohttp сессия
+        """
+        super().__init__(base_url, api_version, timeout, session)
+        self.client_id = client_id
+        self.redirect_uri = redirect_uri
+        self._pkce_params: Optional[PKCEParams] = None
+        self._access_token: Optional[str] = None
+        self._refresh_token: Optional[str] = None
+
+    @staticmethod
+    def _generate_code_verifier() -> str:
+        """Генерация code_verifier для PKCE"""
+        return base64.urlsafe_b64encode(secrets.token_bytes(32)).decode("utf-8").rstrip("=")
+
+    @staticmethod
+    def _generate_code_challenge(code_verifier: str) -> str:
+        """Генерация code_challenge из code_verifier"""
+        sha256_hash = hashlib.sha256(code_verifier.encode("utf-8")).digest()
+        return base64.urlsafe_b64encode(sha256_hash).decode("utf-8").rstrip("=")
+
+    @staticmethod
+    def _generate_state() -> str:
+        """Генерация state для CSRF защиты"""
+        return base64.urlsafe_b64encode(secrets.token_bytes(32)).decode("utf-8").rstrip("=")
+
+    async def get_pkce_params(self) -> PKCEParams:
+        """
+        Получить PKCE параметры от сервера
+
+        Returns:
+            PKCEParams с code_verifier, code_challenge и state
+        """
+        data = await self.get("auth/pkce-params")
+        self._pkce_params = PKCEParams(**data)
+        return self._pkce_params
+
+    async def authorize(
+        self,
+        scope: Optional[str] = None,
+        redirect_uri: Optional[str] = None,
+        pkce_params: Optional[PKCEParams] = None,
+    ) -> AuthorizeResponse:
+        """
+        Инициировать OAuth 2.0 Authorization Code Flow
+
+        Args:
+            scope: Запрашиваемые разрешения (разделенные пробелом)
+            redirect_uri: URI для редиректа (если не указан, используется из конструктора)
+            pkce_params: PKCE параметры (если не указаны, получаются автоматически)
+
+        Returns:
+            AuthorizeResponse с session_id для последующего логина
+        """
+        # Получаем PKCE параметры, если не переданы
+        if pkce_params is None:
+            if self._pkce_params is None:
+                pkce_params = await self.get_pkce_params()
+            else:
+                pkce_params = self._pkce_params
+        else:
+            self._pkce_params = pkce_params
+
+        redirect_uri = redirect_uri or self.redirect_uri
+
+        params = {
+            "response_type": "code",
+            "client_id": self.client_id,
+            "state": pkce_params.state,
+            "code_challenge": pkce_params.code_challenge,
+            "code_challenge_method": "S256",
+        }
+
+        if redirect_uri:
+            params["redirect_uri"] = redirect_uri
+
+        if scope:
+            params["scope"] = scope
+
+        data = await self.get("auth/authorize", params=params)
+        return AuthorizeResponse(**data)
+
+    async def login(
+        self,
+        login: str,
+        password: str,
+        session_id: str,
+    ) -> LoginResponse:
+        """
+        Выполнить аутентификацию пользователя
+
+        Args:
+            login: Логин пользователя
+            password: Пароль пользователя
+            session_id: ID сессии из метода authorize()
+
+        Returns:
+            LoginResponse с authorization_code
+        """
+        json_data = {
+            "session_id": session_id,
+            "login": login,
+            "password": password,
+        }
+
+        data = await self.post("auth/login", json_data=json_data)
+        return LoginResponse(**data)
+
+    async def exchange_code_for_tokens(
+        self,
+        authorization_code: str,
+        redirect_uri: Optional[str] = None,
+        pkce_params: Optional[PKCEParams] = None,
+    ) -> TokenResponse:
+        """
+        Обменять authorization code на токены
+
+        Args:
+            authorization_code: Authorization code из метода login()
+            redirect_uri: Redirect URI (если не указан, используется из конструктора)
+            pkce_params: PKCE параметры (если не указаны, используются сохраненные)
+
+        Returns:
+            TokenResponse с access_token и refresh_token
+        """
+        if pkce_params is None:
+            if self._pkce_params is None:
+                raise TokenError(
+                    "PKCE параметры не найдены. Вызовите get_pkce_params() или authorize() сначала.")
+            pkce_params = self._pkce_params
+
+        redirect_uri = redirect_uri or self.redirect_uri
+
+        form_data = {
+            "grant_type": "authorization_code",
+            "code": authorization_code,
+            "client_id": self.client_id,
+            "code_verifier": pkce_params.code_verifier,
+        }
+
+        if redirect_uri:
+            form_data["redirect_uri"] = redirect_uri
+
+        data = await self.post("auth/token", form_data=form_data)
+        token_response = TokenResponse(**data)
+
+        # Сохраняем токены
+        self._access_token = token_response.access_token
+        self._refresh_token = token_response.refresh_token
+
+        return token_response
+
+    async def refresh_access_token(self, refresh_token: Optional[str] = None) -> TokenResponse:
+        """
+        Обновить access token используя refresh token
+
+        Args:
+            refresh_token: Refresh token (если не указан, используется сохраненный)
+
+        Returns:
+            TokenResponse с новым access_token и refresh_token
+        """
+        refresh_token = refresh_token or self._refresh_token
+
+        if not refresh_token:
+            raise TokenError(
+                "Refresh token не найден. Выполните авторизацию сначала.")
+
+        form_data = {
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "client_id": self.client_id,
+        }
+
+        data = await self.post("auth/token", form_data=form_data)
+        token_response = TokenResponse(**data)
+
+        # Обновляем токены
+        self._access_token = token_response.access_token
+        self._refresh_token = token_response.refresh_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 не найден. Выполните авторизацию сначала.")
+
+        data = await self.get("auth/me", access_token=access_token)
+        return UserInfo(**data)
+
+    async def logout(self, refresh_token: Optional[str] = None) -> dict:
+        """
+        Выйти из системы и отозвать refresh token
+
+        Args:
+            refresh_token: Refresh token для отзыва (если не указан, используется сохраненный)
+
+        Returns:
+            Словарь с сообщением об успешном выходе
+        """
+        refresh_token = refresh_token or self._refresh_token
+
+        if not refresh_token:
+            raise TokenError("Refresh token не найден.")
+
+        form_data = {"refresh_token": refresh_token}
+
+        data = await self.post("auth/logout", form_data=form_data)
+
+        # Очищаем токены
+        self._access_token = None
+        self._refresh_token = None
+        self._pkce_params = None
+
+        return data
+
+    async def get_available_services(self) -> ServicesList:
+        """
+        Получить список всех доступных микросервисов
+
+        Returns:
+            ServicesList со списком активных микросервисов
+        """
+        data = await self.get("auth/services")
+        return ServicesList(**data)
+
+    def get_access_token(self) -> Optional[str]:
+        """Получить текущий access token"""
+        return self._access_token
+
+    def get_refresh_token(self) -> Optional[str]:
+        """Получить текущий refresh token"""
+        return self._refresh_token
+
+    def set_tokens(self, access_token: str, refresh_token: Optional[str] = None):
+        """
+        Установить токены вручную
+
+        Args:
+            access_token: Access token
+            refresh_token: Refresh token (опционально)
+        """
+        self._access_token = access_token
+        if refresh_token:
+            self._refresh_token = refresh_token
+
+    async def full_auth_flow(
+        self,
+        login: str,
+        password: str,
+        scope: Optional[str] = None,
+        redirect_uri: Optional[str] = None,
+    ) -> TokenResponse:
+        """
+        Выполнить полный цикл авторизации (удобный метод)
+
+        Args:
+            login: Логин пользователя
+            password: Пароль пользователя
+            scope: Запрашиваемые разрешения
+            redirect_uri: URI для редиректа
+
+        Returns:
+            TokenResponse с токенами
+        """
+        # 1. Получаем PKCE параметры
+        pkce_params = await self.get_pkce_params()
+
+        # 2. Инициируем авторизацию
+        auth_response = await self.authorize(
+            scope=scope,
+            redirect_uri=redirect_uri,
+            pkce_params=pkce_params,
+        )
+
+        # 3. Выполняем логин
+        login_response = await self.login(
+            login=login,
+            password=password,
+            session_id=auth_response.session_id,
+        )
+
+        # 4. Обмениваем код на токены
+        token_response = await self.exchange_code_for_tokens(
+            authorization_code=login_response.authorization_code,
+            redirect_uri=redirect_uri,
+            pkce_params=pkce_params,
+        )
+
+        return token_response

sso_nebus-0.1.0.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: sso-nebus
+Version: 0.1.0
+Summary: Python клиент для взаимодействия с MS Auth Service API
+License: LICENSE
+License-File: LICENSE
+Author: Артем Костюченко
+Author-email: kostyuchenko.work@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: aiohttp (>=3.13.2,<4.0.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Description-Content-Type: text/markdown
+
+# SSO Nebus Client
+
+Python клиент для взаимодействия с MS Auth Service API. Предоставляет удобные классы для работы с OAuth 2.0 Authorization Code Flow с PKCE (для пользователей) и Client Credentials Grant (для микросервисов).
+
+## Установка
+
+```bash
+pip install -e .
+```
+
+Или если пакет опубликован:
+
+```bash
+pip install sso-nebus-client
+```
+
+## Быстрый старт
+
+### Для пользователей (UserClient)
+
+```python
+import asyncio
+from sso_client import UserClient
+
+async def main():
+    # Создаем клиент
+    client = UserClient(
+        base_url="http://localhost:8000",
+        client_id="your_client_id",
+        redirect_uri="http://localhost:3000/callback"
+    )
+    
+    # Полный цикл авторизации
+    token_response = await client.full_auth_flow(
+        login="user@example.com",
+        password="password123",
+        scope="sso.admin.read sso.admin.create"
+    )
+    
+    print(f"Access token: {token_response.access_token}")
+    print(f"Refresh token: {token_response.refresh_token}")
+    
+    # Получаем информацию о пользователе
+    user_info = await client.get_current_user()
+    print(f"Пользователь: {user_info.name} {user_info.surname}")
+    
+    # Обновляем токен
+    new_token = await client.refresh_access_token()
+    print(f"Новый access token: {new_token.access_token}")
+    
+    await client.close()
+
+asyncio.run(main())
+```
+
+### Пошаговая авторизация
+
+```python
+import asyncio
+from sso_client import UserClient
+
+async def main():
+    client = UserClient(
+        base_url="http://localhost:8000",
+        client_id="your_client_id"
+    )
+    
+    # 1. Получаем PKCE параметры
+    pkce_params = await client.get_pkce_params()
+    
+    # 2. Инициируем авторизацию
+    auth_response = await client.authorize(
+        scope="sso.admin.read",
+        pkce_params=pkce_params
+    )
+    
+    # 3. Выполняем логин
+    login_response = await client.login(
+        login="user@example.com",
+        password="password123",
+        session_id=auth_response.session_id
+    )
+    
+    # 4. Обмениваем код на токены
+    token_response = await client.exchange_code_for_tokens(
+        authorization_code=login_response.authorization_code,
+        pkce_params=pkce_params
+    )
+    
+    print(f"Токены получены: {token_response.access_token}")
+    
+    await client.close()
+
+asyncio.run(main())
+```
+
+### Для микросервисов (ServiceClient)
+
+```python
+import asyncio
+from sso_client import ServiceClient
+
+async def main():
+    # Создаем клиент для микросервиса
+    client = ServiceClient(
+        base_url="http://localhost:8000",
+        client_id="service_id",
+        client_secret="service_secret"
+    )
+    
+    # Получаем access token
+    token_response = await client.get_access_token(
+        scope="system.client.read system.client.edit"
+    )
+    
+    print(f"Access token: {token_response.access_token}")
+    
+    # Выполняем запросы с авторизацией
+    user_info = await client.get_current_user()
+    
+    # Или используем request_with_auth для любых endpoints
+    data = await client.request_with_auth(
+        method="GET",
+        endpoint="admin/users",
+        params={"skip": 0, "limit": 10}
+    )
+    
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Использование с async context manager
+
+```python
+import asyncio
+from sso_client import UserClient
+
+async def main():
+    async with UserClient(
+        base_url="http://localhost:8000",
+        client_id="your_client_id"
+    ) as client:
+        token_response = await client.full_auth_flow(
+            login="user@example.com",
+            password="password123"
+        )
+        # Сессия автоматически закроется при выходе
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### UserClient
+
+Класс для пользовательского взаимодействия с OAuth 2.0 Authorization Code Flow с PKCE.
+
+#### Методы
+
+- `get_pkce_params()` - Получить PKCE параметры от сервера
+- `authorize(scope, redirect_uri, pkce_params)` - Инициировать OAuth 2.0 flow
+- `login(login, password, session_id)` - Выполнить аутентификацию
+- `exchange_code_for_tokens(authorization_code, redirect_uri, pkce_params)` - Обменять код на токены
+- `refresh_access_token(refresh_token)` - Обновить access token
+- `get_current_user(access_token)` - Получить информацию о пользователе
+- `logout(refresh_token)` - Выйти из системы
+- `get_available_services()` - Получить список доступных микросервисов
+- `full_auth_flow(login, password, scope, redirect_uri)` - Выполнить полный цикл авторизации
+
+### ServiceClient
+
+Класс для микросервисного взаимодействия с Client Credentials Grant.
+
+#### Методы
+
+- `get_access_token(scope)` - Получить access token
+- `get_current_user(access_token)` - Получить информацию о текущем пользователе/сервисе
+- `request_with_auth(method, endpoint, json_data, params, auto_refresh)` - Выполнить запрос с авторизацией
+
+## Исключения
+
+- `SSOClientError` - Базовое исключение
+- `AuthenticationError` - Ошибка аутентификации (401)
+- `AuthorizationError` - Ошибка авторизации (403)
+- `APIError` - Ошибка API (4xx, 5xx)
+- `TokenError` - Ошибка работы с токенами
+
+## Лицензия
+
+MIT
+
+

sso_nebus-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

sso_nebus-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

sso_nebus-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,11 @@
+MIT License
+
+Copyright (c) 2025 Артём
+
+Данный код лицензируется на условиях MIT License. См. полный текст лицензии ниже.
+
+Разрешается использование, копирование, изменение, слияние, публикация, распространение, сублицензирование и/или продажа копий данного программного обеспечения, а также разрешение лицам, которым предоставляется данный программный продукт, делать это при соблюдении следующих условий:
+
+Уведомление об авторских правах и данном разрешении должны быть включены во все копии или значительные части данного программного обеспечения.
+
+Данный программный продукт предоставляется "как есть", без каких-либо гарантий, явных или подразумеваемых, включая, помимо прочего, гарантии товарной пригодности и пригодности для определенной цели. В любом случае автор(ы) или держатель авторских прав не несут ответственности за любые претензии, убытки или другие обязательства, будь то в действии контракта, деликте или других обстоятельствах, возникающие из или в связи с использованием данного программного обеспечения.