launchpy 0.4.4.post3__tar.gz → 0.4.5.post1__tar.gz

{launchpy-0.4.4.post3/launchpy.egg-info → launchpy-0.4.5.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.4.4.post3
+Version: 0.4.5.post1
 Summary: Adobe Launch API wrapper
 Home-page: https://github.com/pitchmuc/launchpy
 Author: Julien Piccini
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas

{launchpy-0.4.4.post3 → launchpy-0.4.5.post1}/docs/releases.md

@@ -3,6 +3,17 @@
 This page gathered the changes made between version of the launchpy module.\
 This has been started after the 0.3.0 release.\
 
+## 0.4.5
+* adding `getExtension` in `Property` class
+* improve `upgradeExtension` in `Property` class
+* improving `checkComponentSync` in `Synchronizer` class
+* improving `getLatestPublishedVersion` with error message defining which property is failing\
+Patch:
+* Better support of `publishedVersion` in checkComponentSync
+* Adding more check in the `checkComponentSync` report
+* Documentation improved in synchronizer
+* Support of extension added in `createTargetsLibrary`
+
 ## 0.4.4
 * adding a `getBuilds` method on the `Library` class instance
 * extend support for pagination on `getEnvironments`

{launchpy-0.4.4.post3 → launchpy-0.4.5.post1}/docs/synchronizer.md

@@ -104,36 +104,68 @@ Arguments:
 
 ## checkComponentSync
 
-This method will allow you to check if a component is the same in the target properties, when compare to the base.
-It works on Rules, Data Elements, Extensions, with their name or ID.
-It is returning a dictionary with the name of the target properties as keys and `True` when the component is the same, `False` when the component is **not** the same.
+Check if the component,from the base property, is synced to the different target properties.
+It can also check for the Extensions.\
+It will return a dictionary with the key being the target property and the value being the result of the evaluation, such as {targetProperty: 'similar'} when component have same settings or {targetPropery : '<difference>'} when component do not have same settings.\
+See below for differences.\
 Arguments:
-* componentName : REQUIRED : The name of the component to compare (can be replaced by componentId)
-* componentId : OPTIONAL : The ID of the component to compare
-* publishedVersion : OPTIONAL : if you want to compare to the version that has been published in your base to your target latest version.
+* componentName : REQUIRED : the name of the component to compare
+* componentID : REQUIRED : the id of the component to compare
+* publishedVersion : OPTIONAL : if you want to compare to the version that has been published in your base vs the published version of your target.
+possible kwargs:
+* action_setting_path : [str,list] : The dot notation of the paths you want to verify for the settings object. ex: ["code","customAttributes"]. If not provided, the complete settings are compared.
+* condition_setting_path : [str,list] : The dot notation of the paths you want to verify for the setting object . ex: ["id",""]. If not provided, the complete settings are compared
+* event_setting_path : [str,list] : The dot notation of the paths you want to verify for the setting object . ex: ["id",""]. If not provided, the complete settings are compared
 
 ### Check realised for component
 
 The script will provide these evaluations:
 For Extensions: 
-* It will check if the same version of the extension is used (return `False` in case different versions)
-* It will check if the same settings has been applied (return `False` else `True`)
+* It will check if the extension is also present in that property. (returns the following sentence `f'Extension "{extension_name}" is not present'` if not the case )
+* It will check if the same version of the extension is used (return the following sentence  `f'Extension version is different: {version_base} vs {version_target}` in case different versions)
+* It will check if the same settings has been applied (return `'Extension settings are different'` if not the same)
 
 For Rules:
-* It will check if the rules contain the same number of ruleComponents (return `False` in case different numbers)
-* It will check each ruleComponent if it can be found (based on Name)
-  * If the ruleComponent name cannot be found in the target property : return `False`
-  * If the ruleComponent name is found and the settings are different : return `False`
-  * If all ruleComponent names have been found and their settings are identical : 
-    * If ruleComponent is an event :
-      * If the rule_order attribute is the same return `True` else return `False`
-    * If the ruleComponent is an action : 
-      * If the timeout attribute is the same return `True` else return `False`
-    * neither an action or event ruleComponent : return `True` as settings are identical.
+* It will check if the rule exist in the target property (if not, returning `"Rule does not exist in Target"`)
+* It will check if the rules contain the same number of ruleComponents (return `"The rule does not have the same number of components"` in case different numbers)
+* It will check if the enabled state is the same than your base (if not, returning `"Rule enabled status is different"`)
+* It will check if the published state is the same than your base (if not, returning `"Rule published status is different"`)
+* It will check each ruleComponent if it can be found (based on name) and generate a list of differences based on each component check:
+  * If the ruleComponent name cannot be found in the target property : return `f'component {rule-component-name} does not exist in Target'`
+  * If the ruleComponent is an event it will check if the order of the event is different. If different, it will return: `rule_order is different`
+  * If the ruleComponent is an condition or an action it will check if the tiemout is different. If different, it will return: `f"condition|action {rule-component-name} timeout is different"`
+  * If the ruleComponent cannot be found in the target rule, it will add the following elements: `'component {rule-component-name} does not exist in Target'`
+  * If the ruleComponent name is found and the settings are different : return `f'<componentType> {rule-component-name} has different settings'`.\
+  ComponentType can be: `event, condition, action`\
+  The settings can be check globally or you can specify a specific part of the setting to be checked (see `possible kwargs`)
+  * If the ruleComponent are all similar, then the result will be `Similar` 
+
 
 For Data Elements:
-* It will check if the Data Element name can be found : return `False` if not found
-* If component Name is found and settings are the same : return `True`, else return `False`
+* It will check if the Data Element name can be found : return `f'Data Element "{data-element-name}" does not exist in Target'` if not found
+* If Data Element (based on name) is found and settings are the same : return `"Similar"`, else return `"Data Element settings are different"`
+
+#### Additional elements
+On top of the different properties check, additional information will be provided for the base component: 
+* `base-publihsed`: If the current component check is published.\
+  **IMPORTANT NOTE**: When you using the `publishedVersion` parameter set to True, most of the element will be set to Published. In reverse, it is not because the component current version is not published that it has never been published. Use the `publishedVersion` to ensure this.
+* `base-enabled`: If the current component check is enabled. 
+* `base-state`: 
+  * `Latest`: If the component retrieved is the latest latest version
+  * `Unknown`: If the component retrieved cannot be evaluated to know if it is the latest.
+  * `Draft` : If the component retrieved is not the latest and it has not yet been published
+  * `Edited`: If the component retrieved is not the latest and has been published before.
+
+#### Similar vs Same
+The idea of checking the similarity of 2 components is partially done as not everything can be tested during the check.\
+For that reason, the wording `Similar` is used and not `Same` as they are not technically the same. (different ids, different things.)
+
+#### publishedVersion for checking
+In the case that you want to compare the published versions, 2 similar problems could occure: 
+- **The base component is not published**. The result of that would be the **failing of the comparison** (an exception will be thrown) because you need to have your base clean to start a comparison with a published version.
+- **One or all the Targets properties do not have the component published**. In that case, I tried to handle that nicely and then try to default to the latest version for comparison. In the result, the following parenthesis would be added `(draft)`
+
+Therefore, the `(draft)` is always referring to the target property.
 
 ## Dynamic Component filter
 
@@ -172,7 +204,7 @@ An example on how the data element looks like:
 
 #### Data Elements
 
-You can pass a Data Element name during the instanciation of the `Synchronizer`. This data element needs to resides in the base property and it will contain a valid JSON that will describe the different rules that will apply during the synchronization.\
+You can pass a Data Element name during the instanciation of the `Synchronizer`. This data element needs to resides in the base property and it will contain a **valid** JSON that will describe the different rules that will apply during the synchronization.\
 The format of the JSON representation for the data element is [explained above](#dynamic-component-filter)\
 The data element name needs to be passed in the `dynamicRuleComponent` parameter.
 

launchpy-0.4.5.post1/launchpy/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.4.5-1"

{launchpy-0.4.4.post3 → launchpy-0.4.5.post1}/launchpy/property.py

@@ -63,7 +63,7 @@ class Property:
         return str(json.dumps(self.definition, indent=4))
     
 
-    def _getExtensionPackage(self, ext_name: str, platform: str = "web", verbose: bool = False)->dict:
+    def _getExtensionPackageIdByName(self, ext_name: str, platform: str = "web", verbose: bool = False)->dict:
         """
         Retrieve extension id of the catalog from an extension name.
         It will be used later on to check for available updates. 
@@ -82,6 +82,23 @@ class Property:
             print('extension name : ' + str(data['attributes']['name']))
             print('extension id : ' + str(data['id']))
         return extension_id
+    
+    def getExtensionPackage(self, extension_id: str = None, verbose: bool = False)->dict:
+        """
+        Retrieve the extension package information based on the extension id.
+        Arguments:
+            extension_id : REQUIRED : ID of the extension package to retrieve
+            verbose : OPTIONAL : if set to True, will print the extension name and id.
+        """
+        if extension_id is None:
+            raise ValueError("You must provide an extension id")
+        path = f'/extension_packages/{extension_id}'
+        res_ext = self.connector.getData(self.endpoint+path)
+        data = res_ext['data']
+        if verbose:
+            print('extension name : ' + str(data['attributes']['name']))
+            print('extension id : ' + str(data['id']))
+        return data
 
     def getRessource(self,res_url: str = None, params: dict = None):
         """
@@ -145,6 +162,16 @@ class Property:
         except:
             data = extensions
         return data
+    
+    def getExtension(self,extensionId:str=None)-> object:
+        """
+        Retrieve the definiton of the extension based on its ID.
+        Arguments:
+            extensionId : REQUIRED : ID of the extension to retrieve
+        """
+        path = f"/extensions/{extensionId}"
+        extensions = self.connector.getData(self.endpoint+path)
+        return extensions['data']
 
     def checkExtensionUpdate(self, name:str=None, platform: str = "web", verbose: bool = False):
         """
@@ -174,7 +201,7 @@ class Property:
                                                        'internal_id': ext['id']
                                                        } for ext in extensions if ext['attributes']['name'] == name}
         for name in dict_extensions:
-            new_id = self._getExtensionPackage(name, platform=platform, verbose=verbose)
+            new_id = self._getExtensionPackageIdByName(name, platform=platform, verbose=verbose)
             if new_id != dict_extensions[name]['package_id']:
                 dict_extensions[name]['package_id'] = new_id
                 dict_extensions[name]['update'] = True
@@ -188,28 +215,63 @@ class Property:
             extension_id : REQUIRED : Your internal ID for this extension in your property (EX....)
             package_id : REQUIRED : new extension id for the extension (EP...)
         """
-        data = {'data': {
-            'id': extension_id,
-                "type": "extensions",
-                "relationships": {"extension_package": {
-                    "links": {
-                        "related": "https://reactor.adobe.io/extensions/"+extension_id+"/extension_package"
-                    },
-                    "data": {
-                        "id": package_id,
-                        "type": "extension_packages"
+        if extension_id is None:
+            raise ValueError("You must provide an extension id")
+        if package_id is None:
+            raise ValueError("You must provide a package id")
+        myExtension = self.getExtension(extension_id)
+        latest_package_id = myExtension.get('meta').get('upgrade_extension_package_id',None)
+        current_package_id = myExtension['relationships']['extension_package']['data']['id']
+        if latest_package_id is None:
+            settings = myExtension.get('attributes',{}).get('settings','{}')
+            attributes = {'delegate_descriptor_id': f'{myExtension.get("attributes",{}).get("name")}::extensionConfiguration::config','settings':settings}
+            data = {'data': {
+                    'id': extension_id,
+                        "type": "extensions",
+                        "relationships": {"extension_package": {
+                            "links": {
+                                "related": "https://reactor.adobe.io/extensions/"+extension_id+"/extension_package"
+                            },
+                            "data": {
+                                "id": package_id,
+                                "type": "extension_packages"
+                            }
+                        }
+                        },
+                        'meta': {'upgrade_extension_package_id': package_id}
+                        }
                     }
-                }
-                },
-                'meta': {
-                    'upgrade_extension_package_id': package_id
-                }
-                }
-                }
+        else:
+            if latest_package_id != current_package_id: ##using a different package that the one provided
+                settings = myExtension.get('attributes',{}).get('settings','{}')
+                attributes = {'delegate_descriptor_id': f'{myExtension.get("attributes",{}).get("name")}::extensionConfiguration::config','settings':settings}
+                data = {'data': {
+                    "attributes": attributes,
+                    'id': extension_id,
+                        "type": "extensions",
+                        "relationships": {"extension_package": {
+                            "links": {
+                                "related": "https://reactor.adobe.io/extensions/"+extension_id+"/extension_package"
+                            },
+                            "data": {
+                                "id": latest_package_id,
+                                "type": "extension_packages"
+                            }
+                            }
+                        }
+                        }
+                    }
+            else:
+                raise ValueError("Extension already up to date")
+
         path = f"/extensions/{extension_id}"
         res = self.connector.patchData(
             self.endpoint+path, data=data)
-        return res
+        try:
+            data = res['data']  # skip meta for now
+        except:
+            data = res
+        return data
     
     def getProfile(self)->dict:
         """
@@ -926,20 +988,27 @@ class Property:
                 lastPage=True
         return data
 
-    def getLatestPublishedVersion(self,revisions:list=None)->dict:
+    def getLatestPublishedVersion(self,revisions:Union[list,dict]=None)->dict:
         """
         Find the latest published version of a component based on the list of revisions retrieved via getRevisions methods.
         Arguments:
-            revisions : REQUIRED : list of revisions
+            revisions : REQUIRED : list of revisions or dictionary of the component.
         """
         if revisions is None:
-            raise ValueError('Require a list of revisions')
+            raise ValueError('Require a list of revisions at least')
+        if type(revisions) == dict:
+            revisions = self.getRevisions(element=revisions)
         publishedIndexVersions:dict = {index:rev['attributes']['revision_number'] for index, rev in enumerate(revisions) if rev['attributes']['published'] == True}
+        maxVersion = max(e['attributes']['revision_number'] for e in revisions)
         if len(publishedIndexVersions) == 0:
-            raise IndexError("You want to retrieve a published version of the component.\nBut no published version can be found. Please check if your component has been published")
+            raise IndexError(f"You want to retrieve a published version of the component.\nBut no published version can be found in {self.name}. Please check if your component has been published")
         maxRevisionIndex = [index for index,value in publishedIndexVersions.items() if value == max(list(publishedIndexVersions.values()))][0]
-        return revisions[maxRevisionIndex]
-
+        publishedVersion = revisions[maxRevisionIndex]
+        if maxVersion == publishedVersion['attributes']['revision_number']:
+            publishedVersion['attributes']['latest'] = True
+        else:
+            publishedVersion['attributes']['latest'] = False
+        return publishedVersion
 
     def reviseDataElement(self, dataElement_id: str)->dict:
         """
@@ -1127,6 +1196,8 @@ class Property:
         argument: 
             extension_id : REQUIRED : the extension id
             attr_dict : REQUIRED : dictionary that will be passed to Launch for update
+        possible kwargs:
+            upgradeLatest : OPTIONAL : Boolean if you want to update the relationships of the extension to the new version
         """
         obj = {
             "data": {
@@ -1135,8 +1206,7 @@ class Property:
                 "type": "extensions"
             }
         }
-        extensions = self.connector.patchData(
-            config.endpoints['global']+'/extensions/'+extension_id, data=obj)
+        extensions = self.connector.patchData(self.endpoint+'/extensions/'+extension_id, data=obj)
         try:
             data = extensions['data']
         except:

{launchpy-0.4.4.post3 → launchpy-0.4.5.post1}/launchpy/synchronizer.py

@@ -6,6 +6,7 @@ from .library import Library
 from .launchpy import Translator, copySettings
 from collections import defaultdict
 from copy import deepcopy
+from aepp import som
 
 class Synchronizer:
     """
@@ -54,7 +55,7 @@ class Synchronizer:
             self.targets[target]['rules'] = self.targets[target]['api'].getRules()
             self.targets[target]['extensions'] = self.targets[target]['api'].getExtensions()
             self.targets[target]['dataElements'] = self.targets[target]['api'].getDataElements()
-            self.targets[target]['libraryStack'] = {'dataElements':[],'rules':[]}
+            self.targets[target]['libraryStack'] = {'dataElements':[],'rules':[],"extensions":[]}
             self.translator.extendExtensions(self.targets[target]['extensions'],self.targets[target]['name'])
             if len(self.targets[target]['rules']) > 0:
                 self.translator.extendRules(self.targets[target]['rules'],self.targets[target]['name'])
@@ -114,23 +115,14 @@ class Synchronizer:
                             'inclComponents': deepcopy(self.dict_config[rule]['inclComponents'])
                         }
     
-
-    def syncComponent(self,componentName:str=None,componentId:str=None,publishedVersion:bool=False,**kwargs)->None:
+    def __prepareBaseComponent__(self,componentName:str=None,componentId:str=None,publishedVersion:bool=False)->dict:
         """
-        Synchronize a component from the base property to the different target properties.
-        It will detect the component with the same name in target properties.
-        It will delete the components related objects (ruleComponents, data element code) in the target property and push the template version.
-        If you uploaded a dynamicRuleComponent data element config during the init method, any element that are not sync because of the exclComponentList will return a dict: {componentName:False} 
+        Prepare the base component to be used in the syncComponent method.
         Arguments:
             componentName : REQUIRED : the name of the component to sync
             componentID : REQUIRED : the id of the component to sync
             publishedVersion : OPTIONAL : if you want to take the version that has been published
-        possible kwargs:
-            timeout : OPTIONAL : The timeout to be used for the rule component. If not provided, the existing timeout will be used.
         """
-        timeout = kwargs.get('timeout',None)
-        if componentName is None and componentId is None:
-            raise ValueError('Require a component Name of a component ID')
         cmp_base=None
         if componentId is not None:
             if componentId.startswith('DE'): ## if data element
@@ -143,6 +135,11 @@ class Synchronizer:
                 if len(componentBase)==0:
                     raise KeyError("Component ID cannot be found")
                 cmp_base = componentBase[0]
+            elif componentId.startswith('EX'): ## if an extension
+                componentBase = [ext for ext in self.base['extensions'] if ext['id'] == componentId]
+                if len(componentBase)==0:
+                    raise KeyError("Component ID cannot be found")
+                cmp_base = componentBase[0]
         if componentId is None and componentName is not None: ## If only componentName
             for rule in self.base['rules']:
                 if componentName == rule['attributes']['name']:
@@ -151,12 +148,18 @@ class Synchronizer:
                 for de in self.base['dataElements']:
                     if componentName == de['attributes']['name']:
                         cmp_base = de
+            if cmp_base is None:
+                for ext in self.base['extensions']:
+                    if componentName == ext['attributes']['name']:
+                        cmp_base = ext
         ## In case we do not find any match
         if cmp_base is None:
             raise KeyError("The component ID or component Name cannot be matched in your template property")
         ## Here creating a dictionary that provide all information related to your component 
         cmp_baseDict = {'id':cmp_base['id'],'name':cmp_base['attributes']['name'],'component':cmp_base,'copy':copySettings(cmp_base)}
-        if publishedVersion:
+        if cmp_baseDict['component']['type'] == 'extensions':
+            cmp_baseDict['version'] = cmp_base['attributes'].get('version','1.0.0')
+        if publishedVersion and cmp_baseDict['component']['type'] not in ['extensions']:
             data = self.base['api'].getRevisions(cmp_baseDict['component'])
             publishedVersion = self.base['api'].getLatestPublishedVersion(data) 
             if publishedVersion['attributes']['name'] != cmp_baseDict['name']:
@@ -173,6 +176,25 @@ class Synchronizer:
             cmp_baseDict['name'] = publishedVersion['attributes']['name']
             cmp_baseDict['component'] = publishedVersion
             cmp_baseDict['copy'] = copySettings(publishedVersion)
+        return cmp_baseDict
+
+    def syncComponent(self,componentName:str=None,componentId:str=None,publishedVersion:bool=False,**kwargs)->None:
+        """
+        Synchronize a component from the base property to the different target properties.
+        It will detect the component with the same name in target properties.
+        It will delete the components related objects (ruleComponents, data element code) in the target property and push the template version.
+        If you uploaded a dynamicRuleComponent data element config during the init method, any element that are not sync because of the exclComponentList will return a dict: {componentName:False} 
+        Arguments:
+            componentName : REQUIRED : the name of the component to sync
+            componentID : REQUIRED : the id of the component to sync
+            publishedVersion : OPTIONAL : if you want to take the version that has been published
+        possible kwargs:
+            timeout : OPTIONAL : The timeout to be used for the rule component. If not provided, the existing timeout will be used.
+        """
+        timeout = kwargs.get('timeout',None)
+        if componentName is None and componentId is None:
+            raise ValueError('Require a component Name of a component ID')
+        cmp_baseDict = self.__prepareBaseComponent__(componentName=componentName,componentId=componentId,publishedVersion=publishedVersion)
         ## handling the data element
         if cmp_baseDict['component']['type'] == 'data_elements':
             for target in list(self.targets.keys()):
@@ -206,7 +228,7 @@ class Synchronizer:
                         self.targets[target]['libraryStack']['dataElements'].append(comp)
                         self.targets[target]['dataElements'].append(comp)
                     else:
-                        index,old_component = [(index,de) for index,de in enumerate(self.targets[target]['dataElements']) if de['attributes']['name'] == cmp_baseDict['name']][0]
+                        index,old_component = [(index,de) for index,de in enumerate(self.targets[target]['dataElements']) if de.get('attributes',{}).get('name') == cmp_baseDict['name']][0]
                         attributes = {
                             "name" : translatedComponent['name'],
                             "enabled" : translatedComponent["enabled"],
@@ -359,6 +381,13 @@ class Synchronizer:
                 self.targets[target]['library'].updateDataElements(existingDataElements)
             if len(newDataElements)>0:
                 self.targets[target]['library'].addDataElements(newDataElements)
+            ## taking care of the extensions
+            existingExtensions = [ext['id'] for ext in self.targets[target]['library'].relationships['extensions'] if ext['id'] in [e['id'] for e in self.targets[target]['libraryStack']['extensions']]]
+            newExtensions = [ext['id'] for ext in self.targets[target]['libraryStack']['extensions'] if ext['id'] not in existingExtensions]
+            if len(existingExtensions) > 0:
+                self.targets[target]['library'].updateExtensions(existingExtensions)
+            if len(newExtensions)>0:
+                self.targets[target]['library'].addExtensions(newExtensions)
 
     def upgradeTargetExtension(self,extensionName:str=None,platform:str="web")->dict:
         """
@@ -370,14 +399,20 @@ class Synchronizer:
         """
         if extensionName is None:
             raise ValueError("Require an extension name")
-        for prop, target in self.targets:
+        for prop, target in self.targets.items():
             try:
                 extensionUpdate = target['api'].checkExtensionUpdate(extensionName)
+                for extName, extUpdateDict in extensionUpdate.items():
+                    if extUpdateDict["update"]:
+                        res = target['api'].upgradeExtension(extUpdateDict['internal_id'],extUpdateDict["package_id"])
+                        target['libraryStack']['extensions'].append(res)
+                        if len([index for index, ext in enumerate(target['extensions']) if ext['attributes']['name'] == extName])>0:
+                            index = [index for index, ext in enumerate(target['extensions']) if ext['attributes']['name'] == extName][0]
+                            del target['extensions'][index]
+                        target['extensions'].append(res)
+                        
             except:
                 raise ValueError(f"Could not find an extension name: {extensionName}")
-            
-
-
 
 
     def renameComponent(self,old_name:str=None,new_name:str=None)->None:
@@ -419,83 +454,62 @@ class Synchronizer:
                 self.targets[target]['libraryStack']['rules'].append(comp)
 
 
-    def checkComponentSync(self,componentName:str=None,componentId:str=None,publishedVersion:bool=False,**kwargs)->bool:
+    def checkComponentSync(self,componentName:str=None,componentId:str=None,publishedVersion:bool=False,excludeSimilar:bool=False,**kwargs)->bool:
         """
         Check if the component,from the base property, is synced to the different target properties.
         It can also check for the Extensions.
-        It will returned {targetProperty: True} when component have same settings or {targetPropery : False} when component do not have same settings.
+        It will return a dictionary with the key being the target property and the value being the result of the evaluation, such as {targetProperty: 'similar'} when component have same settings or {targetPropery : False} when component do not have same settings.
         Arguments:
             componentName : REQUIRED : the name of the component to compare
             componentID : REQUIRED : the id of the component to compare
-            publishedVersion : OPTIONAL : if you want to compare to the version that has been published in your base
+            publishedVersion : OPTIONAL : if you want to compare to the version that has been published in your base vs the published version of your target.
+            excludeSimilar : OPTIONAL : If you do not want to see the result if the comparison provide a "similar" result. Similar means that the elements are about the same. Default: False. 
+        possible kwargs:
+            action_setting_path : [str,list] : The dot notation of the paths you want to verify for the settings object. ex: ["code","customAttributes"]. If not provided, the complete settings are compared.
+            condition_setting_path : [str,list] : The dot notation of the paths you want to verify for the setting object . ex: ["id",""]. If not provided, the complete settings are compared
+            event_setting_path : [str,list] : The dot notation of the paths you want to verify for the setting object . ex: ["id",""]. If not provided, the complete settings are compared
         """
         if componentName is None and componentId is None:
             raise ValueError('Require a component Name of a component ID')
-        cmp_base=None
-        if componentId is not None:
-            if componentId.startswith('DE'): ## if data element
-                componentBase = [de for de in self.base['dataElements'] if de['id'] == componentId]
-                if len(componentBase)==0:
-                    raise KeyError("Component ID cannot be found")
-                cmp_base = componentBase[0]
-            elif componentId.startswith('RL'): ## if a rule
-                componentBase = [de for de in self.base['rules'] if de['id'] == componentId]
-                if len(componentBase)==0:
-                    raise KeyError("Component ID cannot be found")
-                cmp_base = componentBase[0]
-            elif componentId.startswith('EX'): ## if an extension
-                componentBase = [ext for ext in self.base['extensions'] if ext['id'] == componentId]
-                if len(componentBase)==0:
-                    raise KeyError("Component ID cannot be found")
-                cmp_base = componentBase[0]
-        if componentId is None and componentName is not None: ## If only componentName
-            for rule in self.base['rules']:
-                if componentName == rule['attributes']['name']:
-                    cmp_base = rule
-            if cmp_base is None: ## data elements
-                for de in self.base['dataElements']:
-                    if componentName == de['attributes']['name']:
-                        cmp_base = de
-            if cmp_base is None: ## extensions
-                for ext in self.base['extensions']:
-                    if componentName == ext['attributes']['name']:
-                        cmp_base = ext
-        ## In case we do not find any match
-        if cmp_base is None:
-            raise KeyError("The component ID or component Name cannot be matched in your template property")
-        ## Here creating a dictionary that provide all information related to your component 
-        cmp_baseDict = {'id':cmp_base['id'],'name':cmp_base['attributes']['name'],'component':cmp_base,'copy':copySettings(cmp_base)}
-        if publishedVersion:
-            data = self.base['api'].getRevisions(cmp_baseDict['component'])
-            publishedVersion = self.base['api'].getLatestPublishedVersion(data) 
-            if publishedVersion['attributes']['name'] != cmp_baseDict['name']:
-                ## Updating mapping table with old name when published version name diff than last version name.
-                if cmp_baseDict['component']['type'] == 'rules':
-                    self.translator.extendBaseRules(
-                    ruleName=publishedVersion['attributes']['name'],
-                    ruleId=publishedVersion['id'],
-                    property_name=self.base["name"])
-                    self.base['rules'].append(publishedVersion)
-                if cmp_baseDict['component']['type'] == 'data_elements':
-                    self.base['dataElements'].append(publishedVersion)
-                if cmp_baseDict['component']['type'] == 'extensions':
-                    self.base['extensions'].append(publishedVersion)
-            cmp_baseDict['id'] = publishedVersion['id']
-            cmp_baseDict['name'] = publishedVersion['attributes']['name']
-            cmp_baseDict['component'] = publishedVersion
-            cmp_baseDict['copy'] = copySettings(publishedVersion)
-        dict_result = {tar:False for tar in self.targets.keys()}
+        cmp_baseDict = self.__prepareBaseComponent__(componentName=componentName,componentId=componentId,publishedVersion=publishedVersion)
+        dict_result = {tar:"" for tar in self.targets.keys()}
+        dict_result['base-enabled'] = cmp_baseDict['component']['attributes'].get('enabled',False)
+        dict_result['base-published'] = cmp_baseDict['component']['attributes'].get('published',False)
+        if cmp_baseDict['component']['attributes'].get('latest',False):
+            dict_result['base-state'] = "Latest"
+        else:
+            if cmp_baseDict['component']['attributes'].get('latest','unknown') == 'unknown':
+                if dict_result['base-enabled']:
+                    dict_result['base-state'] = "Draft"
+                else:
+                    dict_result['base-state'] = "Unknown"
+            elif dict_result['base-published'] == False:
+                dict_result['base-state'] = "Draft"
+            else:
+                dict_result['base-state'] = "Edited"
         if cmp_baseDict['component']['type'] == 'data_elements':
             for target in list(self.targets.keys()):
                 ## if it does not exist
-                    if cmp_baseDict['name'] not in [de.get('attributes',{}).get('name') for de in self.targets[target]['dataElements']]:
-                        dict_result[target] = False
+                if cmp_baseDict['name'] not in [de.get('attributes',{}).get('name') for de in self.targets[target]['dataElements']]:
+                    dict_result[target] = f'Data Element "{cmp_baseDict["name"]}" does not exist in Target'
+                else:
+                    index,target_de = [(index,de) for index,de in enumerate(self.targets[target]['dataElements']) if de['attributes']['name'] == cmp_baseDict['name']][0]
+                    issue_pub = ""
+                    if publishedVersion:
+                        try:
+                            revisions_dataElement = self.targets[target]["api"].getRevisions(target_de)
+                            target_de = self.targets[target]["api"].getLatestPublishedVersion(revisions_dataElement) 
+                        except:
+                            issue_pub = " (draft)"
+                        if target_de['attributes']['enabled'] != cmp_baseDict['component']['attributes']['enabled']:
+                            dict_result[target] = "Data Element enabled status is different"+issue_pub
+                        if target_de['attributes']['published'] != cmp_baseDict['component']['attributes']['published']:
+                            dict_result[target] = "Data Element published status is different"+issue_pub
+                    if target_de['attributes']['settings'] == cmp_baseDict['component']['attributes']['settings']:
+                        if not excludeSimilar:
+                            dict_result[target] = "Similar"+issue_pub
                     else:
-                        index,old_component = [(index,de) for index,de in enumerate(self.targets[target]['dataElements']) if de['attributes']['name'] == cmp_baseDict['name']][0]
-                        if old_component['attributes']['settings'] == cmp_baseDict['component']['attributes']['settings']:
-                            dict_result[target] = True
-                        else:
-                            dict_result[target] = False
+                        dict_result[target] = "Data Element settings are different"+issue_pub
         if cmp_baseDict['component']['type'] == 'rules':
             rcsLink = cmp_baseDict['component'].get('relationships',{}).get('rule_components',{}).get('links',{}).get('related')
             resResource = self.base['api'].getRessource(rcsLink)
@@ -506,53 +520,113 @@ class Synchronizer:
             for target in list(self.targets.keys()):
                 ## if rule does not exist
                 if cmp_baseDict['name'] not in [rule['attributes']['name'] for rule in self.targets[target]['rules']]:
-                    dict_result[target] = False
+                    dict_result[target] = "Rule does not exist in Target"
                 else:
                     index, targetRule = [(index,rule) for index, rule in enumerate(self.targets[target]['rules']) if rule['attributes']['name'] == cmp_baseDict['name']][0]
-                    targetRuleId = targetRule['id']
+                    issue_pub = ""
+                    componentsDifferences = [] ## list of differences for rule components for rule to check difference
+                    if publishedVersion:
+                        try:
+                            revisions_targetRule = self.targets[target]["api"].getRevisions(targetRule)
+                            targetRule = self.targets[target]["api"].getLatestPublishedVersion(revisions_targetRule) 
+                        except:
+                            issue_pub = " (not published)"
+                        if targetRule['attributes']['enabled'] != cmp_baseDict['component']['attributes']['enabled']:
+                            componentsDifferences.append("Rule enabled status is different")
+                        if targetRule['attributes']['published'] != cmp_baseDict['component']['attributes']['published']:
+                            componentsDifferences.append("Rule published status is different")
                     rcsLinkTarget = targetRule.get('relationships',{}).get('rule_components',{}).get('links',{}).get('related')
                     resResource = self.targets[target]['api'].getRessource(rcsLinkTarget)
-                    old_components:list = resResource['data']
+                    target_rule_components:list = resResource['data']
                     #if not same amunt of rule component 
-                    if len(template_ruleComponents) != len(old_components):
-                        dict_result[target] = False
-                    dict_result[target] = False ## bydefault, there is a difference
-                    componentsDifferences = [] ## array of compontent for rule to check difference
+                    if len(template_ruleComponents) != len(target_rule_components):
+                        dict_result[target] = "The rule does not have the same number of components"
                     for base_comp in template_ruleComponents:
                         checkExist = False
-                        for old_comp in old_components:
-                            if old_comp['attributes']['name'] == base_comp['attributes']['name']:
+                        for comp in target_rule_components:
+                            if comp['attributes']['name'] == base_comp['attributes']['name']:
                                 checkExist = True
-                                if old_comp['attributes']['settings'] == base_comp['attributes']['settings']:
-                                    if '::events::' in base_comp['attributes']['delegate_descriptor_id']:
-                                        if old_comp['attributes']['rule_order'] == base_comp['attributes']['rule_order']:
-                                            componentsDifferences.append(True)
-                                        else:
-                                            componentsDifferences.append(False)
-                                    elif '::actions::' in base_comp['attributes']['delegate_descriptor_id']:
-                                        if old_comp['attributes']['timeout'] == base_comp['attributes']['timeout']:
-                                            componentsDifferences.append(True)
-                                        else:
-                                            componentsDifferences.append(False)
-                                    else: ## no action no event but same settings
-                                        componentsDifferences.append(True)
-                                else: ## settings not the same
-                                    componentsDifferences.append(False)
+                                if '::events::' in base_comp['attributes']['delegate_descriptor_id']:
+                                    if comp['attributes']['rule_order'] != base_comp['attributes']['rule_order']:
+                                        componentsDifferences.append("rule_order is different")
+                                    if kwargs.get('event_setting_path',None) is not None:
+                                        list_event_path = kwargs.get('event_setting_path',None)
+                                        if type(list_event_path) == str:
+                                            list_event_path = list(list_event_path)
+                                        mySettings_base = som.Som(json.loads(base_comp['attributes']['settings']))
+                                        mySettings_target = som.Som(json.loads(comp['attributes']['settings']))
+                                        for path in list_event_path:
+                                            tmp_base = mySettings_base.get(path,'')
+                                            tmp_target = mySettings_target.get(path,'')
+                                            if tmp_base != tmp_target:
+                                                componentsDifferences.append(f'event "{comp['attributes']['name']}" has different settings')
+                                    else:
+                                        if base_comp['attributes']['settings'] != comp['attributes']['settings']:
+                                            componentsDifferences.append(f'event "{comp['attributes']['name']}" has different settings')
+                                elif '::conditions::' in base_comp['attributes']['delegate_descriptor_id']:
+                                    if comp['attributes']['timeout'] != base_comp['attributes']['timeout']:
+                                        componentsDifferences.append(f'condition "{comp['attributes']['name']}" timeout is different')
+                                    if kwargs.get('condition_setting_path',None) is not None:
+                                        list_event_path = kwargs.get('condition_setting_path',None)
+                                        if type(list_event_path) == str:
+                                            list_event_path = list(list_event_path)
+                                        mySettings_base = som.Som(json.loads(base_comp['attributes']['settings']))
+                                        mySettings_target = som.Som(json.loads(comp['attributes']['settings']))
+                                        for path in list_event_path:
+                                            tmp_base = mySettings_base.get(path,'')
+                                            tmp_target = mySettings_target.get(path,'')
+                                            if tmp_base != tmp_target:
+                                                componentsDifferences.append(f'condition "{comp['attributes']['name']}" has different settings')
+                                    else:
+                                        if base_comp['attributes']['settings'] != comp['attributes']['settings']:
+                                            componentsDifferences.append(f'condition "{comp['attributes']['name']}" has different settings')
+                                elif '::actions::' in base_comp['attributes']['delegate_descriptor_id']:
+                                    if comp['attributes']['timeout'] != base_comp['attributes']['timeout']:
+                                        componentsDifferences.append(f'action "{comp['attributes']['name']}" timeout is different')
+                                    if kwargs.get('action_setting_path',None) is not None:
+                                        list_actions_path = kwargs.get('action_setting_path',None)
+                                        if type(list_actions_path) == str:
+                                            list_actions_path = list(list_actions_path)
+                                        mySettings_base = som.Som(json.loads(base_comp['attributes']['settings']))
+                                        mySettings_target = som.Som(json.loads(comp['attributes']['settings']))
+                                        for path in list_actions_path:
+                                            tmp_base = mySettings_base.get(path,'')
+                                            tmp_target = mySettings_target.get(path,'')
+                                            if tmp_base != tmp_target:
+                                                componentsDifferences.append(f'action "{comp['attributes']['name']}" has different settings')
+                                    else:
+                                        if base_comp['attributes']['settings'] != comp['attributes']['settings']:
+                                            componentsDifferences.append(f'action "{comp['attributes']['name']}" has different settings')
                         if checkExist == False: ## does not exist
-                            componentsDifferences.append(False)
-                    if all(componentsDifferences):
-                        dict_result[target] = True
+                            componentsDifferences.append(f'component "{base_comp['attributes']['name']}" does not exist in Target')
+                    if len(componentsDifferences)>0:
+                        dict_result[target] = ','.join(componentsDifferences) + issue_pub
+                    else:
+                        if not excludeSimilar:
+                            dict_result[target] = 'Similar' + issue_pub
         if cmp_baseDict['component']['type'] == 'extensions':
             for target in list(self.targets.keys()):
                 if cmp_baseDict['name'] not in [ext['attributes']['name'] for ext in self.targets[target]['extensions']]:
-                    dict_result[target] = False
+                    dict_result[target] = f'Extension "{cmp_baseDict['name']}" is not present'
                 else:
                     index, extensionTarget = [(index,ext) for index, ext in enumerate(self.targets[target]['extensions']) if ext['attributes']['name'] == cmp_baseDict['name']][0]
+                    issue_pub = ""
+                    if publishedVersion:
+                        try:
+                            revisions_targetExt = self.targets[target]["api"].getRevisions(extensionTarget)
+                            extensionTarget = self.targets[target]["api"].getLatestPublishedVersion(revisions_targetExt)
+                        except:
+                            issue_pub = " (not published)"
+                        if extensionTarget['attributes']['enabled'] != cmp_baseDict['component']['attributes']['enabled']:
+                            dict_result[target] = f'Extension enabled status is different: {cmp_baseDict["component"]["attributes"]["enabled"]} vs {extensionTarget["attributes"]["enabled"]}'+issue_pub
+                        if extensionTarget['attributes']['published'] != cmp_baseDict['component']['attributes']['published']:
+                            dict_result[target] = f'Extension published status is different: {cmp_baseDict["component"]["attributes"]["published"]} vs {extensionTarget["attributes"]["published"]}'+issue_pub
                     if extensionTarget['attributes']['version'] != cmp_baseDict['component']['attributes']['version']:
-                        dict_result[target] = False
+                        dict_result[target] = f'Extension version is different: {cmp_baseDict['component']['attributes']['version']} vs {extensionTarget['attributes']['version']}'+issue_pub
                     else:
                         if extensionTarget['attributes']['settings'] != cmp_baseDict['component']['attributes']['settings']:
-                            dict_result[target] = False
+                            dict_result[target] = 'Extension settings are different'+issue_pub
                         else:
-                            dict_result[target] = True
+                            if not excludeSimilar:
+                                dict_result[target] = 'Similar'+issue_pub
         return dict_result

{launchpy-0.4.4.post3 → launchpy-0.4.5.post1/launchpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.4.4.post3
+Version: 0.4.5.post1
 Summary: Adobe Launch API wrapper
 Home-page: https://github.com/pitchmuc/launchpy
 Author: Julien Piccini
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas

{launchpy-0.4.4.post3 → launchpy-0.4.5.post1}/requirements.txt

@@ -2,4 +2,6 @@ pathlib>=1.0.0
 PyJWT[crypto]>=1.7.1
 PyJWT>=1.7.1
 pathlib2>=2.3.5
-requests>=2.25.0
+requests>=2.25.0
+aepp=>0.3.10
+pandas>=2.1.0

{launchpy-0.4.4.post3 → launchpy-0.4.5.post1}/setup.py

@@ -42,7 +42,7 @@ setup(
         "Topic :: Software Development :: Libraries",
         "Development Status :: 4 - Beta"
     ],
-    python_requires='>=3.7',
+    python_requires='>=3.10',
     install_requires=["requests",
-                      "PyJWT", "pathlib2", "pathlib", "PyJWT[crypto]"],
+                      "PyJWT", "pathlib2", "pathlib", "PyJWT[crypto]","aepp","pandas"],
 )

launchpy-0.4.4.post3/launchpy/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.4.4-3"