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

miso_client/services/permission.py

@@ -8,6 +8,7 @@ Optimized to extract userId from JWT token before API calls for cache optimizati
 
 import time
 from typing import List, cast
+
 from ..models.config import PermissionResult
 from ..services.cache import CacheService
 from ..utils.http_client import HttpClient
@@ -16,11 +17,11 @@ from ..utils.jwt_tools import extract_user_id
 
 class PermissionService:
     """Permission service for user authorization with caching."""
-    
+
     def __init__(self, http_client: HttpClient, cache: CacheService):
         """
         Initialize permission service.
-        
+
         Args:
             http_client: HTTP client instance
             cache: Cache service instance (handles Redis + in-memory fallback)
@@ -33,12 +34,12 @@ class PermissionService:
     async def get_permissions(self, token: str) -> List[str]:
         """
         Get user permissions with Redis caching.
-        
+
         Optimized to extract userId from token first to check cache before API call.
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             List of user permissions
         """
@@ -57,9 +58,7 @@ class PermissionService:
             # If we don't have userId, get it from validate endpoint
             if not user_id:
                 user_info = await self.http_client.authenticated_request(
-                    "POST",
-                    "/api/auth/validate",
-                    token
+                    "POST", "/api/auth/validate", token
                 )
                 user_id = user_info.get("user", {}).get("id") if user_info else None
                 if not user_id:
@@ -68,9 +67,7 @@ class PermissionService:
 
             # Cache miss - fetch from controller
             permission_result = await self.http_client.authenticated_request(
-                "GET",
-                "/api/auth/permissions",  # Backend knows app/env from client token
-                token
+                "GET", "/api/auth/permissions", token  # Backend knows app/env from client token
             )
 
             permission_data = PermissionResult(**permission_result)
@@ -81,11 +78,11 @@ class PermissionService:
             await self.cache.set(
                 cache_key,
                 {"permissions": permissions, "timestamp": int(time.time() * 1000)},
-                self.permission_ttl
+                self.permission_ttl,
             )
 
             return permissions
-            
+
         except Exception:
             # Failed to get permissions, return empty list
             return []
@@ -93,11 +90,11 @@ class PermissionService:
     async def has_permission(self, token: str, permission: str) -> bool:
         """
         Check if user has specific permission.
-        
+
         Args:
             token: JWT token
             permission: Permission to check
-            
+
         Returns:
             True if user has the permission, False otherwise
         """
@@ -107,11 +104,11 @@ class PermissionService:
     async def has_any_permission(self, token: str, permissions: List[str]) -> bool:
         """
         Check if user has any of the specified permissions.
-        
+
         Args:
             token: JWT token
             permissions: List of permissions to check
-            
+
         Returns:
             True if user has any of the permissions, False otherwise
         """
@@ -121,11 +118,11 @@ class PermissionService:
     async def has_all_permissions(self, token: str, permissions: List[str]) -> bool:
         """
         Check if user has all of the specified permissions.
-        
+
         Args:
             token: JWT token
             permissions: List of permissions to check
-            
+
         Returns:
             True if user has all permissions, False otherwise
         """
@@ -135,21 +132,19 @@ class PermissionService:
     async def refresh_permissions(self, token: str) -> List[str]:
         """
         Force refresh permissions from controller (bypass cache).
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             Fresh list of user permissions
         """
         try:
             # Get user info to extract userId
             user_info = await self.http_client.authenticated_request(
-                "POST",
-                "/api/auth/validate",
-                token
+                "POST", "/api/auth/validate", token
             )
-            
+
             user_id = user_info.get("user", {}).get("id") if user_info else None
             if not user_id:
                 return []
@@ -158,9 +153,7 @@ class PermissionService:
 
             # Fetch fresh permissions from controller using refresh endpoint
             permission_result = await self.http_client.authenticated_request(
-                "GET",
-                "/api/auth/permissions/refresh",
-                token
+                "GET", "/api/auth/permissions/refresh", token
             )
 
             permission_data = PermissionResult(**permission_result)
@@ -170,11 +163,11 @@ class PermissionService:
             await self.cache.set(
                 cache_key,
                 {"permissions": permissions, "timestamp": int(time.time() * 1000)},
-                self.permission_ttl
+                self.permission_ttl,
             )
 
             return permissions
-            
+
         except Exception:
             # Failed to refresh permissions, return empty list
             return []
@@ -182,18 +175,16 @@ class PermissionService:
     async def clear_permissions_cache(self, token: str) -> None:
         """
         Clear cached permissions for a user.
-        
+
         Args:
             token: JWT token
         """
         try:
             # Get user info to extract userId
             user_info = await self.http_client.authenticated_request(
-                "POST",
-                "/api/auth/validate",
-                token
+                "POST", "/api/auth/validate", token
             )
-            
+
             user_id = user_info.get("user", {}).get("id") if user_info else None
             if not user_id:
                 return
@@ -202,7 +193,7 @@ class PermissionService:
 
             # Clear from cache (CacheService handles Redis + in-memory automatically)
             await self.cache.delete(cache_key)
-                
+
         except Exception:
             # Failed to clear cache, silently continue
             pass

miso_client/services/redis.py

@@ -5,18 +5,20 @@ This module provides Redis connectivity with graceful degradation when Redis
 is unavailable. It handles caching of roles and permissions, and log queuing.
 """
 
-import redis.asyncio as redis
 from typing import Optional
+
+import redis.asyncio as redis
+
 from ..models.config import RedisConfig
 
 
 class RedisService:
     """Redis service for caching and log queuing."""
-    
+
     def __init__(self, config: Optional[RedisConfig] = None):
         """
         Initialize Redis service.
-        
+
         Args:
             config: Optional Redis configuration
         """
@@ -27,7 +29,7 @@ class RedisService:
     async def connect(self) -> None:
         """
         Connect to Redis.
-        
+
         Raises:
             Exception: If connection fails and config is provided
         """
@@ -46,7 +48,7 @@ class RedisService:
                 socket_connect_timeout=5,
                 socket_timeout=5,
             )
-            
+
             # Test connection
             # Some redis stubs type ping as possibly non-awaitable; support both
             resp = self.redis.ping()
@@ -54,7 +56,7 @@ class RedisService:
                 await resp  # type: ignore[misc]
             self.connected = True
             print("Connected to Redis")
-            
+
         except Exception as error:
             print(f"Failed to connect to Redis: {error}")
             self.connected = False
@@ -71,7 +73,7 @@ class RedisService:
     def is_connected(self) -> bool:
         """
         Check if Redis is connected.
-        
+
         Returns:
             True if connected, False otherwise
         """
@@ -80,10 +82,10 @@ class RedisService:
     async def get(self, key: str) -> Optional[str]:
         """
         Get value from Redis.
-        
+
         Args:
             key: Redis key
-            
+
         Returns:
             Value if found, None otherwise
         """
@@ -106,12 +108,12 @@ class RedisService:
     async def set(self, key: str, value: str, ttl: int) -> bool:
         """
         Set value in Redis with TTL.
-        
+
         Args:
             key: Redis key
             value: Value to store
             ttl: Time to live in seconds
-            
+
         Returns:
             True if successful, False otherwise
         """
@@ -132,10 +134,10 @@ class RedisService:
     async def delete(self, key: str) -> bool:
         """
         Delete key from Redis.
-        
+
         Args:
             key: Redis key
-            
+
         Returns:
             True if successful, False otherwise
         """
@@ -156,11 +158,11 @@ class RedisService:
     async def rpush(self, queue: str, value: str) -> bool:
         """
         Push value to Redis list (for log queuing).
-        
+
         Args:
             queue: Queue name
             value: Value to push
-            
+
         Returns:
             True if successful, False otherwise
         """

miso_client/services/role.py

@@ -8,6 +8,7 @@ Optimized to extract userId from JWT token before API calls for cache optimizati
 
 import time
 from typing import List, cast
+
 from ..models.config import RoleResult
 from ..services.cache import CacheService
 from ..utils.http_client import HttpClient
@@ -16,11 +17,11 @@ from ..utils.jwt_tools import extract_user_id
 
 class RoleService:
     """Role service for user authorization with caching."""
-    
+
     def __init__(self, http_client: HttpClient, cache: CacheService):
         """
         Initialize role service.
-        
+
         Args:
             http_client: HTTP client instance
             cache: Cache service instance (handles Redis + in-memory fallback)
@@ -33,12 +34,12 @@ class RoleService:
     async def get_roles(self, token: str) -> List[str]:
         """
         Get user roles with Redis caching.
-        
+
         Optimized to extract userId from token first to check cache before API call.
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             List of user roles
         """
@@ -57,9 +58,7 @@ class RoleService:
             # If we don't have userId, get it from validate endpoint
             if not user_id:
                 user_info = await self.http_client.authenticated_request(
-                    "POST",
-                    "/api/auth/validate",
-                    token
+                    "POST", "/api/auth/validate", token
                 )
                 user_id = user_info.get("user", {}).get("id") if user_info else None
                 if not user_id:
@@ -68,24 +67,20 @@ class RoleService:
 
             # Cache miss - fetch from controller
             role_result = await self.http_client.authenticated_request(
-                "GET",
-                "/api/auth/roles",  # Backend knows app/env from client token
-                token
+                "GET", "/api/auth/roles", token  # Backend knows app/env from client token
             )
-            
+
             role_data = RoleResult(**role_result)
             roles = role_data.roles or []
 
             # Cache the result (CacheService handles Redis + in-memory automatically)
             assert cache_key is not None
             await self.cache.set(
-                cache_key,
-                {"roles": roles, "timestamp": int(time.time() * 1000)},
-                self.role_ttl
+                cache_key, {"roles": roles, "timestamp": int(time.time() * 1000)}, self.role_ttl
             )
 
             return roles
-            
+
         except Exception:
             # Failed to get roles, return empty list
             return []
@@ -93,11 +88,11 @@ class RoleService:
     async def has_role(self, token: str, role: str) -> bool:
         """
         Check if user has specific role.
-        
+
         Args:
             token: JWT token
             role: Role to check
-            
+
         Returns:
             True if user has the role, False otherwise
         """
@@ -107,11 +102,11 @@ class RoleService:
     async def has_any_role(self, token: str, roles: List[str]) -> bool:
         """
         Check if user has any of the specified roles.
-        
+
         Args:
             token: JWT token
             roles: List of roles to check
-            
+
         Returns:
             True if user has any of the roles, False otherwise
         """
@@ -121,11 +116,11 @@ class RoleService:
     async def has_all_roles(self, token: str, roles: List[str]) -> bool:
         """
         Check if user has all of the specified roles.
-        
+
         Args:
             token: JWT token
             roles: List of roles to check
-            
+
         Returns:
             True if user has all roles, False otherwise
         """
@@ -135,21 +130,19 @@ class RoleService:
     async def refresh_roles(self, token: str) -> List[str]:
         """
         Force refresh roles from controller (bypass cache).
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             Fresh list of user roles
         """
         try:
             # Get user info to extract userId
             user_info = await self.http_client.authenticated_request(
-                "POST",
-                "/api/auth/validate",
-                token
+                "POST", "/api/auth/validate", token
             )
-            
+
             user_id = user_info.get("user", {}).get("id") if user_info else None
             if not user_id:
                 return []
@@ -158,23 +151,19 @@ class RoleService:
 
             # Fetch fresh roles from controller using refresh endpoint
             role_result = await self.http_client.authenticated_request(
-                "GET",
-                "/api/auth/roles/refresh",
-                token
+                "GET", "/api/auth/roles/refresh", token
             )
-            
+
             role_data = RoleResult(**role_result)
             roles = role_data.roles or []
 
             # Update cache with fresh data (CacheService handles Redis + in-memory automatically)
             await self.cache.set(
-                cache_key,
-                {"roles": roles, "timestamp": int(time.time() * 1000)},
-                self.role_ttl
+                cache_key, {"roles": roles, "timestamp": int(time.time() * 1000)}, self.role_ttl
             )
 
             return roles
-            
+
         except Exception:
             # Failed to refresh roles, return empty list
             return []

miso_client/utils/__init__.py

@@ -1,9 +1,9 @@
 """Utility modules for MisoClient SDK."""
 
-from .http_client import HttpClient
 from .config_loader import load_config
 from .data_masker import DataMasker
-from .jwt_tools import decode_token, extract_user_id, extract_session_id
+from .http_client import HttpClient
+from .jwt_tools import decode_token, extract_session_id, extract_user_id
 
 __all__ = [
     "HttpClient",
@@ -12,4 +12,4 @@ __all__ = [
     "decode_token",
     "extract_user_id",
     "extract_session_id",
-]
+]

miso_client/utils/config_loader.py

@@ -6,50 +6,55 @@ Automatically loads environment variables with sensible defaults.
 
 import os
 from typing import Literal, cast
-from ..models.config import MisoClientConfig, RedisConfig
+
 from ..errors import ConfigurationError
+from ..models.config import MisoClientConfig, RedisConfig
 
 
 def load_config() -> MisoClientConfig:
     """
     Load configuration from environment variables with defaults.
-    
+
     Required environment variables:
     - MISO_CONTROLLER_URL (or default to https://controller.aifabrix.ai)
     - MISO_CLIENTID or MISO_CLIENT_ID
     - MISO_CLIENTSECRET or MISO_CLIENT_SECRET
-    
+
     Optional environment variables:
     - MISO_LOG_LEVEL (debug, info, warn, error)
+    - API_KEY (for testing - bypasses OAuth2 authentication)
     - REDIS_HOST (if Redis is used)
     - REDIS_PORT (default: 6379)
     - REDIS_PASSWORD
     - REDIS_DB (default: 0)
     - REDIS_KEY_PREFIX (default: miso:)
-    
+
     Returns:
         MisoClientConfig instance
-        
+
     Raises:
         ConfigurationError: If required environment variables are missing
     """
     # Load dotenv if available (similar to TypeScript dotenv/config)
     try:
         from dotenv import load_dotenv
+
         load_dotenv()
     except ImportError:
         pass  # dotenv not installed, continue without it
-    
+
     controller_url = os.environ.get("MISO_CONTROLLER_URL") or "https://controller.aifabrix.ai"
-    
+
     client_id = os.environ.get("MISO_CLIENTID") or os.environ.get("MISO_CLIENT_ID") or ""
     if not client_id:
         raise ConfigurationError("MISO_CLIENTID environment variable is required")
-    
-    client_secret = os.environ.get("MISO_CLIENTSECRET") or os.environ.get("MISO_CLIENT_SECRET") or ""
+
+    client_secret = (
+        os.environ.get("MISO_CLIENTSECRET") or os.environ.get("MISO_CLIENT_SECRET") or ""
+    )
     if not client_secret:
         raise ConfigurationError("MISO_CLIENTSECRET environment variable is required")
-    
+
     log_level_str = os.environ.get("MISO_LOG_LEVEL", "info")
     if log_level_str not in ["debug", "info", "warn", "error"]:
         log_level_str = "info"
@@ -57,14 +62,18 @@ def load_config() -> MisoClientConfig:
     log_level: Literal["debug", "info", "warn", "error"] = cast(
         Literal["debug", "info", "warn", "error"], log_level_str
     )
-    
+
+    # Optional API_KEY for testing
+    api_key = os.environ.get("API_KEY")
+
     config: MisoClientConfig = MisoClientConfig(
         controller_url=controller_url,
         client_id=client_id,
         client_secret=client_secret,
         log_level=log_level,
+        api_key=api_key,
     )
-    
+
     # Optional Redis configuration
     redis_host = os.environ.get("REDIS_HOST")
     if redis_host:
@@ -72,7 +81,7 @@ def load_config() -> MisoClientConfig:
         redis_password = os.environ.get("REDIS_PASSWORD")
         redis_db = int(os.environ.get("REDIS_DB", "0")) if os.environ.get("REDIS_DB") else 0
         redis_key_prefix = os.environ.get("REDIS_KEY_PREFIX", "miso:")
-        
+
         redis_config = RedisConfig(
             host=redis_host,
             port=redis_port,
@@ -80,8 +89,7 @@ def load_config() -> MisoClientConfig:
             db=redis_db,
             key_prefix=redis_key_prefix,
         )
-        
+
         config.redis = redis_config
-    
-    return config
 
+    return config