contentstack-management 1.6.0__tar.gz → 1.7.0__tar.gz

{contentstack_management-1.6.0 → contentstack_management-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentstack-management
-Version: 1.6.0
+Version: 1.7.0
 Summary: Contentstack API Client Library for Python
 Home-page: https://github.com/contentstack/contentstack-management-python
 Author: dev-ex

{contentstack_management-1.6.0 → contentstack_management-1.7.0}/contentstack_management/__init__.py

@@ -34,6 +34,8 @@ from .publish_queue.publish_queue import PublishQueue
 from .extensions.extension import Extension
 from .variant_group.variant_group import VariantGroup
 from .variants.variants import Variants
+from .oauth.oauth_handler import OAuthHandler
+from .oauth.oauth_interceptor import OAuthInterceptor
 
 
 __all__ = (
@@ -71,14 +73,16 @@ __all__ = (
 "PublishQueue",
 "Extension",
 "VariantGroup",
-"Variants"
+"Variants",
+"OAuthHandler",
+"OAuthInterceptor"
 )
 
 __title__ = 'contentstack-management-python'
 __author__ = 'dev-ex'
 __status__ = 'debug'
 __region__ = 'na'
-__version__ = '1.6.0'
+__version__ = '1.7.0'
 __host__ = 'api.contentstack.io'
 __protocol__ = 'https://'
 __api_version__ = 'v3'

{contentstack_management-1.6.0 → contentstack_management-1.7.0}/contentstack_management/_api_client.py

@@ -2,7 +2,7 @@ import requests
 
 
 class _APIClient:
-    def __init__(self, endpoint, headers, timeout=30, max_retries: int = 5):
+    def __init__(self, endpoint, headers, timeout=30, max_retries: int = 5, oauth_interceptor=None):
         """
         The function is a constructor that initializes the endpoint, headers, timeout, and max_retries
         attributes of an object.
@@ -25,6 +25,8 @@ class _APIClient:
         self.headers = headers
         self.timeout = timeout
         self.max_retries = max_retries
+        self.oauth_interceptor = oauth_interceptor
+        self.oauth = {}  # OAuth token storage
         pass
 
     def _call_request(self, method, url, headers: dict = None, params=None, data=None, json_data=None, files=None):
@@ -52,9 +54,17 @@ class _APIClient:
         :return: the JSON response from the HTTP request.
         """
         
-        # headers.update(self.headers)
+        if self.oauth_interceptor and self.oauth_interceptor.is_oauth_configured():
+            return self.oauth_interceptor.execute_request(
+                method, url, headers=headers, params=params, data=data, 
+                json=json_data, files=files, timeout=self.timeout
+            )
+        
+        if headers is None:
+            headers = {}
+        headers.update(self.headers)  # Merge client headers (including authtoken) with request headers
         response = requests.request(
-            method, url, headers=headers, params=params, data=data, json=json_data, files=files)
+            method, url, headers=headers, params=params, data=data, json=json_data, files=files, timeout=self.timeout)
         # response.raise_for_status()
         return response
 

contentstack_management-1.7.0/contentstack_management/contentstack.py

@@ -0,0 +1,181 @@
+from enum import Enum
+import os
+import pyotp
+from ._api_client import _APIClient
+from contentstack_management.organizations import organization
+from contentstack_management.stack import stack
+from contentstack_management.user_session import user_session
+from contentstack_management.users import user
+from contentstack_management.oauth.oauth_handler import OAuthHandler
+
+version = '0.0.1'
+
+
+class Region(Enum):
+    US = "us"
+    EU = "eu"
+    AU = "au"
+    AZURE_EU = "azure-eu"
+    AZURE_NA = "azure-na"
+    GCP_NA = "gcp-na"
+    GCP_EU = "gcp-eu"
+
+
+def user_agents(headers=None):
+    if headers is None:
+        headers = {}
+    local_headers = {'X-User-Agent': f'contentstack-management-python/v{version}',
+                     "Content-Type": "application/json"}
+    headers.update(local_headers)
+    return headers
+
+
+class Client:
+
+    # TODO: DefaultCSCredential(), needs to be implemented
+    def __init__(self, host: str = 'api.contentstack.io', scheme: str = 'https://',
+                 authtoken: str = None , management_token=None, headers: dict = None,
+                 region: Region = Region.US.value, version='v3', timeout=2, max_retries: int = 18, early_access: list = None,
+                 oauth_config: dict = None, **kwargs):
+        self.endpoint = 'https://api.contentstack.io/v3/'
+        
+        if region is not None and region is not Region.US.value:
+            if host is not None and host != 'api.contentstack.io':
+                self.endpoint = f'{scheme}{region}-api.{host}/{version}/'
+            else:
+                host = 'api.contentstack.com'
+                self.endpoint = f'{scheme}{region}-{host}/{version}/'
+        elif host is not None and host != 'api.contentstack.io':
+            self.endpoint = f'{scheme}{host}/{version}/'
+        if headers is None:
+            headers = {}
+        if early_access is not None:
+            early_access_str = ', '.join(early_access)
+            headers['x-header-ea'] = early_access_str
+
+        if authtoken is not None:
+            headers['authtoken'] = authtoken
+        
+        if management_token is not None:
+            headers['authorization'] = management_token
+        headers = user_agents(headers)
+        self.client = _APIClient(endpoint=self.endpoint, headers=headers, timeout=timeout, max_retries=max_retries)
+        
+        # Initialize OAuth if configuration is provided
+        self.oauth_handler = None
+        if oauth_config:
+            self.oauth_handler = OAuthHandler(
+                app_id=oauth_config.get('app_id'),
+                client_id=oauth_config.get('client_id'),
+                redirect_uri=oauth_config.get('redirect_uri'),
+                response_type=oauth_config.get('response_type', 'code'),
+                client_secret=oauth_config.get('client_secret'),
+                scope=oauth_config.get('scope'),
+                api_client=self.client
+            )
+
+        """
+        :param host: Optional hostname for the API endpoint.
+        :param authtoken: Optional authentication token for API requests
+        :param headers: Optional headers to be included with API requests
+        :param authorization: Optional headers to be included in the api request
+        :param region: optional region to be included in API requests, 
+        We have region support options for na, eu, azure-eu, azure-na
+        :param scheme: optional scheme to be included in API requests
+        :param version: optional version to be included in API request path url,
+        :param timeout: Optional timeout value for API requests
+        :param max_requests:Optional maximum number of requests to be made
+        :param retry_on_error: Optional boolean value indicating whether to retry API requests on error.
+        :return: A client object for performing API operations.
+        -------------------------------
+        [Example:]
+
+        >>> import contentstack_management
+        >>> contentstack_client = contentstack_management.Client()
+        -------------------------------
+        """
+
+    def login(self, email: str, password: str, tfa_token: str = None, mfa_secret: str = None):
+        """
+        Login to Contentstack with optional TOTP support.
+        
+        :param email: User's email address
+        :param password: User's password
+        :param tfa_token: Optional two-factor authentication token
+        :param mfa_secret: Optional MFA secret for automatic TOTP generation. 
+                          If not provided, will check MFA_SECRET environment variable
+        :return: Response object from the login request
+        """
+        final_tfa_token = tfa_token
+        
+        if not mfa_secret:
+            mfa_secret = os.getenv('MFA_SECRET')
+        
+        if mfa_secret and not tfa_token:
+            final_tfa_token = self._generate_totp(mfa_secret)
+        
+        return user_session.UserSession(self.client).login(email, password, final_tfa_token)
+
+    def _generate_totp(self, secret: str) -> str:
+        """
+        Generate a Time-Based One-Time Password (TOTP) from the provided secret.
+        
+        :param secret: The MFA secret key for TOTP generation
+        :return: The current TOTP code as a string
+        """
+        totp = pyotp.TOTP(secret)
+        return totp.now()
+
+    def logout(self):
+        return user_session.UserSession(client=self.client).logout()
+
+    @property
+    def authtoken(self):
+        return self.client.headers['authtoken']
+
+    def user(self):
+        return user.User(self.client)
+
+    def organizations(self, organization_uid: str = None):
+        return organization.Organization(self.client, organization_uid)
+
+    def stack(self, api_key: str = None):
+        return stack.Stack(self.client, api_key)
+    
+    def oauth(self, app_id: str, client_id: str, redirect_uri: str, 
+              response_type: str = "code", client_secret: str = None, 
+              scope: list = None):
+        """
+        Create an OAuth handler for OAuth 2.0 authentication.
+        
+        Args:
+            app_id: Your registered App ID
+            client_id: Your OAuth Client ID
+            redirect_uri: The URL where the user is redirected after login and consent
+            response_type: OAuth response type (default: "code")
+            client_secret: Client secret for standard OAuth flows (optional for PKCE)
+            scope: Permissions requested (optional)
+            
+        Returns:
+            OAuthHandler instance
+            
+        Example:
+            >>> import contentstack_management
+            >>> client = contentstack_management.Client()
+            >>> oauth_handler = client.oauth(
+            ...     app_id='your-app-id',
+            ...     client_id='your-client-id',
+            ...     redirect_uri='http://localhost:3000/callback'
+            ... )
+            >>> auth_url = oauth_handler.authorize()
+            >>> print(f"Visit this URL to authorize: {auth_url}")
+        """
+        return OAuthHandler(
+            app_id=app_id,
+            client_id=client_id,
+            redirect_uri=redirect_uri,
+            response_type=response_type,
+            client_secret=client_secret,
+            scope=scope,
+            api_client=self.client
+        )

contentstack_management-1.7.0/contentstack_management/oauth/__init__.py

@@ -0,0 +1,5 @@
+"""OAuth 2.0 authentication module for Contentstack Management SDK."""
+
+from .oauth_handler import OAuthHandler
+
+__all__ = ["OAuthHandler"]

contentstack_management-1.7.0/contentstack_management/oauth/oauth_handler.py

@@ -0,0 +1,409 @@
+"""
+OAuth 2.0 Handler for Contentstack Management SDK.
+
+This module provides OAuth 2.0 authentication support including:
+- Authorization code flow
+- PKCE (Proof Key for Code Exchange)
+- Token management and refresh
+- Secure token storage
+"""
+
+import hashlib
+import secrets
+import time
+import urllib.parse
+from typing import Dict, List, Optional, Union
+from urllib.parse import urlparse, parse_qs
+
+import requests
+
+
+class OAuthHandler:
+    """
+    OAuth 2.0 Handler for Contentstack Management SDK.
+    
+    This class manages OAuth 2.0 authentication flow including authorization,
+    token exchange, refresh, and secure storage.
+    """
+    
+    # Error messages
+    ACCESS_TOKEN_EXPIRED_MSG = "🔄 Access token expired, refreshing..."
+    NO_ACCESS_TOKEN_MSG = "No access token available. Please authenticate first."
+    NO_OAUTH_TOKENS_MSG = "No OAuth tokens available"
+    NO_REFRESH_TOKEN_MSG = "No refresh token available"
+    OAUTH_NOT_CONFIGURED_MSG = "OAuth is not configured. Please set up OAuth first."
+    INVALID_AUTHORIZATION_CODE_MSG = "Authorization code not found in redirect URL"
+    TOKEN_EXCHANGE_FAILED_MSG = "Token exchange failed"
+    TOKEN_REFRESH_FAILED_MSG = "Token refresh failed"
+    OAUTH_BASE_URL_NOT_SET_MSG = "OAuthBaseURL is not set"
+    OAUTH_BASE_URL = 'https://app.contentstack.com'
+    DEVELOPER_HUB_BASE_URL = 'https://developerhub-api.contentstack.com'
+    
+    def __init__(
+        self,
+        app_id: str,
+        client_id: str,
+        redirect_uri: str,
+        response_type: str = "code",
+        client_secret: Optional[str] = None,
+        scope: Optional[List[str]] = None,
+        api_client=None
+    ):
+        self.app_id = app_id
+        self.client_id = client_id
+        self.redirect_uri = redirect_uri
+        self.response_type = response_type
+        self.scope = ' '.join(scope) if scope else ''
+        self.client_secret = client_secret  # Optional, if provided, PKCE will be skipped
+        self.api_client = api_client
+        
+        self._oauth_base_url = self._construct_oauth_base_url()
+        self._developer_hub_base_url = self._construct_developer_hub_base_url()
+        
+        if self.api_client:
+            if not hasattr(self.api_client, 'oauth'):
+                self.api_client.oauth = {}
+            self.api_client.oauth.update({
+                'redirect_uri': redirect_uri,
+                'client_id': client_id,
+                'app_id': app_id
+            })
+        
+        # PKCE setup
+        self.use_pkce = client_secret is None
+        if self.use_pkce:
+            self.code_verifier = self._generate_code_verifier()
+            self.code_challenge = self._generate_code_challenge(self.code_verifier)
+        else:
+            self.code_verifier = None
+            self.code_challenge = None
+    
+    def _construct_oauth_base_url(self) -> str:
+        """
+        Construct OAuth base URL based on api_client endpoint using dynamic text replacement.
+        Returns:
+            OAuth base URL string
+        """
+        if not self.api_client or not hasattr(self.api_client, 'endpoint'):
+            return self.OAUTH_BASE_URL
+        
+        endpoint = self.api_client.endpoint
+        
+        from urllib.parse import urlparse
+        parsed = urlparse(endpoint)
+        domain = parsed.netloc
+        if 'api.contentstack.io' in domain:
+            oauth_domain = domain.replace('api.contentstack.io', 'app.contentstack.com')
+        else:
+            oauth_domain = domain.replace('-api.', '-app.').replace('api.', 'app.')
+        oauth_url = f'https://{oauth_domain}'
+        return oauth_url
+    
+    def _construct_developer_hub_base_url(self) -> str:
+        """
+        Construct Developer Hub base URL based on api_client endpoint using dynamic text replacement.
+        Returns:
+            Developer Hub base URL string
+        """
+        if not self.api_client or not hasattr(self.api_client, 'endpoint'):
+            return self.DEVELOPER_HUB_BASE_URL
+        
+        endpoint = self.api_client.endpoint
+        from urllib.parse import urlparse
+        parsed = urlparse(endpoint)
+        domain = parsed.netloc
+        
+        if 'api.contentstack.io' in domain:
+            dev_hub_domain = domain.replace('api.contentstack.io', 'developerhub-api.contentstack.com')
+        else:
+            dev_hub_domain = domain.replace('-api.', '-developerhub-api.')
+        dev_hub_url = f'https://{dev_hub_domain}'
+        return dev_hub_url
+    
+    def _generate_code_verifier(self, length: int = 128) -> str:
+        """
+        Generate a random code verifier for PKCE.
+        Returns:
+            Base64 URL-encoded code verifier
+        """
+        code_verifier = secrets.token_urlsafe(length)
+        return code_verifier
+    
+    def _generate_code_challenge(self, code_verifier: str) -> str:
+        """
+        Generate code challenge from code verifier using SHA256.
+        Returns:
+            Base64 URL-encoded SHA256 hash of the code verifier
+        """
+        sha256_hash = hashlib.sha256(code_verifier.encode('utf-8')).digest()
+        import base64
+        code_challenge = base64.urlsafe_b64encode(sha256_hash).decode('utf-8').rstrip('=')
+        return code_challenge
+    
+    def _get_headers(self) -> Dict[str, str]:
+        """Get common headers for OAuth requests."""
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json"
+        }
+        
+        if (self.api_client and hasattr(self.api_client, 'oauth') and 
+            self.api_client.oauth.get('accessToken')):
+            headers["authorization"] = f"Bearer {self.api_client.oauth['accessToken']}"
+        return headers
+    
+    def authorize(self) -> str:
+        """
+        Start the OAuth authorization flow.
+        Returns:
+            Authorization URL for user to visit
+        """
+        try:
+            print(f"OAuth Handler - authorize() called with app_id: {self.app_id}, client_id: {self.client_id}")  # Debug
+            if not self._oauth_base_url:
+                raise ValueError(self.OAUTH_BASE_URL_NOT_SET_MSG)
+            oauth_base = self._oauth_base_url.rstrip('/')
+            base_url = f"{oauth_base}/#!/apps/{self.app_id}/authorize"
+            params = {
+                'response_type': 'code',  # Always use 'code'
+                'client_id': self.client_id
+            }
+            
+            if self.redirect_uri and self.redirect_uri.strip() and self.redirect_uri != 'None':
+                params['redirect_uri'] = self.redirect_uri
+            
+            # Add PKCE parameters if using PKCE
+            if self.use_pkce:
+                if not self.code_challenge:
+                    self.code_challenge = self._generate_code_challenge(self.code_verifier)
+                params['code_challenge'] = self.code_challenge
+                params['code_challenge_method'] = 'S256'
+            
+            query_string = urllib.parse.urlencode(params)
+            final_url = f"{base_url}?{query_string}"
+            print(f"OAuth Handler - final authorization URL: {final_url}")  # Debug
+            return final_url
+            
+        except Exception as e:
+            raise ValueError(f"Error generating authorization URL: {e}")
+    
+    def handle_redirect(self, redirect_url: str) -> Dict:
+        """
+        Handle the redirect from OAuth authorization server.
+        Returns:
+            Dictionary containing token information
+        """
+        parsed_url = urlparse(redirect_url)
+        query_params = parse_qs(parsed_url.query)
+        if "code" not in query_params:
+            raise ValueError(self.INVALID_AUTHORIZATION_CODE_MSG)
+        authorization_code = query_params["code"][0]
+        return self.exchange_code_for_token(authorization_code)
+    
+    def exchange_code_for_token(self, authorization_code: str) -> Dict:
+        """
+        Exchange authorization code for access token.
+        Returns:
+            Dictionary containing token information
+        """
+        if not authorization_code or not authorization_code.strip():
+            raise ValueError("Authorization code cannot be empty")
+        data = {
+            "grant_type": "authorization_code",
+            "code": authorization_code.strip(),
+            "redirect_uri": self.redirect_uri,
+            "client_id": self.client_id,
+            "app_id": self.app_id
+        }
+        
+        if self.client_secret:
+            data["client_secret"] = self.client_secret
+        else:
+            data["code_verifier"] = self.code_verifier
+        
+        headers = self._get_headers()
+        
+        try:
+            token_endpoint = f"{self._developer_hub_base_url}/token"
+            response = requests.post(
+                token_endpoint,
+                data=data,
+                headers=headers,
+                timeout=30
+            )
+            response.raise_for_status()
+            token_data = response.json()
+            self._save_tokens(token_data)
+            return token_data
+            
+        except requests.RequestException as e:
+            raise requests.RequestException(f"{self.TOKEN_EXCHANGE_FAILED_MSG}: {str(e)}")
+    
+    def _save_tokens(self, token_data: Dict):
+        """
+        Save tokens and related information.
+        """
+        # Store tokens in api_client.oauth
+        if self.api_client:
+            self.api_client.oauth["accessToken"] = token_data.get("access_token")
+            self.api_client.oauth["refreshToken"] = token_data.get("refresh_token") or self.api_client.oauth.get("refreshToken")
+            self.api_client.oauth["organizationUID"] = token_data.get("organization_uid")
+            self.api_client.oauth["userUID"] = token_data.get("user_uid")
+            expires_in = token_data.get("expires_in", 3600)
+            self.api_client.oauth["tokenExpiryTime"] = int(time.time() * 1000) + (expires_in - 60) * 1000  # Store expiry time in milliseconds
+        
+        self._access_token = token_data.get("access_token")
+        self._refresh_token = token_data.get("refresh_token")
+        expires_in = token_data.get("expires_in", 3600)  # Default 1 hour
+        self._token_expiry_time = time.time() + expires_in
+        self._organization_uid = token_data.get("organization_uid")
+        self._user_uid = token_data.get("user_uid")
+        if self.api_client and self._access_token:
+            self.api_client.headers["Authorization"] = f"Bearer {self._access_token}"
+    
+    def get_valid_access_token(self) -> str:
+        """
+        Get valid access token, refreshing if necessary.
+        Returns:
+            Valid access token
+        """
+        if self.is_token_expired():
+            print(self.ACCESS_TOKEN_EXPIRED_MSG)
+            self.refresh_access_token()
+        access_token = self.get_access_token()
+        if not access_token:
+            raise ValueError(self.NO_ACCESS_TOKEN_MSG)
+        return access_token
+    
+    def is_token_expired(self) -> bool:
+        """
+        Check if access token is expired.
+        Returns:
+            True if token is expired, False otherwise
+        """
+        if not self.api_client or not hasattr(self.api_client, 'oauth'):
+            return True
+        
+        token_expiry_time = self.api_client.oauth.get('tokenExpiryTime')
+        if not token_expiry_time:
+            return True
+        if token_expiry_time > 1e10:
+            expiry_time = token_expiry_time / 1000
+        else:
+            expiry_time = token_expiry_time
+        return time.time() >= expiry_time
+    
+    def refresh_access_token(self) -> str:
+        """
+        Refresh the access token using refresh token.
+        Returns:
+            New access token
+        """
+        if not self.api_client or not hasattr(self.api_client, 'oauth') or not self.api_client.oauth:
+            raise ValueError(self.NO_OAUTH_TOKENS_MSG)
+        refresh_token = self.api_client.oauth.get('refreshToken')
+        if not refresh_token:
+            raise ValueError(self.NO_REFRESH_TOKEN_MSG)
+        data = {
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "client_id": self.client_id,
+            "app_id": self.app_id
+        }
+        if self.client_secret:
+            data["client_secret"] = self.client_secret
+        headers = self._get_headers()
+        try:
+            response = requests.post(
+                f"{self._developer_hub_base_url}/token",
+                data=data,
+                headers=headers,
+                timeout=30
+            )
+            response.raise_for_status()
+            
+            token_data = response.json()
+            self._save_tokens(token_data)
+            
+            return self._access_token
+        except requests.RequestException as e:
+            raise requests.RequestException(f"{self.TOKEN_REFRESH_FAILED_MSG}: {str(e)}")
+    
+    def logout(self, revoke_authorization: bool = True) -> bool:
+        """
+        Logout and clear OAuth tokens.
+        Returns:
+            True if logout successful, False otherwise
+        """
+        try:
+            self._clear_tokens()
+            return True
+            
+        except Exception:
+            self._clear_tokens()
+            return False
+    
+    def _clear_tokens(self):
+        """Clear all stored tokens and related information."""
+        self._access_token = None
+        self._refresh_token = None
+        self._token_expiry_time = None
+        self._organization_uid = None
+        self._user_uid = None
+        
+        if self.api_client and "Authorization" in self.api_client.headers:
+            del self.api_client.headers["Authorization"]
+    
+    def get_access_token(self) -> Optional[str]:
+        """Get the current access token."""
+        return self._access_token
+    
+    def set_access_token(self, token: str):
+        """Set the access token."""
+        self._access_token = token
+        if self.api_client:
+            self.api_client.headers["Authorization"] = f"Bearer {token}"
+            if not hasattr(self.api_client, 'oauth'):
+                self.api_client.oauth = {}
+            self.api_client.oauth['accessToken'] = token
+    
+    def get_refresh_token(self) -> Optional[str]:
+        """Get the current refresh token."""
+        return self._refresh_token
+    
+    def set_refresh_token(self, token: str):
+        """Set the refresh token."""
+        self._refresh_token = token
+        if self.api_client:
+            if not hasattr(self.api_client, 'oauth'):
+                self.api_client.oauth = {}
+            self.api_client.oauth['refreshToken'] = token
+    
+    def get_organization_uid(self) -> Optional[str]:
+        """Get the organization UID."""
+        return self._organization_uid
+    
+    def set_organization_uid(self, uid: str):
+        """Set the organization UID."""
+        self._organization_uid = uid
+    
+    def get_user_uid(self) -> Optional[str]:
+        """Get the user UID."""
+        return self._user_uid
+    
+    def set_user_uid(self, uid: str):
+        """Set the user UID."""
+        self._user_uid = uid
+    
+    def get_token_expiry_time(self) -> Optional[float]:
+        """Get the token expiry time."""
+        return self._token_expiry_time
+    
+    def set_token_expiry_time(self, expiry_time: float):
+        """Set the token expiry time."""
+        self._token_expiry_time = expiry_time
+        if self.api_client:
+            if not hasattr(self.api_client, 'oauth'):
+                self.api_client.oauth = {}
+            self.api_client.oauth['tokenExpiryTime'] = expiry_time
+    

contentstack_management-1.7.0/contentstack_management/oauth/oauth_interceptor.py

@@ -0,0 +1,187 @@
+"""
+OAuth Interceptor for automatic token management and request handling.
+"""
+
+import time
+import threading
+from typing import Dict, Any, Optional
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+class OAuthInterceptor:
+    """
+    OAuth interceptor that automatically handles token refresh and request retries.
+    """
+    MAX_RETRIES = 3
+    REFRESH_TIMEOUT = 30 
+    TOKEN_ENDPOINT_PATH = "/token"
+    TOKEN_REFRESH_FAILED_MSG = "Token refresh failed"
+    NO_VALID_TOKENS_MSG = "OAuth: No valid tokens available"
+    TOKEN_REFRESH_FAILED_AFTER_401_MSG = "OAuth: Token refresh failed after 401"
+    # User agent strings
+    USER_AGENT = "contentstack-python-management-sdk"
+    X_USER_AGENT = "contentstack-python-management-sdk"
+    
+    def __init__(self, oauth_handler):
+        """
+        Initialize the OAuth interceptor.
+        Args:
+            oauth_handler: The OAuthHandler instance
+        """
+        self.oauth_handler = oauth_handler
+        self.early_access = None
+        self.refresh_lock = threading.Lock()
+    
+    def set_early_access(self, early_access: list):
+        """Set early access headers."""
+        self.early_access = early_access
+    
+    def is_oauth_configured(self) -> bool:
+        """Check if OAuth is properly configured."""
+        return (self.oauth_handler is not None and 
+                hasattr(self.oauth_handler, 'app_id') and 
+                self.oauth_handler.app_id is not None)
+    
+    def has_valid_tokens(self) -> bool:
+        """Check if we have valid (non-expired) tokens."""
+        if not self.oauth_handler or not hasattr(self.oauth_handler, 'api_client'):
+            return False
+        
+        api_client = self.oauth_handler.api_client
+        if not hasattr(api_client, 'oauth') or not api_client.oauth:
+            return False
+        return not self.oauth_handler.is_token_expired()
+    
+    def _get_default_headers(self, request_url: str) -> Dict[str, str]:
+        """
+        Get default headers for requests.
+        Returns:
+            Dictionary of headers
+        """
+        headers = {
+            "X-User-Agent": self.X_USER_AGENT,
+            "User-Agent": self.USER_AGENT,
+            "x-header-ea": ",".join(self.early_access) if self.early_access else "true"
+        }
+        
+        if self.TOKEN_ENDPOINT_PATH in request_url:
+            headers["Content-Type"] = "application/x-www-form-urlencoded"
+        else:
+            headers["Content-Type"] = "application/json"
+        
+        return headers
+    
+    def _add_auth_header(self, headers: Dict[str, str], request_url: str) -> Dict[str, str]:
+        """
+        Add authorization header if appropriate.
+        Returns:
+            Updated headers with authorization if needed
+        """
+        if self.TOKEN_ENDPOINT_PATH in request_url:
+            return headers
+        if (self.oauth_handler and 
+            hasattr(self.oauth_handler, 'api_client') and
+            self.oauth_handler.api_client and
+            hasattr(self.oauth_handler.api_client, 'oauth') and
+            self.oauth_handler.api_client.oauth and
+            self.oauth_handler.api_client.oauth.get('accessToken')):
+            
+            headers["Authorization"] = f"Bearer {self.oauth_handler.api_client.oauth['accessToken']}"
+        return headers
+    
+    def _ensure_valid_token(self) -> bool:
+        """
+        Ensure we have a valid token, refreshing if necessary.
+        Returns:
+            True if we have a valid token, False otherwise
+        """
+        if not self.oauth_handler or not hasattr(self.oauth_handler, 'api_client'):
+            return False
+        
+        api_client = self.oauth_handler.api_client
+        if not hasattr(api_client, 'oauth') or not api_client.oauth:
+            return False
+        
+        # Check if token is expired and refresh if needed
+        if self.oauth_handler.is_token_expired():
+            with self.refresh_lock:
+                try:
+                    if self.oauth_handler.is_token_expired():
+                        self.oauth_handler.refresh_access_token()
+                    return True
+                except Exception as e:
+                    print(f"{self.TOKEN_REFRESH_FAILED_MSG}: {e}")
+                    return False
+        
+        return True
+    
+    def execute_request(self, method: str, url: str, **kwargs) -> requests.Response:
+        """
+        Execute a request with OAuth handling and retry logic.
+        Returns:
+            Response object
+        """
+        if self.TOKEN_ENDPOINT_PATH in url:
+            return self._make_request(method, url, **kwargs)
+        if not self._ensure_valid_token():
+            raise requests.RequestException(self.NO_VALID_TOKENS_MSG)
+        return self._execute_with_retry(method, url, 0, **kwargs)
+    
+    def _execute_with_retry(self, method: str, url: str, retry_count: int, **kwargs) -> requests.Response:
+        """
+        Execute request with retry logic.
+        Returns:
+            Response object
+        """
+        headers = self._get_default_headers(url)
+        headers = self._add_auth_header(headers, url)
+        if 'headers' in kwargs:
+            headers.update(kwargs['headers'])
+        kwargs['headers'] = headers
+        
+        response = self._make_request(method, url, **kwargs)
+        if not response.ok and retry_count < self.MAX_RETRIES:
+            status_code = response.status_code
+            
+            if (status_code == 401 and 
+                self.oauth_handler and 
+                hasattr(self.oauth_handler, 'api_client') and
+                self.oauth_handler.api_client and
+                hasattr(self.oauth_handler.api_client, 'oauth') and
+                self.oauth_handler.api_client.oauth and
+                self.oauth_handler.api_client.oauth.get('refreshToken')):
+                
+                with self.refresh_lock:
+                    try:
+                        self.oauth_handler.refresh_access_token()
+                        headers["Authorization"] = f"Bearer {self.oauth_handler.api_client.oauth['accessToken']}"
+                        kwargs['headers'] = headers
+                        return self._execute_with_retry(method, url, retry_count + 1, **kwargs)
+                    except Exception as e:
+                        raise requests.RequestException(f"{self.TOKEN_REFRESH_FAILED_AFTER_401_MSG}: {e}")
+            
+            if status_code == 429 or (status_code >= 500 and status_code != 501):
+                # Calculate delay with exponential backoff
+                delay = min(1000 * (2 ** retry_count), 30000) / 1000  # Convert to seconds
+                time.sleep(delay)
+                return self._execute_with_retry(method, url, retry_count + 1, **kwargs)
+        return response
+    
+    def _make_request(self, method: str, url: str, **kwargs) -> requests.Response:
+        """
+        Make the actual HTTP request.
+        Returns:
+            Response object
+        """
+        return requests.request(method, url, **kwargs)
+    
+    def get_valid_access_token(self) -> Optional[str]:
+        """
+        Get a valid access token, refreshing if necessary.
+        Returns:
+            Valid access token or None if unavailable
+        """
+        if self._ensure_valid_token():
+            return self.oauth_handler.api_client.oauth.get('accessToken')
+        return None

{contentstack_management-1.6.0 → contentstack_management-1.7.0}/contentstack_management/user_session/user_session.py

@@ -63,7 +63,7 @@ class UserSession:
         }
 
         if tfa_token is not None:
-            data["user"]["tf_token"] = tfa_token
+            data["user"]["tfa_token"] = tfa_token
 
         data = json.dumps(data)
         response = self.client.post(_path, headers=self.client.headers, data=data, json_data=None)

{contentstack_management-1.6.0 → contentstack_management-1.7.0}/contentstack_management.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contentstack-management
-Version: 1.6.0
+Version: 1.7.0
 Summary: Contentstack API Client Library for Python
 Home-page: https://github.com/contentstack/contentstack-management-python
 Author: dev-ex

{contentstack_management-1.6.0 → contentstack_management-1.7.0}/contentstack_management.egg-info/SOURCES.txt

@@ -44,6 +44,9 @@ contentstack_management/management_token/__init__.py
 contentstack_management/management_token/management_token.py
 contentstack_management/metadata/__init__.py
 contentstack_management/metadata/metadata.py
+contentstack_management/oauth/__init__.py
+contentstack_management/oauth/oauth_handler.py
+contentstack_management/oauth/oauth_interceptor.py
 contentstack_management/organizations/__init__.py
 contentstack_management/organizations/organization.py
 contentstack_management/publish_queue/__init__.py

contentstack_management-1.6.0/contentstack_management/contentstack.py

@@ -1,98 +0,0 @@
-from enum import Enum
-from ._api_client import _APIClient
-from contentstack_management.organizations import organization
-from contentstack_management.stack import stack
-from contentstack_management.user_session import user_session
-from contentstack_management.users import user
-
-version = '0.0.1'
-
-
-class Region(Enum):
-    US = "us"
-    EU = "eu"
-    AU = "au"
-    AZURE_EU = "azure-eu"
-    AZURE_NA = "azure-na"
-    GCP_NA = "gcp-na"
-    GCP_EU = "gcp-eu"
-
-
-def user_agents(headers=None):
-    if headers is None:
-        headers = {}
-    local_headers = {'X-User-Agent': f'contentstack-management-python/v{version}',
-                     "Content-Type": "application/json"}
-    headers.update(local_headers)
-    return headers
-
-
-class Client:
-
-    # TODO: DefaultCSCredential(), needs to be implemented
-    def __init__(self, host: str = 'api.contentstack.io', scheme: str = 'https://',
-                 authtoken: str = None , management_token=None, headers: dict = None,
-                 region: Region = Region.US.value, version='v3', timeout=2, max_retries: int = 18, early_access: list = None,
-                 **kwargs):
-        self.endpoint = 'https://api.contentstack.io/v3/'
-        if region is not None and host is not None and region is not Region.US.value:
-            self.endpoint = f'{scheme}{region}-{host}/{version}/'
-        if region is not None and host is None and region is not Region.US.value:
-            host = 'api.contentstack.com'
-            self.endpoint = f'{scheme}{region}-{host}/{version}/'
-        if host is not None and region is None:
-            self.endpoint = f'{scheme}{host}/{version}/'
-        if headers is None:
-            headers = {}
-        if early_access is not None:
-            early_access_str = ', '.join(early_access)
-            headers['x-header-ea'] = early_access_str
-
-        if authtoken is not None:
-            headers['authtoken'] = authtoken
-        
-        if management_token is not None:
-            headers['authorization'] = management_token
-        headers = user_agents(headers)
-        self.client = _APIClient(endpoint=self.endpoint, headers=headers, timeout=timeout, max_retries=max_retries)
-
-        """
-        :param host: Optional hostname for the API endpoint.
-        :param authtoken: Optional authentication token for API requests
-        :param headers: Optional headers to be included with API requests
-        :param authorization: Optional headers to be included in the api request
-        :param region: optional region to be included in API requests, 
-        We have region support options for na, eu, azure-eu, azure-na
-        :param scheme: optional scheme to be included in API requests
-        :param version: optional version to be included in API request path url,
-        :param timeout: Optional timeout value for API requests
-        :param max_requests:Optional maximum number of requests to be made
-        :param retry_on_error: Optional boolean value indicating whether to retry API requests on error.
-        :return: A client object for performing API operations.
-        -------------------------------
-        [Example:]
-
-        >>> import contentstack_management
-        >>> contentstack_client = contentstack_management.Client()
-        -------------------------------
-        """
-
-    def login(self, email: str, password: str, tfa_token: str = None):
-        return user_session.UserSession(self.client).login(email, password, tfa_token)
-        pass
-
-    def logout(self):
-        return user_session.UserSession(client=self.client).logout()
-
-    @property
-    def authtoken(self):
-        return self.client.headers['authtoken']
-
-    def user(self):
-        return user.User(self.client)
-
-    def organizations(self, organization_uid: str = None):
-        return organization.Organization(self.client, organization_uid)
-
-    def stack(self, api_key: str = None):
-        return stack.Stack(self.client, api_key)