launchpy 0.5.0__tar.gz → 0.5.1__tar.gz

{launchpy-0.5.0/launchpy.egg-info → launchpy-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.0
+Version: 0.5.1
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0
@@ -12,13 +12,11 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas

{launchpy-0.5.0 → launchpy-0.5.1}/docs/cli.md

@@ -17,7 +17,7 @@ This document provides an overview of the command line interface (CLI) for `laun
       - [extract\_property](#extract_property)
       - [load\_property](#load_property)
       - [get\_extensions](#get_extensions)
-      - [load\_extension](#load_extension)
+      - [load\_synchronizer](#load_synchronizer)
     - [Property Layer Commands](#property-layer-commands)
       - [get\_extensions](#get_extensions-1)
       - [get\_extension](#get_extension)
@@ -286,8 +286,8 @@ python -m launchpy.cli -cf <path_to_your_config_file>
 launchpy> get_extensions -s True
 ```
 
-#### load_extension
-Load a the synchronizer layer, allowing you to manage and synchronize properties with rules and data elements.\
+#### load_synchronizer
+Load the synchronizer layer, allowing you to manage and synchronize properties with extensions, rules and data elements.\
 Arguments:
 `base_name`: Name of the Launch Property to use as base.
 `-t`, `--targets`: list of target property names for synchronization. This is a required parameter.
@@ -299,6 +299,31 @@ launchpy> load_synchronizer "Base Property Name" -t "Target Property 1" "Target
 synchronizer:Base_Property_Name>
 ```
 
+**Synchronizing across organizations**\
+The synchronizer also supports a base property and/or target properties that live in a *different* Adobe organization than the one currently active in the CLI. This is useful when you manage several IMS orgs and want to push the same rules, data elements and extensions from a single base property to properties in other orgs.
+
+To reference a property in another organization, append `@<org_name>` to its name, where `<org_name>` matches an `org_name` entry from a multi-org config file (see [create_config_file](#create_config_file)). Any property name without `@<org_name>` is resolved against the organization that is currently active in the session (the one last set via [config](#config) or [change_org](#change_org)).
+
+First, load a multi-org config file so every organization you want to reference is available in the session:
+```bash
+python -m launchpy.cli -cf <path_to_your_multi_org_config_file> --org_name client_a
+launchpy:client_a>
+```
+
+Then load the synchronizer using `@org_name` on the base and/or the targets:
+```bash
+launchpy:client_a> load_synchronizer "Base Property Name@client_a" -t "Target Property 1@client_b" "Target Property 2@client_c"
+synchronizer:Base_Property_Name>
+```
+
+Organizations can be mixed freely; targets that omit `@org_name` resolve to the currently active organization (`client_a` below):
+```bash
+launchpy:client_a> load_synchronizer "Base Property Name" -t "Target Property 1" "Target Property 2@client_b"
+synchronizer:Base_Property_Name>
+```
+
+**Note**: if a private extension used by the base property is named differently in a target organization, the CLI cannot map the two names for you — this requires passing a `mapping_extensions` dictionary (`{"target-extension-name": "base-extension-name"}`) to `launchpy.Synchronizer` directly through the Python API, usually done via a Notebook, since that option is not exposed as a CLI flag.
+
 ### Property Layer Commands
 
 Once you have instantiated the property layer for a specific property, you can access various commands to manage that property. These commands allow you to perform actions such as viewing and editing rules, data elements, and other configurations related to that property.

{launchpy-0.5.0 → launchpy-0.5.1}/docs/releases.md

@@ -4,7 +4,6 @@ This page gathered the changes made between version of the launchpy module.\
 This has been started after the 0.3.0 release.\
 
 ## 0.5.0
-* Adding option to extract only the latest published version of the artifacts when extracting a property. This is available in the CLI with the `-p` or `--published_version` flag and in the `extractProperty` function with the `publishedVersion` parameter. 
 * Fixing the `create_property` method in the CLI
 * Adding support for multi-org config files.
 * Adding support for multi-org instantiation in the synchronizer module.
@@ -14,7 +13,9 @@ This has been started after the 0.3.0 release.\
 * Adding `sync_data_elements` capabilitiy in the CLI and `syncDataElements` in synchronizer module.
 * Fixing the `createTargetsLibrary` method in the synchronizer where using existing library that contained rules not touched by the synchronizer would delete them. Now it will keep them and only update the ones that are in the source property.
 * `extractProperty` can now extract the elements as they are in their published version. This is available in the CLI with the `-p` or `--published_version` flag and in the `extractProperty` function with the `publishedVersion` parameter.
-* `extractProperty` has a new parameter `folder` that allows you to specify the folder where the property will be extracted. If None, a folder named after the property name will be created in the current working directory.
+* `extractProperty` has a new parameter `folder` that allows you to specify the folder where the property will be extracted. If None, a folder named after the property name will be created in the current working directory.\
+Patch: 
+* Printing the outcome that elements are not created when you do not have the `forceCreation` parameter.
 
 
 ## 0.4.9

{launchpy-0.5.0 → launchpy-0.5.1}/docs/synchronizer.md

@@ -54,9 +54,34 @@ That is possible, but the requirements are still needed regarding the following
 * You have unique name for your rule and data elements
 * You have the same extension installed in both the template and target properties.
 
-The synchronizer will use the environment credential lastly loaded in the system.\ 
-We would recommend to load first the target organization that you want to sync to, and then the base organization.\
-You will be able to use the Property instance of the target organization in order to sync the element afterwards.
+#### Using the `@org_name` shorthand (recommended)
+
+The simplest way is to import a **multi-org config file** (a JSON list where each block has its own `org_name`, see [getstarted](getstarted.md)) so that every organization you want to reference is loaded in a single call, then reference a property in a specific organization by appending `@<org_name>` to its name in `base` or `targets`. Any name without `@<org_name>` is resolved against the default/last configured organization.
+
+```py
+import launchpy as lp
+
+lp.importConfigFile('config_multi_org.json') ## loads every org_name block in the file at once
+
+synchronizor = lp.Synchronizer(
+    base='Base Property Name@client_a',
+    targets=['Target Property 1@client_b', 'Target Property 2@client_c']
+)
+```
+
+You can mix organizations freely; a target without `@org_name` resolves to the default organization (the first one loaded, or the one set by your last `configure()` call without an explicit `org_name`):
+
+```py
+synchronizor = lp.Synchronizer(
+    base='Base Property Name', ## resolved in the default org
+    targets=['Target Property 1', 'Target Property 2@client_b']
+)
+```
+
+#### Using explicit Property instances (alternative)
+
+You can also build the `Property` instances yourself and pass them directly instead of strings. This is useful for one-off scripts or when you want to select a property that `getProperties` returns without relying on name matching.\
+The synchronizer will use the environment credential lastly loaded in the system, so we recommend loading the target organization first, then the base organization, so that the `Property` instances you build stay tied to the correct organization's connector.
 
 Example of setup
 

launchpy-0.5.1/launchpy/__version__.py

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

{launchpy-0.5.0 → launchpy-0.5.1}/launchpy/cli/__main__.py

@@ -578,7 +578,11 @@ class SynchronizerCLI(cmd.Cmd):
                 result = self.synchronizer.syncComponent(componentId=args.id, publishedVersion=args.published, forceCreation=args.create, verbose=args.verbose)
             else:
                 result = self.synchronizer.syncComponent(componentName=args.name, publishedVersion=args.published, forceCreation=args.create, verbose=args.verbose)
-            console.print(f"Component '{args.name or args.id}' synced successfully.", style="green")
+            for prop, message in result.items():
+                if "does not exist" in message:
+                    console.print(f"[{prop}] {message}", style="yellow")
+                elif args.verbose:
+                    console.print(f"[{prop}] {message}", style="green")
         except Exception as e:
             console.print(f"(!) Error: {str(e)}", style="red")
             return
@@ -590,32 +594,44 @@ class SynchronizerCLI(cmd.Cmd):
         parser.add_argument("-r", "--regex", help="Regex pattern to filter rules by name (partial match, non-case sensitive). Default None.", type=str, default=None)
         parser.add_argument("-c", "--create", help="Create rules that do not exist in the destination property. Default False.", action="store_true", default=False)
         parser.add_argument("-p", "--published", help="Sync the latest published version of the rules. Default False.", action="store_true", default=False)
+        parser.add_argument("-v", "--verbose", help="Print detailed information about the sync process, including successes. Default False.", action="store_true", default=False)
         try:
             args = parser.parse_args(shlex.split(args))
             result = self.synchronizer.syncRules(regex=args.regex, forceCreation=args.create, publishedVersion=args.published)
-            console.print(f"All rules synced successfully.", style="green")
+            for ruleName, targetResults in result.items():
+                for prop, message in (targetResults or {}).items():
+                    if "does not exist" in message:
+                        console.print(f"[{ruleName}][{prop}] {message}", style="yellow")
+                    elif args.verbose:
+                        console.print(f"[{ruleName}][{prop}] {message}", style="green")
         except Exception as e:
             console.print(f"(!) Error: {str(e)}", style="red")
             return
         except SystemExit:
             return
-    
+
     def do_sync_data_elements(self,args:Any):
         """Sync all data elements between source and destination properties."""
         parser = argparse.ArgumentParser(prog='sync_data_elements', add_help=True)
         parser.add_argument("-r", "--regex", help="Regex pattern to filter data elements by name (partial match, non-case sensitive). Default None.", type=str, default=None)
         parser.add_argument("-c", "--create", help="Create data elements that do not exist in the destination property. Default False.", action="store_true", default=False)
         parser.add_argument("-p", "--published", help="Sync the latest published version of the data elements. Default False.", action="store_true", default=False)
+        parser.add_argument("-v", "--verbose", help="Print detailed information about the sync process, including successes. Default False.", action="store_true", default=False)
         try:
             args = parser.parse_args(shlex.split(args))
             result = self.synchronizer.syncDataElements(regex=args.regex, forceCreation=args.create, publishedVersion=args.published)
-            console.print(f"All data elements synced successfully.", style="green")
+            for deName, targetResults in result.items():
+                for prop, message in (targetResults or {}).items():
+                    if "does not exist" in message:
+                        console.print(f"[{deName}][{prop}] {message}", style="yellow")
+                    elif args.verbose:
+                        console.print(f"[{deName}][{prop}] {message}", style="green")
         except Exception as e:
             console.print(f"(!) Error: {str(e)}", style="red")
             return
         except SystemExit:
             return
-    
+
     def do_sync_extensions(self,args:Any):
         """Sync all extensions between source and destination properties."""
         parser = argparse.ArgumentParser(prog='sync_extensions', add_help=True)
@@ -625,13 +641,18 @@ class SynchronizerCLI(cmd.Cmd):
         try:
             args = parser.parse_args(shlex.split(args))
             result = self.synchronizer.syncExtensions(regex=args.regex, forceCreation=args.create, verbose=args.verbose)
-            console.print(f"All extensions synced successfully.", style="green")
+            for extName, targetResults in result.items():
+                for prop, message in (targetResults or {}).items():
+                    if "does not exist" in message:
+                        console.print(f"[{extName}][{prop}] {message}", style="yellow")
+                    elif args.verbose:
+                        console.print(f"[{extName}][{prop}] {message}", style="green")
         except Exception as e:
             console.print(f"(!) Error: {str(e)}", style="red")
             return
         except SystemExit:
             return
-        
+
     def do_rename_component(self,args:Any):
         """Rename a component in the destination property."""
         parser = argparse.ArgumentParser(prog='rename_component', add_help=True)
@@ -661,16 +682,22 @@ class SynchronizerCLI(cmd.Cmd):
         parser = argparse.ArgumentParser(prog='upgrade_extension', add_help=True)
         parser.add_argument("name", help="Name of the extension to upgrade", type=str)
         parser.add_argument("-p", "--platform", help="Platform to be used for extension upgrade. default 'web'. Possible values: web, app", type=str, default="web")
+        parser.add_argument("-v", "--verbose", help="Print detailed information about the upgrade process, including successes. Default False.", action="store_true", default=False)
         try:
             args = parser.parse_args(shlex.split(args))
-            self.synchronizer.upgradeTargetExtension(extensionName=args.name, platform=args.platform)
-            console.print(f"Extension '{args.name}' upgraded successfully.", style="green")
+            response = self.synchronizer.upgradeTargetExtension(extensionName=args.name, platform=args.platform, verbose=args.verbose)
+            for prop, message in response.items():
+                failed = message.startswith("Could not upgrade")
+                if failed:
+                    console.print(f"[{prop}] {message}", style="red")
+                elif args.verbose:
+                    console.print(f"[{prop}] {message}", style="green")
         except Exception as e:
             console.print(f"(!) Error: {str(e)}", style="red")
             return
         except SystemExit:
             return
-    
+
     def do_get_base_rules(self,args:Any):
         """Get the base rules that are available for synchronization."""
         parser = argparse.ArgumentParser(prog='get_base_rules', add_help=True)
@@ -848,8 +875,12 @@ class SynchronizerCLI(cmd.Cmd):
                 console.print(f"Upgrading {len(extensions)} extension{'s' if len(extensions) > 1 else ''} from library '{lib.name}'...", style="blue")
                 for ext in extensions:
                     try:
-                        self.synchronizer.upgradeTargetExtension(extensionName=ext['attributes']['name'], platform=ext['attributes']['platform'], publishedVersion=publishedVersion, verbose=args.verbose)
-                        console.print(f"Extension '{ext['attributes']['name']}' upgraded successfully.", style="green")
+                        response = self.synchronizer.upgradeTargetExtension(extensionName=ext['attributes']['name'], platform=ext['attributes']['platform'], verbose=args.verbose)
+                        for prop, message in response.items():
+                            if message.startswith("Could not upgrade"):
+                                console.print(f"[{prop}] {message}", style="red")
+                            elif args.verbose:
+                                console.print(f"[{prop}] {message}", style="green")
                     except Exception as e:
                         console.print(f"(!) Error upgrading extension '{ext['attributes']['name']}': {str(e)}", style="red")
             if len(rules)>0:
@@ -860,8 +891,12 @@ class SynchronizerCLI(cmd.Cmd):
                             ruleId = rule['links']['self'].split('/').pop()
                         else:
                             ruleId = rule['id']
-                        self.synchronizer.syncComponent(componentId=ruleId, publishedVersion=publishedVersion, forceCreation=args.create,libraryLinked=libraryLinked,verbose=args.verbose)
-                        console.print(f"Rule '{rule['attributes']['name']}' synced successfully.", style="green")
+                        response = self.synchronizer.syncComponent(componentId=ruleId, publishedVersion=publishedVersion, forceCreation=args.create,libraryLinked=libraryLinked,verbose=args.verbose)
+                        for prop, message in response.items():
+                            if "does not exist" in message:
+                                console.print(f"[{prop}] {message}", style="yellow")
+                            elif args.verbose:
+                                console.print(f"[{prop}] {message}", style="green")
                     except Exception as e:
                         console.print(f"(!) Error syncing rule '{rule['attributes']['name']}': {str(e)}", style="red")
             if len(dataelements)>0:
@@ -872,8 +907,12 @@ class SynchronizerCLI(cmd.Cmd):
                             deId = de['links']['self'].split('/').pop()
                         else:
                             deId = de['id']
-                        self.synchronizer.syncComponent(componentId=deId, publishedVersion=publishedVersion, forceCreation=args.create,libraryLinked=libraryLinked,verbose=args.verbose)
-                        console.print(f"Data element '{de['attributes']['name']}' synced successfully.", style="green")
+                        response = self.synchronizer.syncComponent(componentId=deId, publishedVersion=publishedVersion, forceCreation=args.create,libraryLinked=libraryLinked,verbose=args.verbose)
+                        for prop, message in response.items():
+                            if "does not exist" in message:
+                                console.print(f"[{prop}] {message}", style="yellow")
+                            elif args.verbose:
+                                console.print(f"[{prop}] {message}", style="green")
                     except Exception as e:
                         console.print(f"(!) Error syncing data element '{de['attributes']['name']}': {str(e)}", style="red")
         except Exception as e:

{launchpy-0.5.0 → launchpy-0.5.1}/launchpy/property.py

@@ -199,6 +199,9 @@ class Property:
                                                        'update': False,
                                                        'internal_id': ext['id']
                                                        } for ext in extensions if ext['attributes']['name'] == name}
+            if len(dict_extensions) == 0:
+                installed_names = [ext['attributes']['name'] for ext in extensions]
+                raise ValueError(f"No extension named '{name}' is installed on this property. Installed extensions: {installed_names}")
         for name in dict_extensions:
             new_id = self._getExtensionPackageIdByName(name, platform=platform, verbose=verbose)
             if new_id != dict_extensions[name]['package_id']:

{launchpy-0.5.0 → launchpy-0.5.1}/launchpy/synchronizer.py

@@ -164,6 +164,7 @@ class Synchronizer:
         """
         cmp_base=None
         componentBase = None
+        lib_cmp_base = None
         if componentId is not None:
             if componentId.startswith('DE'): ## if data element
                 if kwargs.get('libraryLinked',False):
@@ -232,7 +233,7 @@ class Synchronizer:
                     if cmp_baseDict['component']['type'] == 'data_elements':
                         self.base['dataElements'].append(publishedVersion)
             cmp_baseDict = {'id':publishedVersion['id'],'name':publishedVersion['attributes']['name'],'component':publishedVersion,'copy':copySettings(publishedVersion)}
-        if kwargs.get('libraryLinked',False) and cmp_baseDict['component']['type'] in ['rules','data_elements']:
+        if lib_cmp_base is not None and kwargs.get('libraryLinked',False) and cmp_baseDict['component']['type'] in ['rules','data_elements']:
             if lib_cmp_base['attributes']['name'] != cmp_baseDict['name']:
                 with self._base_lock:
                     if cmp_baseDict['component']['type'] == 'rules':
@@ -246,12 +247,13 @@ class Synchronizer:
             cmp_baseDict = {'id':lib_cmp_base['id'],'name':lib_cmp_base['attributes']['name'],'component':lib_cmp_base,'copy':copySettings(lib_cmp_base)}
         return cmp_baseDict
 
-    def syncComponent(self,componentName:str=None,componentId:str=None,publishedVersion:bool=False,forceCreation:bool=False,**kwargs)->None:
+    def syncComponent(self,componentName:str=None,componentId:str=None,publishedVersion:bool=False,forceCreation:bool=False,**kwargs)->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} 
+        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}
+        Returns a dictionary keyed by target property name, with the status message for that target (created, updated, or not synced because the component does not exist and forceCreation is False).
         Arguments:
             componentName : REQUIRED : the name of the component to sync
             componentID : REQUIRED : the id of the component to sync
@@ -267,6 +269,7 @@ class Synchronizer:
         verbose = kwargs.get('verbose',False)
         if componentName is None and componentId is None:
             raise ValueError('Require a component Name of a component ID')
+        response = {}
         cmp_baseDict = self.__prepareBaseComponent__(componentName=componentName,componentId=componentId,publishedVersion=publishedVersion,libraryLinked=libraryLinked)
         ## handling the data element
         if cmp_baseDict['component']['type'] == 'data_elements':
@@ -306,9 +309,11 @@ class Synchronizer:
                                         attr_dict=translatedComponent)
                                 self.targets[target]['libraryStack']['dataElements'].append(comp)
                                 self.targets[target]['dataElements'].append(comp)
+                                response[target] = f'Data element "{cmp_baseDict["name"]}" created in "{target}".'
                             else:
-                                if verbose:
-                                    print(f'The data element "{cmp_baseDict["name"]}" does not exist in the target property "{target}". Set forceCreation to True if you want to create it.')
+                                message = f'Data element "{cmp_baseDict["name"]}" does not exist in the target property "{target}". Not synced, set forceCreation to True if you want to create it.'
+                                print(message)
+                                response[target] = message
                         else:
                             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 = {
@@ -328,6 +333,7 @@ class Synchronizer:
                             del self.targets[target]['dataElements'][index]
                             self.targets[target]['dataElements'].append(comp)
                             self.targets[target]['libraryStack']['dataElements'].append(comp)
+                            response[target] = f'Data element "{cmp_baseDict["name"]}" updated in "{target}".'
         ## Rules part
         if cmp_baseDict['component']['type'] == 'rules':
             ## fetching all rule components associated with a rule.
@@ -385,10 +391,12 @@ class Synchronizer:
                                         delay_next=translatedComponent['delay_next'],
                                         timeout=translatedComponent['timeout'],
                                     )
+                                response[target] = f'Rule "{cmp_baseDict["name"]}" created in "{target}".'
                             else:
                                 flagSkipCreation = True
-                                if verbose:
-                                    print(f'The rule "{cmp_baseDict["name"]}" does not exist in the target property "{target}". Not creating it')
+                                message = f'The rule "{cmp_baseDict["name"]}" does not exist in the target property "{target}". Not synced, set forceCreation to True if you want to create it.'
+                                print(message)
+                                response[target] = message
                         else: ## if a rule exist with the same name
                             if verbose:
                                     print(f'The rule "{cmp_baseDict["name"]}" exists in the target property "{target}". Updating it')
@@ -424,6 +432,7 @@ class Synchronizer:
                                     delay_next=translatedComponent['delay_next'],
                                     timeout=translatedComponent['timeout'],
                                 )
+                            response[target] = f'Rule "{cmp_baseDict["name"]}" updated in "{target}".'
                         ## updating rule attribute if difference between base and target
                         if not flagSkipCreation: ## if the rule was created or updated, we want to make sure that the attribute are the same as the template
                             if cmp_baseDict['component']['attributes']['enabled'] != targetRule['attributes']['enabled']:
@@ -449,7 +458,7 @@ class Synchronizer:
                         comp_base_settings = cmp_baseDict['copy']['settings']
                         comp_base_extension_id = cmp_baseDict['copy']['extension_id']
                         descriptor = cmp_baseDict['copy']['descriptor']
-                        if cmp_baseDict['name'] not in [ext['attributes']['name'] for ext in self.targets[target]['extensions']]:
+                        if cmp_baseDict['name'] not in [ext['attributes']['name'] for ext in self.targets[target]['extensions']]: ## if extension does not exist
                             if forceCreation:
                                 if verbose:
                                     print(f'The extension "{cmp_baseDict["name"]}" does not exist in the target property "{target}". Creating it')
@@ -463,9 +472,11 @@ class Synchronizer:
                                 self.targets[target]['libraryStack']['extensions'].append(comp)
                                 self.targets[target]['extensions'].append(comp)
                                 self.translator.extendExtensions(self.targets[target]['extensions'],target)
+                                response[target] = f'Extension "{cmp_baseDict["name"]}" created in "{target}".'
                             else:
-                                if verbose:
-                                    print(f'The extension "{cmp_baseDict["name"]}" does not exist in the target property "{target}". Set forceCreation to True if you want to create it.')
+                                message = f'The extension "{cmp_baseDict["name"]}" does not exist in the target property "{target}". Not synced, set forceCreation to True if you want to create it.'
+                                print(message)
+                                response[target] = message
                         else: ## if extension exist, we will update it
                             if verbose:
                                 print(f'The extension "{cmp_baseDict["name"]}" exists in the target property "{target}". Updating it')
@@ -480,27 +491,32 @@ class Synchronizer:
                             self.targets[target]['extensions'].append(comp)
                             self.targets[target]['libraryStack']['extensions'].append(comp)
                             self.translator.extendExtensions(self.targets[target]['extensions'],target)
+                            response[target] = f'Extension "{cmp_baseDict["name"]}" updated in "{target}".'
+        return response
 
-
-    def syncComponents(self,componentsName:list=None,componentsId:list=None,publishedVersion:bool=False,forceCreation:bool=False)->None:
+    def syncComponents(self,componentsName:list=None,componentsId:list=None,publishedVersion:bool=False,forceCreation:bool=False)->dict:
         """
         Sync multiple components by looping through the list of name passed.
+        Returns a dictionary keyed by component name (or id), with the per-target status returned by syncComponent.
         Arguments:
             componentsName : REQUIRED : The list of component names to sync
             componentsId : REQUIRED : The list of component ID to sync
             publishedVersion : OPTIONAL : if you want to take the version that has been published
             forceCreation : OPTIONAL : If set to True, it will sync the components even if they do not exist in the target properties. If set to False, it will only sync the components that already exist in the target properties. Default: False.
         """
+        results = {}
         if componentsName is not None:
             for component in componentsName:
-                self.syncComponent(componentName=component,publishedVersion=publishedVersion,forceCreation=forceCreation)
+                results[component] = self.syncComponent(componentName=component,publishedVersion=publishedVersion,forceCreation=forceCreation)
         if componentsId is not None:
             for component in componentsId:
-                self.syncComponent(componentId=component,publishedVersion=publishedVersion,forceCreation=forceCreation)
-    
-    def syncRules(self,regex:str=None,forceCreation:bool=False,publishedVersion:bool=False)->None:
+                results[component] = self.syncComponent(componentId=component,publishedVersion=publishedVersion,forceCreation=forceCreation)
+        return results
+
+    def syncRules(self,regex:str=None,forceCreation:bool=False,publishedVersion:bool=False)->dict:
         """
         Synchronizing the rules in the base property to the target properties.
+        Returns a dictionary keyed by rule name, with the per-target status (created, updated, or not synced because the rule does not exist and forceCreation is False).
         Arguments:
             regex : OPTIONAL : If you want to filter the rules to sync based on a regex pattern. Default: None (sync all rules)
             forceCreation : OPTIONAL : If set to True, it will sync the rules even if they do not exist in the target properties. If set to False, it will only sync the rules that already exist in the target properties. Default: False.
@@ -509,14 +525,17 @@ class Synchronizer:
         base_rule_names = [rule['attributes']['name'] for rule in self.base['rules']]
         if regex is not None:
             base_rule_names = [rule for rule in base_rule_names if re.search(regex,rule)]
+        results = {}
         with ThreadPoolExecutor() as executor:
-            futures = [executor.submit(self.syncComponent, componentName=rule, forceCreation=forceCreation, publishedVersion=publishedVersion) for rule in base_rule_names]
-            for future in futures:
-                future.result()
+            future_to_name = {executor.submit(self.syncComponent, componentName=rule, forceCreation=forceCreation, publishedVersion=publishedVersion): rule for rule in base_rule_names}
+            for future in future_to_name:
+                results[future_to_name[future]] = future.result()
+        return results
 
-    def syncDataElements(self,regex:str=None,forceCreation:bool=False,publishedVersion:bool=False)->None:
+    def syncDataElements(self,regex:str=None,forceCreation:bool=False,publishedVersion:bool=False)->dict:
         """
         Synchronizing the data elements in the base property to the target properties.
+        Returns a dictionary keyed by data element name, with the per-target status (created, updated, or not synced because the data element does not exist and forceCreation is False).
         Arguments:
             regex : OPTIONAL : If you want to filter the data elements to sync based on a regex pattern. Default: None (sync all data elements)
             forceCreation : OPTIONAL : If set to True, it will sync the data elements even if they do not exist in the target properties. If set to False, it will only sync the data elements that already exist in the target properties. Default: False.
@@ -525,15 +544,18 @@ class Synchronizer:
         base_de_names = [de['attributes']['name'] for de in self.base['dataElements']]
         if regex is not None:
             base_de_names = [de for de in base_de_names if re.search(regex,de)]
+        results = {}
         with ThreadPoolExecutor() as executor:
-            futures = [executor.submit(self.syncComponent, componentName=de, forceCreation=forceCreation, publishedVersion=publishedVersion) for de in base_de_names]
-            for future in futures:
-                future.result()
-    
-    def syncExtensions(self,regex:str=None,forceCreation:bool=False, **kwargs)->None:
+            future_to_name = {executor.submit(self.syncComponent, componentName=de, forceCreation=forceCreation, publishedVersion=publishedVersion): de for de in base_de_names}
+            for future in future_to_name:
+                results[future_to_name[future]] = future.result()
+        return results
+
+    def syncExtensions(self,regex:str=None,forceCreation:bool=False, **kwargs)->dict:
         """
         Take extensions from the Base and try to install them on the target properties.
         It will check if the extension is already installed in the target property, if not it will install it.
+        Returns a dictionary keyed by extension name, with the per-target status (created, updated, or not synced because the extension does not exist and forceCreation is False).
         Arguments:
             regex : OPTIONAL : If you want to filter the extensions name to sync based on a regex pattern. Default: None (sync all extensions)
             forceCreation : OPTIONAL : If set to True, will force the creation of the extension even if it already exists. Default: False
@@ -542,8 +564,10 @@ class Synchronizer:
         base_extension_names = [ext['attributes']['name'] for ext in base_extensions]
         if regex is not None:
             base_extension_names = [ext for ext in base_extension_names if re.search(regex,ext)]
+        results = {}
         for ext_name in base_extension_names:
-            self.syncComponent(componentName=ext_name,forceCreation=forceCreation,**kwargs)
+            results[ext_name] = self.syncComponent(componentName=ext_name,forceCreation=forceCreation,**kwargs)
+        return results
 
     
     def createTargetsLibrary(self,name:str="syncComponents",assignEnv:bool|str=False,**kwargs)->None:
@@ -672,9 +696,10 @@ class Synchronizer:
         """
         if extensionName is None:
             raise ValueError("Require an extension name")
+        response = {}
         for prop, target in self.targets.items():
             try:
-                extensionUpdate = target['api'].checkExtensionUpdate(extensionName)
+                extensionUpdate = target['api'].checkExtensionUpdate(extensionName,platform=platform)
                 for extName, extUpdateDict in extensionUpdate.items():
                     if extUpdateDict["update"]:
                         res = target['api'].upgradeExtension(extUpdateDict['internal_id'],extUpdateDict["package_id"])
@@ -683,13 +708,18 @@ class Synchronizer:
                             index = [index for index, ext in enumerate(target['extensions']) if ext['attributes']['name'] == extName][0]
                             del target['extensions'][index]
                         target['extensions'].append(res)
+                        response[prop] = f"Extension '{extName}' upgraded successfully."
                         if verbose:
                             print(f"Extension '{extName}' upgraded successfully in '{prop}' property.")
                     else:
+                        response[prop] = f"Extension '{extName}' is already up to date."
                         if verbose:
                             print(f"Extension '{extName}' is already up to date in '{prop}' property.")
-            except:
-                raise ValueError(f"Could not find an extension name: {extensionName}")
+            except Exception as e:
+                response[prop] = f"Could not upgrade extension '{extensionName}': {e}"
+                if verbose:
+                    print(f"Could not upgrade extension '{extensionName}' in '{prop}' property: {e}")
+        return response
 
 
     def renameComponent(self,old_name:str=None,new_name:str=None)->None:
@@ -939,9 +969,10 @@ class Synchronizer:
             dict_check[element_name] = self.checkComponentSync(componentId=element_id, excludeSimilar=excludeSimilar,publishedVersion=publishedVersion,libraryLinked=libraryLink)
         return dict_check
     
-    def syncFromLibrary(self,library:str=None,state='published',forceCreation:bool=False,libraryLinked:bool=True,publishedVersion:bool=False,dryRun:bool=False,**kwargs)->None:
+    def syncFromLibrary(self,library:str=None,state='published',forceCreation:bool=False,libraryLinked:bool=True,publishedVersion:bool=False,dryRun:bool=False,**kwargs)->dict:
         """
         Sync the components in a library, from the base property, to the different target properties by using the createTargetsLibrary method.
+        Returns a dictionary keyed by component name, with the per-target status (created, updated, or not synced because the component does not exist and forceCreation is False), or the error message if the sync failed.
         Arguments:
             library : REQUIRED : the library name or the library ID to get the components.
             state : OPTIONAL : the state of the library to compare. Default: 'published', possible states: "development", "submitted", "approved", "rejected", "published"
@@ -949,7 +980,7 @@ class Synchronizer:
             libraryLinked : OPTIONAL : If set to True, it will sync the components using the library version. Default: False.
             publishedVersion : OPTIONAL : if you want to sync the version of the library that has been published in your base vs the published version of your target. Default: False.
             dryRun : OPTIONAL : If set to True, it will not actually sync the components but will return a dictionary with the components that would be synced and the target properties they would be synced to. Default: False.
-        Possible kwargs: 
+        Possible kwargs:
             verbose : bool : If set to True, it will print the name of the components and the property that are being synced and the target property. Default: False.
         """
         verbose = kwargs.get('verbose', False)
@@ -968,12 +999,15 @@ class Synchronizer:
         rules = myLib.getRules()
         dataelements = myLib.getDataElements()
         extensions = myLib.getExtensions()
+        results = {}
         if len(extensions)>0:
             for ext in extensions:
                 try:
-                    self.upgradeTargetExtension(extensionName=ext['attributes']['name'],platform=ext['attributes']['platform'],verbose=verbose)
-                except:
-                    print(f'Extension {ext["attributes"]["name"]} could not be updated in the target properties. Please check if the extension exist and if there is an update available.')
+                    results[ext['attributes']['name']] = self.upgradeTargetExtension(extensionName=ext['attributes']['name'],platform=ext['attributes']['platform'],verbose=verbose)
+                except Exception as e:
+                    message = f'Extension {ext["attributes"]["name"]} could not be updated in the target properties: {e}'
+                    print(message)
+                    results[ext['attributes']['name']] = message
         if len(rules)>0:
             for rule in rules:
                 try:
@@ -981,9 +1015,11 @@ class Synchronizer:
                         ruleId = rule['links']['self'].split('/').pop()
                     else:
                         ruleId = rule['id']
-                    self.syncComponent(componentId=ruleId,publishedVersion=publishedVersion, forceCreation=forceCreation,libraryLinked=libraryLinked,verbose=verbose)
-                except:
-                    print(f'Rule {rule["attributes"]["name"]} could not be updated in the target properties. Please check if the rule exist.')
+                    results[rule['attributes']['name']] = self.syncComponent(componentId=ruleId,publishedVersion=publishedVersion, forceCreation=forceCreation,libraryLinked=libraryLinked,verbose=verbose)
+                except Exception as e:
+                    message = f'Rule {rule["attributes"]["name"]} could not be updated in the target properties: {e}'
+                    print(message)
+                    results[rule['attributes']['name']] = message
         if len(dataelements)>0:
             for de in dataelements:
                 try:
@@ -991,7 +1027,9 @@ class Synchronizer:
                         deId = de['links']['self'].split('/').pop()
                     else:
                         deId = de['id']
-                    self.syncComponent(componentId=deId,publishedVersion=publishedVersion,forceCreation=forceCreation,libraryLinked=libraryLinked,verbose=verbose)
-                except:
-                    print(f'Data Element {de["attributes"]["name"]} could not be updated in the target properties. Please check if the data element exist.')
-        return 
+                    results[de['attributes']['name']] = self.syncComponent(componentId=deId,publishedVersion=publishedVersion,forceCreation=forceCreation,libraryLinked=libraryLinked,verbose=verbose)
+                except Exception as e:
+                    message = f'Data Element {de["attributes"]["name"]} could not be updated in the target properties: {e}'
+                    print(message)
+                    results[de['attributes']['name']] = message
+        return results

{launchpy-0.5.0 → launchpy-0.5.1/launchpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.0
+Version: 0.5.1
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0
@@ -12,13 +12,11 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas

{launchpy-0.5.0 → launchpy-0.5.1}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
 description = "Adobe Launch API wrapper"
 dynamic = ["version"]
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.12"
 keywords = ["adobe", "analytics", "API", "python"]
 license = {text = "Apache License 2.0"}
 classifiers = [
@@ -19,8 +19,6 @@ classifiers = [
     "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Topic :: Scientific/Engineering :: Information Analysis",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",

launchpy-0.5.0/launchpy/__version__.py

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