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

miso_client/utils/data_masker.py

@@ -10,9 +10,9 @@ from typing import Any, Set
 
 class DataMasker:
     """Static class for masking sensitive data."""
-    
+
     MASKED_VALUE = "***MASKED***"
-    
+
     # Set of sensitive field names (normalized)
     _sensitive_fields: Set[str] = {
         "password",
@@ -37,58 +37,58 @@ class DataMasker:
         "privatekey",
         "secretkey",
     }
-    
+
     @classmethod
     def is_sensitive_field(cls, key: str) -> bool:
         """
         Check if a field name indicates sensitive data.
-        
+
         Args:
             key: Field name to check
-            
+
         Returns:
             True if field is sensitive, False otherwise
         """
         # Normalize key: lowercase and remove underscores/hyphens
         normalized_key = key.lower().replace("_", "").replace("-", "")
-        
+
         # Check exact match
         if normalized_key in cls._sensitive_fields:
             return True
-        
+
         # Check if field contains sensitive keywords
         for sensitive_field in cls._sensitive_fields:
             if sensitive_field in normalized_key:
                 return True
-        
+
         return False
-    
+
     @classmethod
     def mask_sensitive_data(cls, data: Any) -> Any:
         """
         Mask sensitive data in objects, arrays, or primitives.
-        
+
         Returns a masked copy without modifying the original.
         Recursively processes nested objects and arrays.
-        
+
         Args:
             data: Data to mask (dict, list, or primitive)
-            
+
         Returns:
             Masked copy of the data
         """
         # Handle null and undefined
         if data is None:
             return data
-        
+
         # Handle primitives (string, number, boolean)
         if not isinstance(data, (dict, list)):
             return data
-        
+
         # Handle arrays
         if isinstance(data, list):
             return [cls.mask_sensitive_data(item) for item in data]
-        
+
         # Handle objects/dicts
         masked: dict[str, Any] = {}
         for key, value in data.items():
@@ -101,49 +101,49 @@ class DataMasker:
             else:
                 # Keep non-sensitive value as-is
                 masked[key] = value
-        
+
         return masked
-    
+
     @classmethod
     def mask_value(cls, value: str, show_first: int = 0, show_last: int = 0) -> str:
         """
         Mask specific value (useful for masking individual strings).
-        
+
         Args:
             value: String value to mask
             show_first: Number of characters to show at the start
             show_last: Number of characters to show at the end
-            
+
         Returns:
             Masked string value
         """
         if not value or len(value) <= show_first + show_last:
             return cls.MASKED_VALUE
-        
+
         first = value[:show_first] if show_first > 0 else ""
         last = value[-show_last:] if show_last > 0 else ""
         masked_length = max(8, len(value) - show_first - show_last)
         masked = "*" * masked_length
-        
+
         return f"{first}{masked}{last}"
-    
+
     @classmethod
     def contains_sensitive_data(cls, data: Any) -> bool:
         """
         Check if data contains sensitive information.
-        
+
         Args:
             data: Data to check
-            
+
         Returns:
             True if data contains sensitive fields, False otherwise
         """
         if data is None or not isinstance(data, (dict, list)):
             return False
-        
+
         if isinstance(data, list):
             return any(cls.contains_sensitive_data(item) for item in data)
-        
+
         # Check object keys
         for key, value in data.items():
             if cls.is_sensitive_field(key):
@@ -151,6 +151,5 @@ class DataMasker:
             if isinstance(value, (dict, list)):
                 if cls.contains_sensitive_data(value):
                     return True
-        
-        return False
 
+        return False

miso_client/utils/http_client.py

@@ -6,21 +6,23 @@ with the Miso Controller, including automatic client token management,
 retry logic, and error handling.
 """
 
-import httpx
 import asyncio
 from datetime import datetime, timedelta
-from typing import Any, Dict, Optional, Literal
-from ..models.config import MisoClientConfig, ClientTokenResponse
-from ..errors import MisoClientError, AuthenticationError, ConnectionError
+from typing import Any, Dict, Literal, Optional
+
+import httpx
+
+from ..errors import AuthenticationError, ConnectionError, MisoClientError
+from ..models.config import ClientTokenResponse, MisoClientConfig
 
 
 class HttpClient:
     """HTTP client for Miso Controller communication with automatic client token management."""
-    
+
     def __init__(self, config: MisoClientConfig):
         """
         Initialize HTTP client with configuration.
-        
+
         Args:
             config: MisoClient configuration
         """
@@ -29,7 +31,7 @@ class HttpClient:
         self.client_token: Optional[str] = None
         self.token_expires_at: Optional[datetime] = None
         self.token_refresh_lock = asyncio.Lock()
-        
+
     async def _initialize_client(self):
         """Initialize HTTP client if not already initialized."""
         if self.client is None:
@@ -38,59 +40,59 @@ class HttpClient:
                 timeout=30.0,
                 headers={
                     "Content-Type": "application/json",
-                }
+                },
             )
-    
+
     async def _get_client_token(self) -> str:
         """
         Get client token, fetching if needed.
-        
+
         Proactively refreshes if token will expire within 60 seconds.
-        
+
         Returns:
             Client token string
-            
+
         Raises:
             AuthenticationError: If token fetch fails
         """
         await self._initialize_client()
-        
+
         now = datetime.now()
-        
+
         # If token exists and not expired (with 60s buffer for proactive refresh), return it
         if (
-            self.client_token and 
-            self.token_expires_at and 
-            self.token_expires_at > now + timedelta(seconds=60)
+            self.client_token
+            and self.token_expires_at
+            and self.token_expires_at > now + timedelta(seconds=60)
         ):
             assert self.client_token is not None
             return self.client_token
-        
+
         # Acquire lock to prevent concurrent token fetches
         async with self.token_refresh_lock:
             # Double-check after acquiring lock
             if (
-                self.client_token and 
-                self.token_expires_at and 
-                self.token_expires_at > now + timedelta(seconds=60)
+                self.client_token
+                and self.token_expires_at
+                and self.token_expires_at > now + timedelta(seconds=60)
             ):
                 assert self.client_token is not None
                 return self.client_token
-            
+
             # Fetch new token
             await self._fetch_client_token()
             assert self.client_token is not None
             return self.client_token
-    
+
     async def _fetch_client_token(self) -> None:
         """
         Fetch client token from controller.
-        
+
         Raises:
             AuthenticationError: If token fetch fails
         """
         await self._initialize_client()
-        
+
         try:
             # Use a temporary client to avoid interceptor recursion
             temp_client = httpx.AsyncClient(
@@ -100,67 +102,67 @@ class HttpClient:
                     "Content-Type": "application/json",
                     "x-client-id": self.config.client_id,
                     "x-client-secret": self.config.client_secret,
-                }
+                },
             )
-            
+
             response = await temp_client.post("/api/auth/token")
             await temp_client.aclose()
-            
+
             if response.status_code != 200:
                 raise AuthenticationError(
                     f"Failed to get client token: HTTP {response.status_code}",
-                    status_code=response.status_code
+                    status_code=response.status_code,
                 )
-            
+
             data = response.json()
             token_response = ClientTokenResponse(**data)
-            
+
             if not token_response.success or not token_response.token:
                 raise AuthenticationError("Failed to get client token: Invalid response")
-            
+
             self.client_token = token_response.token
             # Set expiration with 30 second buffer before actual expiration
             expires_in = max(0, token_response.expiresIn - 30)
             self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
-            
+
         except httpx.HTTPError as e:
             raise ConnectionError(f"Failed to get client token: {str(e)}")
         except Exception as e:
             if isinstance(e, (AuthenticationError, ConnectionError)):
                 raise
             raise AuthenticationError(f"Failed to get client token: {str(e)}")
-    
+
     async def _ensure_client_token(self):
         """Ensure client token is set in headers."""
         token = await self._get_client_token()
         if self.client:
             self.client.headers["x-client-token"] = token
-    
+
     async def close(self):
         """Close the HTTP client."""
         if self.client:
             await self.client.aclose()
             self.client = None
-    
+
     async def __aenter__(self):
         """Async context manager entry."""
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
         await self.close()
-    
+
     async def get(self, url: str, **kwargs) -> Any:
         """
         Make GET request.
-        
+
         Args:
             url: Request URL
             **kwargs: Additional httpx request parameters
-            
+
         Returns:
             Response data (JSON parsed)
-            
+
         Raises:
             MisoClientError: If request fails
         """
@@ -169,35 +171,37 @@ class HttpClient:
         try:
             assert self.client is not None
             response = await self.client.get(url, **kwargs)
-            
+
             # Handle 401 - clear token to force refresh
             if response.status_code == 401:
                 self.client_token = None
                 self.token_expires_at = None
-            
+
             response.raise_for_status()
             return response.json()
         except httpx.HTTPStatusError as e:
             raise MisoClientError(
                 f"HTTP {e.response.status_code}: {e.response.text}",
                 status_code=e.response.status_code,
-                error_body=e.response.json() if e.response.headers.get("content-type", "").startswith("application/json") else {}
+                error_body=e.response.json()
+                if e.response.headers.get("content-type", "").startswith("application/json")
+                else {},
             )
         except httpx.RequestError as e:
             raise ConnectionError(f"Request failed: {str(e)}")
-    
+
     async def post(self, url: str, data: Optional[Dict[str, Any]] = None, **kwargs) -> Any:
         """
         Make POST request.
-        
+
         Args:
             url: Request URL
             data: Request data (will be JSON encoded)
             **kwargs: Additional httpx request parameters
-            
+
         Returns:
             Response data (JSON parsed)
-            
+
         Raises:
             MisoClientError: If request fails
         """
@@ -206,34 +210,36 @@ class HttpClient:
         try:
             assert self.client is not None
             response = await self.client.post(url, json=data, **kwargs)
-            
+
             if response.status_code == 401:
                 self.client_token = None
                 self.token_expires_at = None
-            
+
             response.raise_for_status()
             return response.json()
         except httpx.HTTPStatusError as e:
             raise MisoClientError(
                 f"HTTP {e.response.status_code}: {e.response.text}",
                 status_code=e.response.status_code,
-                error_body=e.response.json() if e.response.headers.get("content-type", "").startswith("application/json") else {}
+                error_body=e.response.json()
+                if e.response.headers.get("content-type", "").startswith("application/json")
+                else {},
             )
         except httpx.RequestError as e:
             raise ConnectionError(f"Request failed: {str(e)}")
-    
+
     async def put(self, url: str, data: Optional[Dict[str, Any]] = None, **kwargs) -> Any:
         """
         Make PUT request.
-        
+
         Args:
             url: Request URL
             data: Request data (will be JSON encoded)
             **kwargs: Additional httpx request parameters
-            
+
         Returns:
             Response data (JSON parsed)
-            
+
         Raises:
             MisoClientError: If request fails
         """
@@ -242,33 +248,35 @@ class HttpClient:
         try:
             assert self.client is not None
             response = await self.client.put(url, json=data, **kwargs)
-            
+
             if response.status_code == 401:
                 self.client_token = None
                 self.token_expires_at = None
-            
+
             response.raise_for_status()
             return response.json()
         except httpx.HTTPStatusError as e:
             raise MisoClientError(
                 f"HTTP {e.response.status_code}: {e.response.text}",
                 status_code=e.response.status_code,
-                error_body=e.response.json() if e.response.headers.get("content-type", "").startswith("application/json") else {}
+                error_body=e.response.json()
+                if e.response.headers.get("content-type", "").startswith("application/json")
+                else {},
             )
         except httpx.RequestError as e:
             raise ConnectionError(f"Request failed: {str(e)}")
-    
+
     async def delete(self, url: str, **kwargs) -> Any:
         """
         Make DELETE request.
-        
+
         Args:
             url: Request URL
             **kwargs: Additional httpx request parameters
-            
+
         Returns:
             Response data (JSON parsed)
-            
+
         Raises:
             MisoClientError: If request fails
         """
@@ -277,41 +285,43 @@ class HttpClient:
         try:
             assert self.client is not None
             response = await self.client.delete(url, **kwargs)
-            
+
             if response.status_code == 401:
                 self.client_token = None
                 self.token_expires_at = None
-            
+
             response.raise_for_status()
             return response.json()
         except httpx.HTTPStatusError as e:
             raise MisoClientError(
                 f"HTTP {e.response.status_code}: {e.response.text}",
                 status_code=e.response.status_code,
-                error_body=e.response.json() if e.response.headers.get("content-type", "").startswith("application/json") else {}
+                error_body=e.response.json()
+                if e.response.headers.get("content-type", "").startswith("application/json")
+                else {},
             )
         except httpx.RequestError as e:
             raise ConnectionError(f"Request failed: {str(e)}")
-    
+
     async def request(
         self,
         method: Literal["GET", "POST", "PUT", "DELETE"],
         url: str,
         data: Optional[Dict[str, Any]] = None,
-        **kwargs
+        **kwargs,
     ) -> Any:
         """
         Generic request method.
-        
+
         Args:
             method: HTTP method
             url: Request URL
             data: Request data (for POST/PUT)
             **kwargs: Additional httpx request parameters
-            
+
         Returns:
             Response data (JSON parsed)
-            
+
         Raises:
             MisoClientError: If request fails
         """
@@ -326,51 +336,51 @@ class HttpClient:
             return await self.delete(url, **kwargs)
         else:
             raise ValueError(f"Unsupported HTTP method: {method}")
-    
+
     async def authenticated_request(
         self,
         method: Literal["GET", "POST", "PUT", "DELETE"],
         url: str,
         token: str,
         data: Optional[Dict[str, Any]] = None,
-        **kwargs
+        **kwargs,
     ) -> Any:
         """
         Make authenticated request with Bearer token.
-        
+
         IMPORTANT: Client token is sent as x-client-token header (via _ensure_client_token)
         User token is sent as Authorization: Bearer header (this method parameter)
         These are two separate tokens for different purposes.
-        
+
         Args:
             method: HTTP method
             url: Request URL
             token: User authentication token (sent as Bearer token)
             data: Request data (for POST/PUT)
             **kwargs: Additional httpx request parameters
-            
+
         Returns:
             Response data (JSON parsed)
-            
+
         Raises:
             MisoClientError: If request fails
         """
         await self._ensure_client_token()
-        
+
         # Add Bearer token for user authentication
         # x-client-token is automatically added by _ensure_client_token
         headers = kwargs.get("headers", {})
         headers["Authorization"] = f"Bearer {token}"
         kwargs["headers"] = headers
-        
+
         return await self.request(method, url, data, **kwargs)
-    
+
     async def get_environment_token(self) -> str:
         """
         Get environment token using client credentials.
-        
+
         This is called automatically by HttpClient but can be called manually.
-        
+
         Returns:
             Client token string
         """

miso_client/utils/jwt_tools.py

@@ -5,21 +5,22 @@ This module provides utilities for extracting information from JWT tokens
 without verification, used for cache optimization and context extraction.
 """
 
+from typing import Any, Dict, Optional, cast
+
 import jwt
-from typing import Optional, Dict, Any, cast
 
 
 def decode_token(token: str) -> Optional[Dict[str, Any]]:
     """
     Safely decode JWT token without verification.
-    
+
     This is used for extracting user information (like userId) from tokens
     for cache optimization. The token is NOT verified - it should only be
     used for cache key generation, not for authentication decisions.
-    
+
     Args:
         token: JWT token string
-        
+
     Returns:
         Decoded token payload as dictionary, or None if decoding fails
     """
@@ -35,44 +36,40 @@ def decode_token(token: str) -> Optional[Dict[str, Any]]:
 def extract_user_id(token: str) -> Optional[str]:
     """
     Extract user ID from JWT token.
-    
+
     Tries common JWT claim fields: sub, userId, user_id, id
-    
+
     Args:
         token: JWT token string
-        
+
     Returns:
         User ID string if found, None otherwise
     """
     decoded = decode_token(token)
     if not decoded:
         return None
-    
+
     # Try common JWT claim fields for user ID
     user_id = (
-        decoded.get("sub") or
-        decoded.get("userId") or
-        decoded.get("user_id") or
-        decoded.get("id")
+        decoded.get("sub") or decoded.get("userId") or decoded.get("user_id") or decoded.get("id")
     )
-    
+
     return str(user_id) if user_id else None
 
 
 def extract_session_id(token: str) -> Optional[str]:
     """
     Extract session ID from JWT token.
-    
+
     Args:
         token: JWT token string
-        
+
     Returns:
         Session ID string if found, None otherwise
     """
     decoded = decode_token(token)
     if not decoded:
         return None
-    
+
     value = decoded.get("sid") or decoded.get("sessionId")
     return value if isinstance(value, str) else None
-