ibm-appconfiguration-python-sdk 0.4.1__tar.gz → 0.4.2__tar.gz

{ibm_appconfiguration_python_sdk-0.4.1/ibm_appconfiguration_python_sdk.egg-info → ibm_appconfiguration_python_sdk-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-appconfiguration-python-sdk
-Version: 0.4.1
+Version: 0.4.2
 Summary: IBM Cloud App Configuration Python SDK
 Home-page: https://github.com/IBM/appconfiguration-python-sdk
 Author: IBM

{ibm_appconfiguration_python_sdk-0.4.1 → ibm_appconfiguration_python_sdk-0.4.2}/ibm_appconfiguration/configurations/configuration_handler.py

@@ -33,6 +33,7 @@ from .internal.utils.metering import Metering
 from .internal.utils.socket import Socket
 from .internal.utils.url_builder import URLBuilder
 from .internal.utils.api_manager import APIManager
+from .internal.utils.rollout_utils import parse_rollout_configuration_phases, get_current_rollout_percentage
 
 
 class ConfigurationHandler:
@@ -61,6 +62,7 @@ class ConfigurationHandler:
         self.__feature_map = dict()
         self.__property_map = dict()
         self.__segment_map = dict()
+        self.__rollout_config_map = dict()
         self.__live_config_update_enabled = True
         ConfigurationHandler.__instance = self
         self.__retry_interval = 120
@@ -97,6 +99,7 @@ class ConfigurationHandler:
         self.__feature_map = dict()
         self.__property_map = dict()
         self.__segment_map = dict()
+        self.__rollout_config_map = dict()
 
     def set_context(self, collection_id: str, environment_id: str, options: dict):
         """Set the context for the configuration
@@ -249,11 +252,33 @@ class ConfigurationHandler:
         if len(data) != 0:
             if 'features' in data:
                 self.__feature_map = dict()
+                self.__rollout_config_map = dict()
                 try:
                     all_feature_list: List = data.get('features')
                     for i, feature in enumerate(all_feature_list):
                         feature_obj = Feature(feature)
                         self.__feature_map[feature_obj.get_feature_id()] = feature_obj
+                        
+                        # Parse feature-level progressive rollout
+                        if feature_obj.get_rollout_configuration() is not None:
+                            rollout_config = feature_obj.get_rollout_configuration()
+                            if rollout_config:
+                                rollout_map = parse_rollout_configuration_phases(rollout_config)
+                                if rollout_map:
+                                    self.__rollout_config_map[feature_obj.get_feature_id()] = rollout_map
+                        
+                        # Parse segment-level progressive rollout
+                        segment_rules = feature_obj.get_segment_rules()
+                        if segment_rules and isinstance(segment_rules, list):
+                            for segment_rule in segment_rules:
+                                segment_rule_obj = SegmentRules(segment_rule)
+                                if segment_rule_obj.get_rollout_configuration() is not None:
+                                    rollout_config = segment_rule_obj.get_rollout_configuration()
+                                    if rollout_config and segment_rule_obj.get_rule_id():
+                                        rollout_map = parse_rollout_configuration_phases(rollout_config)
+                                        if rollout_map:
+                                            key = feature_obj.get_feature_id() + config_constants.DELIMITER + segment_rule_obj.get_rule_id()
+                                            self.__rollout_config_map[key] = rollout_map
                 except Exception as err:
                     Logger.debug(err)
 
@@ -359,8 +384,21 @@ class ConfigurationHandler:
                     if feature.get_feature_data_format() == "YAML" and type(result_dict['value']) == str:
                         return Validators.validate_yaml_string(result_dict['value']), result_dict['is_enabled']
                     return result_dict['value'], result_dict['is_enabled']
-                if feature.get_rollout_percentage() == 100 or (get_normalized_value(
-                        entity_id + ":" + feature.get_feature_id()) < feature.get_rollout_percentage()):
+
+                # Check feature-level rollout
+                rollout_percentage = None
+                if feature.get_rollout_configuration() is not None:
+                    rollout_map = self.__rollout_config_map.get(feature.get_feature_id())
+                    if rollout_map:
+                        entity_id += feature.get_rollout_configuration().get('start_at')
+                        rollout_percentage = get_current_rollout_percentage(rollout_map)
+                    else:
+                        rollout_percentage = 0
+                else:
+                    rollout_percentage = feature.get_rollout_percentage() if feature.get_rollout_percentage() is not None else 100
+
+                if rollout_percentage == 100 or (get_normalized_value(
+                        entity_id + ":" + feature.get_feature_id()) < rollout_percentage):
                     return feature.get_enabled_value(), True
                 return feature.get_disabled_value(), False
             return feature.get_disabled_value(), False
@@ -391,7 +429,35 @@ class ConfigurationHandler:
                                 result_dict['evaluated_segment_id'] = segment_key
                                 if feature is not None:
                                     # evaluate_rules was called for feature flag
-                                    segment_rollout_percentage = feature.get_rollout_percentage() if segment_rule.get_rollout_percentage() == config_constants.DEFAULT_ROLLOUT_PERCENTAGE else segment_rule.get_rollout_percentage()
+                                    segment_rollout_percentage = None
+                                    
+                                    # Check if segment rule has progressive rollout
+                                    if segment_rule.get_rollout_configuration() is not None or segment_rule.get_rollout_type() == config_constants.PROGRESSIVE:
+                                        # Determine which rollout map to use
+                                        if segment_rule.get_rollout_percentage() == config_constants.DEFAULT_ROLLOUT_PERCENTAGE:
+                                            # Use feature-level rollout
+                                            rollout_map = self.__rollout_config_map.get(feature.get_feature_id())
+                                        else:
+                                            # Use segment-level rollout
+                                            rule_id = segment_rule.get_rule_id()
+                                            if rule_id:
+                                                key = feature.get_feature_id() + config_constants.DELIMITER + rule_id
+                                                rollout_map = self.__rollout_config_map.get(key)
+                                            else:
+                                                rollout_map = None
+                                        
+                                        if rollout_map:
+                                            entity_id += segment_rule.get_rollout_configuration().get('start_at')
+                                            segment_rollout_percentage = get_current_rollout_percentage(rollout_map)
+                                        else:
+                                            segment_rollout_percentage = 0
+                                    else:
+                                        # Use manual rollout percentage
+                                        if segment_rule.get_rollout_percentage() == config_constants.DEFAULT_ROLLOUT_PERCENTAGE:
+                                            segment_rollout_percentage = feature.get_rollout_percentage() if feature.get_rollout_percentage() is not None else 100
+                                        else:
+                                            segment_rollout_percentage = segment_rule.get_rollout_percentage() if segment_rule.get_rollout_percentage() is not None else 100
+                                    
                                     if segment_rollout_percentage == 100 or (get_normalized_value(
                                             entity_id + ":" + feature.get_feature_id())) < segment_rollout_percentage:
                                         if segment_rule.get_value() == config_constants.DEFAULT_FEATURE_VALUE:
@@ -413,8 +479,20 @@ class ConfigurationHandler:
                         Logger.debug(err)
 
         if feature is not None:
-            if feature.get_rollout_percentage() == 100 or get_normalized_value(
-                    entity_id + ":" + feature.get_feature_id()) < feature.get_rollout_percentage():
+            # Check feature-level rollout
+            rollout_percentage = None
+            if feature.get_rollout_configuration() is not None:
+                rollout_map = self.__rollout_config_map.get(feature.get_feature_id())
+                if rollout_map:
+                    entity_id += feature.get_rollout_configuration().get('start_at')
+                    rollout_percentage = get_current_rollout_percentage(rollout_map)
+                else:
+                    rollout_percentage = 0
+            else:
+                rollout_percentage = feature.get_rollout_percentage() if feature.get_rollout_percentage() is not None else 100
+            
+            if rollout_percentage == 100 or get_normalized_value(
+                    entity_id + ":" + feature.get_feature_id()) < rollout_percentage:
                 result_dict['value'] = feature.get_enabled_value()
                 result_dict['is_enabled'] = True
             else:

{ibm_appconfiguration_python_sdk-0.4.1 → ibm_appconfiguration_python_sdk-0.4.2}/ibm_appconfiguration/configurations/internal/common/config_constants.py

@@ -18,7 +18,7 @@ This file defines the constants used by the SDK.
 
 DEFAULT_SEGMENT_ID = '$$null$$'
 DEFAULT_ENTITY_ID = '$$null$$'
-DEFAULT_USAGE_LIMIT = 10
+DEFAULT_USAGE_LIMIT = 30
 SDK_NAME = "appconfiguration-python-sdk"
 MAX_NUMBER_OF_RETRIES = 3
 DEFAULT_ROLLOUT_PERCENTAGE = '$default'
@@ -26,3 +26,7 @@ DEFAULT_FEATURE_VALUE = '$default'
 DEFAULT_PROPERTY_VALUE = '$default'
 WEBSOCKET_RECONNECT_DELAY = 15  # Constant delay between reconnection attempts for server errors
 CUSTOM_SOCKET_CLOSE_REASON_CODE = 4001
+
+MANUAL = 'MANUAL'
+PROGRESSIVE = 'PROGRESSIVE'
+DELIMITER = '\u001F'

ibm_appconfiguration_python_sdk-0.4.2/ibm_appconfiguration/configurations/internal/utils/rollout_utils.py

@@ -0,0 +1,101 @@
+# Copyright 2021 IBM All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Utility module for handling progressive rollout configurations.
+"""
+
+from datetime import datetime
+from sortedcontainers import SortedDict
+from .logger import Logger
+
+
+def parse_rollout_configuration_phases(configuration: dict) -> SortedDict:
+    """
+    Parse progressive rollout phases into a SortedDict for efficient timestamp-to-percentage lookups.
+    
+    Args:
+        configuration: Rollout configuration dict with 'start_at' and 'phases' keys
+        
+    Returns:
+        SortedDict with timestamps (ms) as keys and percentages as values, or None if parsing fails
+    """
+    if not configuration or 'start_at' not in configuration or 'phases' not in configuration:
+        return None
+    
+    if not isinstance(configuration['phases'], list) or len(configuration['phases']) == 0:
+        return None
+    
+    try:
+        # Parse start timestamp
+        start_time = datetime.fromisoformat(configuration['start_at'].replace('Z', '+00:00'))
+        transition_time = int(start_time.timestamp() * 1000)  # Convert to milliseconds
+        
+        # Create SortedDict for efficient lookups
+        result = SortedDict()
+        result[0] = 0
+        
+        # Duration multipliers in milliseconds
+        multipliers = {
+            'days': 86400000,  # days
+            'hours': 3600000,  # hours
+            'minutes': 60000,  # minutes
+        }
+        
+        for phase in configuration['phases']:
+            if not isinstance(phase, dict) or 'percentage' not in phase:
+                continue
+            
+            # Add phase entry
+            result[transition_time] = phase['percentage']
+            
+            # Calculate next transition time if duration is specified
+            duration = phase.get('duration')
+            if duration:
+                transition_time += multipliers.get(phase.get('duration_type')) * duration
+
+        return result
+    
+    except (ValueError, AttributeError) as e:
+        Logger.error(f"Invalid start_at timestamp: {configuration.get('start_at')}, error: {str(e)}")
+        return None
+    except Exception as e:
+        Logger.error(f"Error parsing rollout configuration: {str(e)}")
+        return None
+
+
+def get_current_rollout_percentage(rollout_map: SortedDict) -> int:
+    """
+    Returns the current rollout percentage based on current time.
+    
+    Args:
+        rollout_map: SortedDict containing timestamp-to-percentage mappings
+        
+    Returns:
+        The current rollout percentage, or 0 if rollout_map is None or empty
+    """
+    if not rollout_map or len(rollout_map) == 0:
+        return 0
+    
+    current_time = int(datetime.now().timestamp() * 1000)  # Current time in milliseconds
+    
+    # Find the entry with the largest timestamp that is <= current_time
+    # SortedDict.bisect_right returns the index where current_time would be inserted
+    # We want the item just before that position
+    idx = rollout_map.bisect_right(current_time)
+    if idx > 0:
+        key = rollout_map.keys()[idx - 1]
+        return rollout_map[key]
+    
+    return 0

{ibm_appconfiguration_python_sdk-0.4.1 → ibm_appconfiguration_python_sdk-0.4.2}/ibm_appconfiguration/configurations/models/feature.py

@@ -20,6 +20,7 @@ from typing import Any
 from ..internal.utils.logger import Logger
 from ..internal.utils.validators import Validators
 from .configuration_type import ConfigurationType
+from ..internal.common import config_constants
 
 
 class Feature:
@@ -39,7 +40,13 @@ class Feature:
         self.__format = feature_list.get('format', None)
         self.__disabled_value = feature_list.get('disabled_value', object)
         self.__enabled_value = feature_list.get('enabled_value', object)
-        self.__rollout_percentage = feature_list.get('rollout_percentage', 100)
+        self.__rollout_type = feature_list.get('rollout_type', config_constants.MANUAL)
+        if feature_list.get('rollout_configuration', None) is not None:
+            self.__rollout_configuration = feature_list.get('rollout_configuration')
+            self.__rollout_percentage = None
+        else:
+            self.__rollout_percentage = feature_list.get('rollout_percentage', 100)
+            self.__rollout_configuration = None
 
     def get_feature_name(self) -> str:
         """Get the Feature name"""
@@ -74,6 +81,14 @@ class Feature:
     def get_rollout_percentage(self) -> int:
         """Get the Feature flag's rollout percentage"""
         return self.__rollout_percentage
+    
+    def get_rollout_type(self) -> str:
+        """Get the Feature flag's rollout type"""
+        return self.__rollout_type
+    
+    def get_rollout_configuration(self) -> Any:
+        """Get the Feature flag's rollout configuration"""
+        return self.__rollout_configuration
 
     def is_enabled(self) -> bool:
         """

{ibm_appconfiguration_python_sdk-0.4.1 → ibm_appconfiguration_python_sdk-0.4.2}/ibm_appconfiguration/configurations/models/segment_rules.py

@@ -15,6 +15,8 @@
 This module defines the model of a segment rule defined in App Configuration service.
 """
 
+from ..internal.common import config_constants
+
 
 class SegmentRules:
     """
@@ -26,7 +28,14 @@ class SegmentRules:
         self.__order = segment_rules.get("order", 1)
         self.__value = segment_rules.get("value", object)
         self.__rules = segment_rules.get("rules", list())
-        self.__rollout_percentage = segment_rules.get("rollout_percentage", 100)
+        self.__rule_id = segment_rules.get("rule_id", None)
+        self.__rollout_type = segment_rules.get("rollout_type", config_constants.MANUAL)
+        if segment_rules.get("rollout_configuration", None) is not None:
+            self.__rollout_configuration = segment_rules.get("rollout_configuration")
+            self.__rollout_percentage = None
+        else:
+            self.__rollout_percentage = segment_rules.get("rollout_percentage", 100)
+            self.__rollout_configuration = None
 
     def get_order(self) -> int:
         """Get the SegmentRule order"""
@@ -43,3 +52,15 @@ class SegmentRules:
     def get_rollout_percentage(self) -> int:
         """Get the rollout percentage for SegmentRule"""
         return self.__rollout_percentage
+    
+    def get_rule_id(self) -> str:
+        """Get the rule ID for SegmentRule"""
+        return self.__rule_id
+    
+    def get_rollout_type(self) -> str:
+        """Get the rollout type for SegmentRule"""
+        return self.__rollout_type
+    
+    def get_rollout_configuration(self) -> dict:
+        """Get the rollout configuration for SegmentRule"""
+        return self.__rollout_configuration

{ibm_appconfiguration_python_sdk-0.4.1 → ibm_appconfiguration_python_sdk-0.4.2}/ibm_appconfiguration/version.py

@@ -15,4 +15,4 @@
 """
 Version of ibm-appconfiguration-python-sdk
 """
-__version__ = '0.4.1'
+__version__ = '0.4.2'

{ibm_appconfiguration_python_sdk-0.4.1 → ibm_appconfiguration_python_sdk-0.4.2/ibm_appconfiguration_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-appconfiguration-python-sdk
-Version: 0.4.1
+Version: 0.4.2
 Summary: IBM Cloud App Configuration Python SDK
 Home-page: https://github.com/IBM/appconfiguration-python-sdk
 Author: IBM

{ibm_appconfiguration_python_sdk-0.4.1 → ibm_appconfiguration_python_sdk-0.4.2}/ibm_appconfiguration_python_sdk.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ ibm_appconfiguration/configurations/internal/utils/file_manager.py
 ibm_appconfiguration/configurations/internal/utils/logger.py
 ibm_appconfiguration/configurations/internal/utils/metering.py
 ibm_appconfiguration/configurations/internal/utils/parser.py
+ibm_appconfiguration/configurations/internal/utils/rollout_utils.py
 ibm_appconfiguration/configurations/internal/utils/socket.py
 ibm_appconfiguration/configurations/internal/utils/url_builder.py
 ibm_appconfiguration/configurations/internal/utils/validators.py

{ibm_appconfiguration_python_sdk-0.4.1 → ibm_appconfiguration_python_sdk-0.4.2}/setup.py

@@ -12,7 +12,7 @@
 from setuptools import setup, find_packages
 
 NAME = "ibm-appconfiguration-python-sdk"
-VERSION = "0.4.1"
+VERSION = "0.4.2"
 # To install the library, run the following
 #
 # python setup.py install