launchpy 0.4.3.post1__tar.gz → 0.4.3.post3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: launchpy
-Version: 0.4.3.post1
+Version: 0.4.3.post3
 Summary: Adobe Launch API wrapper
 Home-page: https://github.com/pitchmuc/launchpy
 Author: Julien Piccini

{launchpy-0.4.3.post1 → launchpy-0.4.3.post3}/docs/getstarted.md

@@ -26,7 +26,15 @@ lp.createConfigFile()
 This will create a JSON and you will need to fill it with the information available in your adobe io account.
 
 **NOTE**: scope in the config file has evolved over time so you can change it. Following this [link](https://www.adobe.io/authentication/auth-methods.html#!AdobeDocs/adobeio-auth/master/JWT/Scopes.md) to see the different scope possible.\
-By default, I will test the dev scope if the scope provided fails.
+You can change the `scope` attribute for one of these values: `"https://ims-na1.adobelogin.com/s/ent_reactor_admin_sdk"` or `"https://ims-na1.adobelogin.com/s/ent_reactor_sdk"`
+By default, I will test the dev scope if the scope provided fails. So normally nothing you need to do.
+
+**NOTE 2**: There is a possibility till end of 2024 to use the JWT.\
+launchpy supports both `jwt` and `oauthV2` authentication.\
+By default the latest version will try to use the `oauthV2`.\
+You can specify the keys generated in the config file by using the `auth_type` parameter.\
+Possible values : `oauthV2` (default) or `jwt`
+
 
 ## 4. Import the configuration file
 

{launchpy-0.4.3.post1 → launchpy-0.4.3.post3}/docs/property.md

@@ -22,7 +22,7 @@ Here are shortlinks to the different methods explanation.
 
 ## Get methods
 
-When you have your property instance created, the methods that you may want to call first are the get methods. They never take any argument, they don’t actually need any argument.
+When you have your property instance created, the methods that you may want to call first are the get methods. They never take any argument, they don't actually need any argument.
 The only thing important to know is that you must run the getRules() method before the getRuleComponents() method.
 
 The different get methods are the following :
@@ -82,6 +82,10 @@ The different get methods are the following :
     - created_at : it will be greater that this date ('2022-12-12T10:19:20.867Z')
     - updated_at : it will be greater that this date ('2022-12-12T10:19:20.867Z')
 
+* **getLibrary** : Retrieve a specific library.
+  Argument:
+  * library : REQUIRED : Either the library name or the library ID
+
 * **getNotes** : Retrieve the note associated with the object pass to the method. Returns list.
   Arguments:
   * data: OPTIONAL : object that is associated with a Note (rule, data element, etc...)
@@ -191,6 +195,11 @@ The different delete methods are:
   Arguments: 
   * dataElement_id : REQUIRED : Data Element ID that needs to be deleted
 
+* **deleteLibrary** : Delete a specific library. It only works for library in development state.
+  Arguments:
+  * library : REQUIRED : Either the library ID or the library Name
+  * components : OPTIONAL : Boolean, if set to `True`, it will try to delete the different components in that library afterwards. Only rules and data elements would be deleted, no extension.
+
 ## Update methods
 
 As you can imagine the update methods enable you to update the different elements.\

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

@@ -4,7 +4,9 @@ This page gathered the changes made between version of the launchpy module.\
 This has been started after the 0.3.0 release.\
 
 ## 0.4.3
-* Refactor `Translator` class for removing `pandas` dependency
+* Refactor `Translator` class for removing `pandas` dependency\
+Patch:
+* Fix an issue with dependency on `target_configs` attribute in synchronizor.
 
 ## 0.4.2
 * Supporting the Oauth Token V2 authentication

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

@@ -38,6 +38,8 @@ synchronizor = lp.Synchronizer(base='Prop1',targets=['Prop2'])
 
 ```
 
+There is a possibility to setup some rules so you can filter when migrating from one property to another. See [dynamic Filtering](#dynamic-component-filter)
+
 ## SyncComponent Method
 
 The `syncComponent` method can take 3 arguments.
@@ -166,18 +168,58 @@ An example on how the data element looks like:
 ```
 **NOTE** : The JSON representation should be flawless and the regular expression used as well, otherwise the script can break trying to decrypting it. 
 
-### Usage of Dynamic Component filter
+### Dynamic Component Filtering options
+
+#### 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.\
+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.
+
+Hence the code would look like this for instantiation:
+```python
+
+import launchpy as lp
+
+lp.importConfigFile('config.json')
+synchronizor = lp.Synchronizer(base='Prop1',targets=['Prop2'],dynamicRuleComponent='dataElementName')
+
+```
+
+#### Code
+
+You can also provide the JSON representation of the filter used for synchronization via a dictionary, directly in your notebook.\
+A method called `dynamicFiltering` allows you to load a dynamic filter directly within the python application and do not require the creation of data element for it.
+
+So after instantiation, you can now pass the rule such as: 
+
+```python
+import launchpy as lp
+
+lp.importConfigFile('config.json')
+synchronizor = lp.Synchronizer(base='Prop1',targets=['Prop2'])
+myRules = [
+  {
+    'name':'myName',
+    'targetProperties':'.+ some condition .+ ',
+    'exclComponents':[
+        'DE - My Data Element',
+        'RL - My Rule'
+      ],
+    'inclComponents':[
+        'somecomponent name'
+      ]
+  }
+]
 
-You would use that data element name during the instantiation of the synchronizer such as: 
+synchronizor.dynamicFiltering(myRules)
 
-```python 
-synchronizor = lp.Synchronizer(base='BaseProperty',targets=['Target Property 1',
-                                                         'Target Property 2',
-                                                         'Target Property  3'],
-                               dynamicRuleComponent='syncFilter')
 ```
-In this example above, `syncFilter` is the name of the data element containing that configuration.\
-Once your Synchronizer class has been instanciated, you can access 2 attributes in it to verify the correct setup.
+
+
+### Dynamic Component filter check
+
+Once you have loaded your dynamic component rules in your Synchronizer class, you can access 2 attributes to verify the correct setup.
 
 * `dict_config` 
 The `dict_config` attribute will be a copy of your data element setup, but a dictionary instead of an array where all of the target properties rule will be a key.\

launchpy-0.4.3.post3/launchpy/__version__.py

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

{launchpy-0.4.3.post1 → launchpy-0.4.3.post3}/launchpy/connector.py

@@ -283,7 +283,7 @@ class AdobeRequest:
             status_code = {'error': 'Request Error'}
         return status_code
 
-    def deleteData(self, endpoint: str, params: dict = None, headers: dict = None, *args, **kwargs):
+    def deleteData(self, endpoint: str, params: dict = None, data=None, headers: dict = None, *args, **kwargs):
         """
         Abstraction for deleting data
         """
@@ -294,6 +294,10 @@ class AdobeRequest:
             res = requests.delete(endpoint, headers=headers)
         elif params is not None:
             res = requests.delete(endpoint, headers=headers, params=params)
+        elif params is None and data is not None:
+            res = requests.delete(endpoint, headers=headers, data=json.dumps(data))
+        elif params is not None and data is not None:
+            res = requests.delete(endpoint, headers=headers, params=params, data=json.dumps(data))
         try:
             status_code = res.status_code
         except:

{launchpy-0.4.3.post1 → launchpy-0.4.3.post3}/launchpy/library.py

@@ -176,6 +176,24 @@ class Library:
         res = self.connector.patchData(self.endpoint +url, data=obj)
         return res
 
+    def removeDataElements(self,data_element_ids:list)->dict:
+        """
+        Take a list of data elements and remove them from the library.
+        Arguments:
+            data_element_ids: REQUIRED : list of data elements id
+        """
+        if self.state != 'development':
+            print('State is not development, cannot update relationships')
+            return None
+        obj = {'data': []}
+        if type(data_element_ids) == str:
+            data_element_ids = data_element_ids.split(' ')
+        for ids in data_element_ids:
+            obj['data'].append({"id": ids,"type": "data_elements"})
+        url =  f'/libraries/{self.id}/relationships/data_elements'
+        print(obj)
+        res = self.connector.deleteData(self.endpoint +url, data=obj)
+        return res
 
     def addRules(self, rules_ids: list)->dict:
         """
@@ -216,6 +234,25 @@ class Library:
         res = self.connector.patchData(self.endpoint + url, data=obj)
         return res
 
+    def removeRules(self,rules_ids:list)->dict:
+        """
+        Remove the rules that are passed. 
+        Arguments:
+            rules_ids: REQUIRED : list of rules id
+        """
+        if self.state != 'development':
+            print('State is not development, cannot add relationships')
+            return None
+        obj = {'data': []}
+        if type(rules_ids) == str:
+            rules_ids = rules_ids.split(' ')
+        for ids in rules_ids:
+            obj['data'].append({"id": ids, "type": "rules"})
+        url = f'/libraries/{self.id}/relationships/rules'
+        res = self.connector.deleteData(self.endpoint + url, data=obj)
+        return res
+
+
     def addExtensions(self, extensions_ids: list)->object:
         """
         Take a list of extension id and attach them to the library. 
@@ -291,9 +328,11 @@ class Library:
         new_env = self.connector.getData(self.endpoint+path) 
         return new_env
     
-    def updateLibrary(self)->dict:
+    def updateLibrary(self,empty:bool=False)->dict:
         """
         Update the library
+        Arguments:
+            empty : OPTIONAL : You want to empty the library.
         """
         path = f'/libraries/{self.id}'
         data = {
@@ -305,6 +344,21 @@ class Library:
                     }
                 }
                 }
+        if True:
+            data['relationships'] = {
+                "data_elements": {
+                    "data": []
+                },
+                "rules": {
+                    "data": []
+                },
+                "extensions": {
+                    "data": []
+                },
+                "environment":{
+                    "data":{},
+                }
+            }
         res = self.connector.patchData(self.endpoint+path,data=data)
         return res
 

{launchpy-0.4.3.post1 → launchpy-0.4.3.post3}/launchpy/property.py

@@ -48,7 +48,7 @@ class Property:
         self._Rules = data['links']['rules']
         self._RuleComponents = 'https://reactor.adobe.io/properties/' + \
             self.id + '/rule_components'
-        self._Host = 'https://reactor.adobe.io//properties/' + \
+        self._Host = 'https://reactor.adobe.io/properties/' + \
             data['id']+'/hosts'
         self._Note = 'https://reactor.adobe.io/notes/'
         self._Environments = data['links']['environments']
@@ -507,6 +507,20 @@ class Property:
             data = data + append_data
         return data
 
+    def getLibrary(self,libraryId:str=None)->dict:
+        """
+        get a library based on its ID.
+        Arguments:
+            libraryId : REQUIRED : Library ID to be retrieved
+        """
+        if libraryId is None:
+            raise ValueError("Require a library ID")
+        path = f"/libraries/{libraryId}"
+        res = self.connector.getData(self.endpoint+path)
+        if 'data' in res.keys():
+            return res['data']
+        return res
+
     def getNotes(self, data: object)->list:
         """
         Retrieve the note associated with the object pass to the method. Returns list.
@@ -1145,6 +1159,35 @@ class Property:
             'https://reactor.adobe.io/environments/'+env_id)
         return data
 
+    def deleteLibrary(self,library:str=None,components:bool=False)->str:
+        """
+        Delete a Library based on its name or ID.
+        Arguments:
+            library : REQUIRED : Either the ID of the library or the name of the library.
+            components : OPTIONAL : If set to True, it will try to delete all components inside that library.
+        """
+        if library is None:
+            raise ValueError("Require at least library ID")
+        libraries = self.getLibraries()
+        librariesIds = [lib['id'] for lib in libraries]
+        librariesNameId = {lib['attributes']['name']:lib['id'] for lib in libraries}
+        if library in librariesIds:
+            libraryId = library
+        else:
+            libraryId = librariesNameId[library]
+        path = f"/libraries/{libraryId}"
+        if components==True:  
+            myLib = self.getLibrary(libraryId)
+            libClass = Library(myLib)
+            rules = libClass.getRules()
+            dataelements = libClass.getDataElements()
+        res = self.connector.deleteData('https://reactor.adobe.io/'+path)
+        for rule in rules:
+            self.deleteRule(rule['id'])
+        for de in dataelements:
+            self.deleteDataElement(de['id'])
+        return res
+
 def extensionsInfo(data: list)->dict:
     """
     Return a dictionary from the list provided from the extensions request.

{launchpy-0.4.3.post1 → launchpy-0.4.3.post3}/launchpy/synchronizer.py

@@ -44,21 +44,8 @@ class Synchronizer:
         self.translator = Translator()
         self.translator.setBaseExtensions(self.base['extensions'],self.base['name'])
         self.translator.setBaseRules(self.base['rules'],self.base['name'])
-        self.dict_config = {}
-        if kwargs.get("dynamicRuleComponent",None) is not None:
-            configRules = [de for de in self.base['dataElements'] if de['attributes']['name'] == kwargs.get("dynamicRuleComponent",None)]
-            if len(configRules)==1:
-                configRules = configRules[0]
-            else:
-                raise ValueError("The dynamicRuleComponent is using a value that does not match any data element.")
-            codeConfig:list = json.loads(json.loads(configRules['attributes']['settings'])['source'])## list expected from the code
-            for rule in codeConfig:
-                self.dict_config[rule['targetProperties']] = {'inclComponents':[],'exclComponents':[]}
-                if 'inclComponents' in rule.keys():
-                    self.dict_config[rule['targetProperties']]['inclComponents'] += rule['inclComponents']
-                if 'exclComponents' in rule.keys():
-                    self.dict_config[rule['targetProperties']]['exclComponents'] += rule['exclComponents']
         self.targets = {}
+        self.target_configs = {}
         for target in targets:
             tmp_target = [prop for prop in properties if prop['attributes']['name'] == target]
             if len(tmp_target) == 0:
@@ -73,19 +60,60 @@ class Synchronizer:
                 self.translator.extendRules(self.targets[target]['rules'],self.targets[target]['name'])
             else:
                 self.translator.rules[self.targets[target]['name']] = None
-        self.target_configs = {}
-        if len(self.dict_config)>0: ## verify that there are rules
-            for rule in self.dict_config.keys():
-                for target in self.targets.keys():
-                    if re.search(rule,target) is not None:
-                        if target in self.target_configs.keys():
+        if kwargs.get("dynamicRuleComponent",None) is not None:
+            configRules = [de for de in self.base['dataElements'] if de['attributes']['name'] == kwargs.get("dynamicRuleComponent",None)]
+            if len(configRules)==1:
+                configRules = configRules[0]
+            else:
+                raise ValueError("The dynamicRuleComponent is using a value that does not match any data element.")
+            codeConfig:list = json.loads(json.loads(configRules['attributes']['settings'])['source'])## list expected from the code
+            self.dynamicFiltering(codeConfig)
+
+    def dynamicFiltering(self,dynamicFilterJSON:dict,override:bool=True)->None:
+        """
+        Building the dynamic rule filtering for each of the target properties.
+        Base on this code format
+        [
+            {
+                'name':'myName',
+                'targetProperties':'.+ some condition .+ ',
+                'exclComponents':[
+                    'DE - My Data Element',
+                    'RL - My Rule'
+                ],
+                'inclComponents':[
+                    'somecomponent name'
+                ]
+            }
+        ]
+        Arguments: 
+            dynamicFilterJSON : REQUIRED : The JSON representation of your rules.
+            override : OPTIONAL : Replace the existing dynamic filtering. Default True.
+                If set to False, apply the logic on top of the existing one loaded before.
+        """
+        if override == True:
+            self.dict_config = {} ## global dynamic rule filtering
+            self.target_configs = {} ## dynamic rule filtering apply to target
+        for rule in dynamicFilterJSON:
+            self.dict_config[rule['targetProperties']] = {'inclComponents':[],'exclComponents':[]}
+            if 'inclComponents' in rule.keys():
+                self.dict_config[rule['targetProperties']]['inclComponents'] += rule['inclComponents']
+            if 'exclComponents' in rule.keys():
+                self.dict_config[rule['targetProperties']]['exclComponents'] += rule['exclComponents']
+        for rule in self.dict_config.keys():
+            for target in self.targets.keys():
+                if re.search(rule,target) is not None:
+                    if target in self.target_configs.keys():
+                        if self.dict_config[rule]['exclComponents'] not in self.target_configs[target]['exclComponents']:
                             self.target_configs[target]['exclComponents'] += deepcopy(self.dict_config[rule]['exclComponents'])
+                        if self.dict_config[rule]['inclComponents'] not in self.target_configs[target]['inclComponents']:
                             self.target_configs[target]['inclComponents'] += deepcopy(self.dict_config[rule]['inclComponents'])
-                        else:
-                            self.target_configs[target] = {
-                                'exclComponents': deepcopy(self.dict_config[rule]['exclComponents']),
-                                'inclComponents': deepcopy(self.dict_config[rule]['inclComponents'])
-                            }
+                    else:
+                        self.target_configs[target] = {
+                            'exclComponents': deepcopy(self.dict_config[rule]['exclComponents']),
+                            'inclComponents': deepcopy(self.dict_config[rule]['inclComponents'])
+                        }
+    
 
     def syncComponent(self,componentName:str=None,componentId:str=None,publishedVersion:bool=False,**kwargs)->None:
         """

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: launchpy
-Version: 0.4.3.post1
+Version: 0.4.3.post3
 Summary: Adobe Launch API wrapper
 Home-page: https://github.com/pitchmuc/launchpy
 Author: Julien Piccini

launchpy-0.4.3.post1/launchpy/__version__.py

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