miso-client 0.1.0__py3-none-any.whl → 3.7.2__py3-none-any.whl

miso_client/api/__init__.py

@@ -0,0 +1,35 @@
+"""
+Centralized API layer with typed interfaces.
+
+Provides typed interfaces for all controller API calls, organized by domain.
+"""
+
+from ..utils.http_client import HttpClient
+from .auth_api import AuthApi
+from .logs_api import LogsApi
+from .permissions_api import PermissionsApi
+from .roles_api import RolesApi
+
+
+class ApiClient:
+    """
+    Centralized API client for Miso Controller communication.
+
+    Wraps HttpClient and provides typed interfaces organized by domain.
+    """
+
+    def __init__(self, http_client: HttpClient):
+        """
+        Initialize API client.
+
+        Args:
+            http_client: HttpClient instance
+        """
+        self.http_client = http_client
+        self.auth = AuthApi(http_client)
+        self.roles = RolesApi(http_client)
+        self.permissions = PermissionsApi(http_client)
+        self.logs = LogsApi(http_client)
+
+
+__all__ = ["ApiClient", "AuthApi", "RolesApi", "PermissionsApi", "LogsApi"]

miso_client/api/auth_api.py

@@ -0,0 +1,367 @@
+"""
+Auth API implementation.
+
+Provides typed interfaces for authentication endpoints.
+"""
+
+from typing import Optional
+
+from ..models.config import AuthStrategy
+from ..utils.http_client import HttpClient
+from .types.auth_types import (
+    DeviceCodeRequest,
+    DeviceCodeResponseWrapper,
+    DeviceCodeTokenPollRequest,
+    DeviceCodeTokenPollResponse,
+    DeviceCodeTokenResponse,
+    GetPermissionsResponse,
+    GetRolesResponse,
+    GetUserResponse,
+    LoginResponse,
+    LogoutResponse,
+    RefreshPermissionsResponse,
+    RefreshRolesResponse,
+    RefreshTokenRequest,
+    RefreshTokenResponse,
+    ValidateTokenRequest,
+    ValidateTokenResponse,
+)
+
+
+class AuthApi:
+    """Auth API client for authentication endpoints."""
+
+    # Endpoint constants
+    LOGIN_ENDPOINT = "/api/v1/auth/login"
+    VALIDATE_ENDPOINT = "/api/v1/auth/validate"
+    USER_ENDPOINT = "/api/v1/auth/user"
+    LOGOUT_ENDPOINT = "/api/v1/auth/logout"
+    REFRESH_ENDPOINT = "/api/v1/auth/refresh"
+    DEVICE_CODE_ENDPOINT = "/api/v1/auth/login"
+    DEVICE_CODE_TOKEN_ENDPOINT = "/api/v1/auth/login/device/token"
+    DEVICE_CODE_REFRESH_ENDPOINT = "/api/v1/auth/login/device/refresh"
+    ROLES_ENDPOINT = "/api/v1/auth/roles"
+    ROLES_REFRESH_ENDPOINT = "/api/v1/auth/roles/refresh"
+    PERMISSIONS_ENDPOINT = "/api/v1/auth/permissions"
+    PERMISSIONS_REFRESH_ENDPOINT = "/api/v1/auth/permissions/refresh"
+
+    def __init__(self, http_client: HttpClient):
+        """
+        Initialize Auth API client.
+
+        Args:
+            http_client: HttpClient instance
+        """
+        self.http_client = http_client
+
+    async def login(self, redirect: str, state: Optional[str] = None) -> LoginResponse:
+        """
+        Initiate login flow (GET with query params).
+
+        Args:
+            redirect: Redirect URI for OAuth2 callback
+            state: Optional state parameter for CSRF protection
+
+        Returns:
+            LoginResponse with login URL
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        params = {"redirect": redirect}
+        if state:
+            params["state"] = state
+
+        response = await self.http_client.get(self.LOGIN_ENDPOINT, params=params)
+        return LoginResponse(**response)
+
+    async def validate_token(
+        self,
+        token: str,
+        environment: Optional[str] = None,
+        application: Optional[str] = None,
+        auth_strategy: Optional[AuthStrategy] = None,
+    ) -> ValidateTokenResponse:
+        """
+        Validate authentication token (POST).
+
+        Uses authenticated_request to send the token as Bearer token for authentication,
+        while also including it in the request body for validation.
+
+        Args:
+            token: JWT token to validate
+            environment: Optional environment key
+            application: Optional application key
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            ValidateTokenResponse with validation result
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        request_data = ValidateTokenRequest(
+            token=token, environment=environment, application=application
+        )
+        response = await self.http_client.authenticated_request(
+            "POST",
+            self.VALIDATE_ENDPOINT,
+            token,
+            data=request_data.model_dump(exclude_none=True),
+            auth_strategy=auth_strategy,
+        )
+        return ValidateTokenResponse(**response)
+
+    async def get_user(
+        self, token: Optional[str] = None, auth_strategy: Optional[AuthStrategy] = None
+    ) -> GetUserResponse:
+        """
+        Get current user information (GET).
+
+        Token is optional - can use x-client-token header instead.
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            GetUserResponse with user information
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.USER_ENDPOINT, token, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.USER_ENDPOINT)
+        return GetUserResponse(**response)
+
+    async def logout(self, token: Optional[str] = None) -> LogoutResponse:
+        """
+        Logout user (POST).
+
+        If token is provided, sends it in the request body for server-side invalidation.
+        Otherwise, uses client credentials authentication.
+
+        Args:
+            token: Optional user token to invalidate (sent in request body if provided)
+
+        Returns:
+            LogoutResponse with logout message
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        if token:
+            # Send token in body for server-side invalidation
+            response = await self.http_client.authenticated_request(
+                "POST", self.LOGOUT_ENDPOINT, token, data={"token": token}
+            )
+        else:
+            # Use client credentials (no user token)
+            response = await self.http_client.post(self.LOGOUT_ENDPOINT)
+        return LogoutResponse(**response)
+
+    async def refresh_token(self, refresh_token: str) -> RefreshTokenResponse:
+        """
+        Refresh user access token (POST).
+
+        Args:
+            refresh_token: Refresh token
+
+        Returns:
+            RefreshTokenResponse with new tokens
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        request_data = RefreshTokenRequest(refreshToken=refresh_token)
+        response = await self.http_client.post(
+            self.REFRESH_ENDPOINT, data=request_data.model_dump()
+        )
+        return RefreshTokenResponse(**response)
+
+    async def initiate_device_code(
+        self, environment: Optional[str] = None, scope: Optional[str] = None
+    ) -> DeviceCodeResponseWrapper:
+        """
+        Initiate device code flow (POST).
+
+        Args:
+            environment: Optional environment key
+            scope: Optional OAuth2 scope string
+
+        Returns:
+            DeviceCodeResponseWrapper with device code information
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        request_data = DeviceCodeRequest(environment=environment, scope=scope)
+        response = await self.http_client.post(
+            self.DEVICE_CODE_ENDPOINT, data=request_data.model_dump(exclude_none=True)
+        )
+        return DeviceCodeResponseWrapper(**response)
+
+    async def poll_device_code_token(self, device_code: str) -> DeviceCodeTokenPollResponse:
+        """
+        Poll for device code token (POST).
+
+        Returns 202 while authorization is pending.
+
+        Args:
+            device_code: Device code from initiation
+
+        Returns:
+            DeviceCodeTokenPollResponse with token or pending status
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        request_data = DeviceCodeTokenPollRequest(deviceCode=device_code)
+        response = await self.http_client.post(
+            self.DEVICE_CODE_TOKEN_ENDPOINT, data=request_data.model_dump()
+        )
+        return DeviceCodeTokenPollResponse(**response)
+
+    async def refresh_device_code_token(self, refresh_token: str) -> DeviceCodeTokenResponse:
+        """
+        Refresh device code access token (POST).
+
+        Args:
+            refresh_token: Refresh token from device code flow
+
+        Returns:
+            DeviceCodeTokenResponse with new tokens
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        request_data = RefreshTokenRequest(refreshToken=refresh_token)
+        response = await self.http_client.post(
+            self.DEVICE_CODE_REFRESH_ENDPOINT, data=request_data.model_dump()
+        )
+        response_data = response.get("data", {})
+        return DeviceCodeTokenResponse(**response_data)
+
+    async def get_roles(
+        self,
+        token: Optional[str] = None,
+        environment: Optional[str] = None,
+        application: Optional[str] = None,
+        auth_strategy: Optional[AuthStrategy] = None,
+    ) -> GetRolesResponse:
+        """
+        Get user roles (GET).
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            environment: Optional environment key filter
+            application: Optional application key filter
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            GetRolesResponse with user roles
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        params = {}
+        if environment:
+            params["environment"] = environment
+        if application:
+            params["application"] = application
+
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.ROLES_ENDPOINT, token, params=params, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.ROLES_ENDPOINT, params=params)
+        return GetRolesResponse(**response)
+
+    async def refresh_roles(
+        self, token: Optional[str] = None, auth_strategy: Optional[AuthStrategy] = None
+    ) -> RefreshRolesResponse:
+        """
+        Refresh user roles (GET).
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            RefreshRolesResponse with refreshed roles
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.ROLES_REFRESH_ENDPOINT, token, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.ROLES_REFRESH_ENDPOINT)
+        return RefreshRolesResponse(**response)
+
+    async def get_permissions(
+        self,
+        token: Optional[str] = None,
+        environment: Optional[str] = None,
+        application: Optional[str] = None,
+        auth_strategy: Optional[AuthStrategy] = None,
+    ) -> GetPermissionsResponse:
+        """
+        Get user permissions (GET).
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            environment: Optional environment key filter
+            application: Optional application key filter
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            GetPermissionsResponse with user permissions
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        params = {}
+        if environment:
+            params["environment"] = environment
+        if application:
+            params["application"] = application
+
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.PERMISSIONS_ENDPOINT, token, params=params, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.PERMISSIONS_ENDPOINT, params=params)
+        return GetPermissionsResponse(**response)
+
+    async def refresh_permissions(
+        self, token: Optional[str] = None, auth_strategy: Optional[AuthStrategy] = None
+    ) -> RefreshPermissionsResponse:
+        """
+        Refresh user permissions (GET).
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            RefreshPermissionsResponse with refreshed permissions
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.PERMISSIONS_REFRESH_ENDPOINT, token, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.PERMISSIONS_REFRESH_ENDPOINT)
+        return RefreshPermissionsResponse(**response)

miso_client/api/logs_api.py

@@ -0,0 +1,91 @@
+"""
+Logs API implementation.
+
+Provides typed interfaces for logging endpoints.
+"""
+
+from typing import Optional
+
+from ..models.config import LogEntry
+from ..utils.http_client import HttpClient
+from .types.logs_types import BatchLogRequest, BatchLogResponse, LogRequest, LogResponse
+
+
+class LogsApi:
+    """Logs API client for logging endpoints."""
+
+    # Endpoint constants
+    LOGS_ENDPOINT = "/api/v1/logs"
+    LOGS_BATCH_ENDPOINT = "/api/v1/logs/batch"
+
+    def __init__(self, http_client: HttpClient):
+        """
+        Initialize Logs API client.
+
+        Args:
+            http_client: HttpClient instance
+        """
+        self.http_client = http_client
+
+    async def send_log(self, log_entry: LogRequest, token: Optional[str] = None) -> LogResponse:
+        """
+        Send log entry (POST).
+
+        Supports Bearer token, x-client-token, or client credentials authentication.
+        If token is provided, uses authenticated_request. Otherwise uses client credentials (automatic).
+
+        Args:
+            log_entry: LogRequest with type and data
+            token: Optional user token (if not provided, uses x-client-token/client credentials)
+
+        Returns:
+            LogResponse with success status
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        if token:
+            response = await self.http_client.authenticated_request(
+                "POST",
+                self.LOGS_ENDPOINT,
+                token,
+                data=log_entry.model_dump(exclude_none=True),
+            )
+        else:
+            response = await self.http_client.post(
+                self.LOGS_ENDPOINT, data=log_entry.model_dump(exclude_none=True)
+            )
+        return LogResponse(**response)
+
+    async def send_batch_logs(
+        self, logs: list[LogEntry], token: Optional[str] = None
+    ) -> BatchLogResponse:
+        """
+        Send multiple log entries in batch (POST).
+
+        Supports Bearer token, x-client-token, or client credentials authentication.
+        If token is provided, uses authenticated_request. Otherwise uses client credentials (automatic).
+
+        Args:
+            logs: List of LogEntry objects
+            token: Optional user token (if not provided, uses x-client-token/client credentials)
+
+        Returns:
+            BatchLogResponse with processing results
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        request_data = BatchLogRequest(logs=logs)
+        if token:
+            response = await self.http_client.authenticated_request(
+                "POST",
+                self.LOGS_BATCH_ENDPOINT,
+                token,
+                data=request_data.model_dump(exclude_none=True),
+            )
+        else:
+            response = await self.http_client.post(
+                self.LOGS_BATCH_ENDPOINT, data=request_data.model_dump(exclude_none=True)
+            )
+        return BatchLogResponse(**response)

miso_client/api/permissions_api.py

@@ -0,0 +1,88 @@
+"""
+Permissions API implementation.
+
+Provides typed interfaces for permissions endpoints.
+"""
+
+from typing import Optional
+
+from ..models.config import AuthStrategy
+from ..utils.http_client import HttpClient
+from .types.permissions_types import GetPermissionsResponse, RefreshPermissionsResponse
+
+
+class PermissionsApi:
+    """Permissions API client for permission endpoints."""
+
+    # Endpoint constants
+    PERMISSIONS_ENDPOINT = "/api/v1/auth/permissions"
+    PERMISSIONS_REFRESH_ENDPOINT = "/api/v1/auth/permissions/refresh"
+
+    def __init__(self, http_client: HttpClient):
+        """
+        Initialize Permissions API client.
+
+        Args:
+            http_client: HttpClient instance
+        """
+        self.http_client = http_client
+
+    async def get_permissions(
+        self,
+        token: Optional[str] = None,
+        environment: Optional[str] = None,
+        application: Optional[str] = None,
+        auth_strategy: Optional[AuthStrategy] = None,
+    ) -> GetPermissionsResponse:
+        """
+        Get user permissions (GET).
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            environment: Optional environment key filter
+            application: Optional application key filter
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            GetPermissionsResponse with user permissions
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        params = {}
+        if environment:
+            params["environment"] = environment
+        if application:
+            params["application"] = application
+
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.PERMISSIONS_ENDPOINT, token, params=params, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.PERMISSIONS_ENDPOINT, params=params)
+        return GetPermissionsResponse(**response)
+
+    async def refresh_permissions(
+        self, token: Optional[str] = None, auth_strategy: Optional[AuthStrategy] = None
+    ) -> RefreshPermissionsResponse:
+        """
+        Refresh user permissions (GET).
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            RefreshPermissionsResponse with refreshed permissions
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.PERMISSIONS_REFRESH_ENDPOINT, token, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.PERMISSIONS_REFRESH_ENDPOINT)
+        return RefreshPermissionsResponse(**response)

miso_client/api/roles_api.py

@@ -0,0 +1,88 @@
+"""
+Roles API implementation.
+
+Provides typed interfaces for roles endpoints.
+"""
+
+from typing import Optional
+
+from ..models.config import AuthStrategy
+from ..utils.http_client import HttpClient
+from .types.roles_types import GetRolesResponse, RefreshRolesResponse
+
+
+class RolesApi:
+    """Roles API client for role endpoints."""
+
+    # Endpoint constants
+    ROLES_ENDPOINT = "/api/v1/auth/roles"
+    ROLES_REFRESH_ENDPOINT = "/api/v1/auth/roles/refresh"
+
+    def __init__(self, http_client: HttpClient):
+        """
+        Initialize Roles API client.
+
+        Args:
+            http_client: HttpClient instance
+        """
+        self.http_client = http_client
+
+    async def get_roles(
+        self,
+        token: Optional[str] = None,
+        environment: Optional[str] = None,
+        application: Optional[str] = None,
+        auth_strategy: Optional[AuthStrategy] = None,
+    ) -> GetRolesResponse:
+        """
+        Get user roles (GET).
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            environment: Optional environment key filter
+            application: Optional application key filter
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            GetRolesResponse with user roles
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        params = {}
+        if environment:
+            params["environment"] = environment
+        if application:
+            params["application"] = application
+
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.ROLES_ENDPOINT, token, params=params, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.ROLES_ENDPOINT, params=params)
+        return GetRolesResponse(**response)
+
+    async def refresh_roles(
+        self, token: Optional[str] = None, auth_strategy: Optional[AuthStrategy] = None
+    ) -> RefreshRolesResponse:
+        """
+        Refresh user roles (GET).
+
+        Args:
+            token: Optional user token (if not provided, uses x-client-token)
+            auth_strategy: Optional authentication strategy
+
+        Returns:
+            RefreshRolesResponse with refreshed roles
+
+        Raises:
+            MisoClientError: If request fails
+        """
+        if token:
+            response = await self.http_client.authenticated_request(
+                "GET", self.ROLES_REFRESH_ENDPOINT, token, auth_strategy=auth_strategy
+            )
+        else:
+            response = await self.http_client.get(self.ROLES_REFRESH_ENDPOINT)
+        return RefreshRolesResponse(**response)