launchpy 0.5.0.post1__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.0.post1
+Version: 0.5.2
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0
@@ -12,8 +12,6 @@ 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
@@ -36,6 +34,10 @@ Dynamic: license-file
 Python wrapper for the Adobe Launch API.\
 This module is named launchpy.
 
+Current version: **0.5.2**. This version fixes GET retries and adds automatic
+HTTP 429 retries across all five connector methods. See the
+[0.5.2 release notes](./docs/releases.md#052) for details.
+
 ## Installation
 
 You can install the module by realising the following pip command:\
@@ -68,3 +70,29 @@ Most of the documentation has been imported from the datanalyst website [here](.
 ## Release information
 
 You can find release information [here](./docs/releases.md).
+
+## HTTP retries
+
+The `AdobeRequest` connector always retries HTTP 429 responses for GET, POST,
+PUT, PATCH, and DELETE, even when their body is not JSON or `retry=0`.
+Rate-limit retries have no attempt limit and do not consume the configured
+`retry` budget. A request can therefore keep waiting while the API remains
+rate limited; it can be interrupted normally.
+
+The connector
+honors `Retry-After` in seconds or HTTP-date format; absent or invalid values
+use exponential backoff starting at 45 seconds and capped at 300 seconds.
+The JSON-returning methods also always retry Adobe error code `429050`.
+
+The `retry` setting is reserved for other retryable errors: currently, GET
+responses that cannot be decoded as JSON. It specifies the number of
+**additional attempts**, with a default of `0`. Set
+`property.connector.retry = 3` or pass `retry=3` to a connector method to
+override this budget; neither setting limits rate-limit retries.
+
+Successful return values are unchanged: DELETE returns the HTTP status code,
+while the other methods return decoded JSON. GET also retries invalid JSON
+responses with a 30-second delay. Invalid JSON from write operations and
+network exceptions do not trigger retries, to avoid replaying writes that
+may already have succeeded. This policy applies to the five connector methods,
+not the separate OAuth token request or async property-extraction requests.

launchpy-0.5.2/README.md

@@ -0,0 +1,67 @@
+# Launchpy
+
+Python wrapper for the Adobe Launch API.\
+This module is named launchpy.
+
+Current version: **0.5.2**. This version fixes GET retries and adds automatic
+HTTP 429 retries across all five connector methods. See the
+[0.5.2 release notes](./docs/releases.md#052) for details.
+
+## Installation
+
+You can install the module by realising the following pip command:\
+`pip install launchpy`
+
+You can access the version of the module that you run via the following attribute:\
+`launchpy.__version__`
+
+## Content of the module
+
+This module is built around 7 main parts:
+
+- Helping functions [Core Components](./docs/main.md)
+- Admin instantiating functions [Admin Class](./docs/admin.md)
+- Managing properties [Property Class](./docs/property.md)
+- Managing Publishing Cycle [Library Class](./docs/library.md)
+- Translator functionationality [Translator Class](./docs/translator.md)
+- Synchronizer [Synchronizer Class](./docs/synchronizer.md)
+- Command Line Interface [CLI](./docs/cli.md)
+
+## Get Started
+
+A [get started guide](./docs/getstarted.md) has been created to explain the different functionality.
+You can find a more detail description functionalities at [datanalyst.info](https://datanalyst.info).
+
+## Main documentation
+
+Most of the documentation has been imported from the datanalyst website [here](./docs/main.md).
+
+## Release information
+
+You can find release information [here](./docs/releases.md).
+
+## HTTP retries
+
+The `AdobeRequest` connector always retries HTTP 429 responses for GET, POST,
+PUT, PATCH, and DELETE, even when their body is not JSON or `retry=0`.
+Rate-limit retries have no attempt limit and do not consume the configured
+`retry` budget. A request can therefore keep waiting while the API remains
+rate limited; it can be interrupted normally.
+
+The connector
+honors `Retry-After` in seconds or HTTP-date format; absent or invalid values
+use exponential backoff starting at 45 seconds and capped at 300 seconds.
+The JSON-returning methods also always retry Adobe error code `429050`.
+
+The `retry` setting is reserved for other retryable errors: currently, GET
+responses that cannot be decoded as JSON. It specifies the number of
+**additional attempts**, with a default of `0`. Set
+`property.connector.retry = 3` or pass `retry=3` to a connector method to
+override this budget; neither setting limits rate-limit retries.
+
+Successful return values are unchanged: DELETE returns the HTTP status code,
+while the other methods return decoded JSON. GET also retries invalid JSON
+responses with a 30-second delay. Invalid JSON from write operations and
+network exceptions do not trigger retries, to avoid replaying writes that
+may already have succeeded. This policy applies to the five connector methods,
+not the separate OAuth token request or async property-extraction requests.

{launchpy-0.5.0.post1 → launchpy-0.5.2}/docs/releases.md

@@ -3,6 +3,21 @@
 This page gathered the changes made between version of the launchpy module.\
 This has been started after the 0.3.0 release.\
 
+## 0.5.2
+* Fixing recursive GET retries and always retrying HTTP 429 responses for GET, POST, PUT, PATCH, and DELETE.
+* Respecting `Retry-After` seconds and HTTP dates, with exponential backoff when the header is absent or invalid.
+* Keeping rate-limit retries independent of the connector's `retry` budget and per-call overrides, including when `retry=0`. Other retryable errors remain bounded by that budget.
+* Preserving DELETE request bodies when sending and retrying requests.
+
+## 0.5.1
+* Raising the minimum supported Python version from 3.10 to 3.12.
+* `syncComponent` now returns a dictionary of per-target status messages. `syncComponents`, `syncRules`, `syncDataElements`, `syncExtensions`, and `syncFromLibrary` now return results grouped by component name or ID, including error messages when library synchronization fails.
+* Updating the CLI synchronization commands to report missing components instead of always reporting success. Successful per-target operations are displayed when verbose mode is enabled.
+* Adding the `-v` / `--verbose` flag to the `sync_rules`, `sync_data_elements`, and `upgrade_extension` CLI commands.
+* `checkExtensionUpdate` now raises a descriptive error when the requested extension is not installed, including the installed extension names.
+* `upgradeTargetExtension` now respects the `platform` parameter and returns per-target upgrade, already-up-to-date, or failure messages. The CLI displays upgrade failures instead of reporting success.
+* Fixing library-linked component preparation when no library component was retrieved, avoiding an uninitialized-variable error.
+
 ## 0.5.0
 * Fixing the `create_property` method in the CLI
 * Adding support for multi-org config files.

launchpy-0.5.2/launchpy/__version__.py

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

{launchpy-0.5.0.post1 → launchpy-0.5.2}/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.2/launchpy/connector.py

@@ -0,0 +1,193 @@
+import os
+import json
+import logging
+import time
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+from typing import Any, Dict, Union
+from copy import deepcopy
+# Non standard libraries
+import requests
+from launchpy import config, configs
+
+class AdobeRequest:
+    """
+    Handle request to Audience Manager and taking care that the request have a valid token set each time.
+    """
+
+    def __init__(self,
+                 config_objects: dict = config.config_objects,
+                 headers: dict = config.headers,
+                 org_name: str = None,
+                 verbose: bool = False,
+                 retry: int = 0
+                ) -> None:
+        """
+        Set the connector to be used for handling request to AAM
+        Arguments:
+            config_objects : OPTIONAL : Require the importConfig file to have been used.
+            headers : OPTIONAL : header of the config modules
+            verbose : OPTIONAL : display comment on the request.
+            retry : OPTIONAL : Number of additional attempts for GET responses
+                that cannot be decoded as JSON. Default: 0.
+                Rate-limited requests always retry and do not consume this budget.
+        """
+        if org_name is None:
+            if len(config_objects) >= 1:
+                self.config_key = list(config_objects.keys())[0]
+                config_object = config_objects[self.config_key]
+        else:
+            if org_name in config_objects.keys():
+                self.config_key = org_name
+                config_object = config_objects[self.config_key]
+            else:
+                raise ValueError(f"Configuration for org_name '{org_name}' not found.")
+        if config_object['org_id'] == '':
+            raise Exception(
+                'You have to upload the configuration file with importConfigFile method.')
+        self.config = {self.config_key: deepcopy(config_object)}
+        header = headers[self.config_key]
+        self.header = deepcopy(header)
+        self.retry = retry
+        if self.config[self.config_key].get('token', '') == '' or time.time() > self.config[self.config_key].get('date_limit', 0):
+            if 'scopes' in self.config[self.config_key].keys() and self.config[self.config_key].get('scopes',None) is not None:
+                self.connectionType = 'oauthV2'
+                token_and_expiry = self.get_oauth_token_and_expiry_for_config(config=self.config[self.config_key], verbose=verbose)
+            else:
+                raise ValueError("Invalid configuration: missing 'scopes' for OAuth V2 authentication.")
+            token = token_and_expiry['token']
+            expiry = token_and_expiry['expiry']
+            self.token = deepcopy(token)
+            self.config[self.config_key]['token'] = deepcopy(token)
+            self.config[self.config_key]['date_limit'] = deepcopy(time.time() + expiry - 500)
+            self.header.update({'Authorization': f'Bearer {token}'})
+    
+    def get_oauth_token_and_expiry_for_config(self,config:dict,verbose:bool=False,save:bool=False)->Dict[str,str]:
+        """
+        Retrieve the access token by using the OAuth information provided by the user
+        during the import importConfigFile function.
+        Arguments :
+            config : REQUIRED : Configuration object.
+            verbose : OPTIONAL : Default False. If set to True, print information.
+            save : OPTIONAL : Default False. If set to True, save the token in the 'token.txt' file.
+        """
+        if config is None:
+            raise ValueError("config dictionary is required")
+        oauth_payload = {
+            "grant_type": "client_credentials",
+            "client_id": config["client_id"],
+            "client_secret": config["secret"],
+            "scope": config["scopes"]
+        }
+        response = requests.post(
+            config["oauthTokenEndpointV2"], data=oauth_payload)
+        json_response = response.json()
+        if 'access_token' in json_response.keys():
+            token = json_response['access_token']
+            expiry = json_response["expires_in"]
+        else:
+            return json.dumps(json_response,indent=2)
+        if save:
+            with open('token.txt', 'w') as f:
+                f.write(token)
+        if verbose:
+            print('token valid till : ' + time.ctime(time.time() + expiry))
+        return {'token': token, 'expiry': expiry}
+
+    def _checkingDate(self) -> None:
+        """
+        Checking if the token is still valid
+        """
+        now = time.time()
+        if now > self.config[self.config_key]['date_limit']:
+            if self.connectionType =='oauthV2':
+                token_and_expiry = self.get_oauth_token_and_expiry_for_config(config=self.config[self.config_key], verbose=False)
+            token = token_and_expiry['token']
+            self.config[self.config_key]['token'] = deepcopy(token)
+            self.config[self.config_key]['date_limit'] = deepcopy(time.time() + token_and_expiry['expiry'] - 500)
+            self.header.update({'Authorization': f'Bearer {token}'})
+
+    @staticmethod
+    def _retry_delay(response: requests.Response, attempt: int) -> float:
+        retry_after = response.headers.get("Retry-After")
+        if retry_after is not None:
+            try:
+                seconds = int(retry_after)
+                if seconds >= 0:
+                    return float(seconds)
+            except ValueError:
+                try:
+                    retry_at = parsedate_to_datetime(retry_after)
+                    return max(0.0, (retry_at - datetime.now(timezone.utc)).total_seconds())
+                except (TypeError, ValueError, OverflowError):
+                    pass
+        return min(45 * 2 ** min(attempt, 3), 300)
+
+    def _request(self, method: str, endpoint: str, params: dict | None = None,
+                 data: Any = None, headers: dict | None = None, *,
+                 retry: int | None = None, verbose: bool = False) -> Any:
+        retries = self.retry if retry is None else retry
+        if isinstance(retries, bool) or not isinstance(retries, int) or retries < 0:
+            raise ValueError("retry must be a non-negative integer")
+        request_kwargs: dict[str, Any] = {}
+        if params is not None:
+            request_kwargs["params"] = params
+        if data is not None:
+            request_kwargs["data"] = data if method == "get" else json.dumps(data)
+        attempt = 0
+        rate_limit_attempt = 0
+        while True:
+            self._checkingDate()
+            response = getattr(requests, method)(
+                endpoint, headers=self.header if headers is None else headers, **request_kwargs)
+            if verbose:
+                print(f"request URL : {response.request.url}")
+                print(f"status_code : {response.status_code}")
+            rate_limited = response.status_code == 429
+            if not rate_limited:
+                if method == "delete":
+                    return response.status_code
+                try:
+                    result = response.json()
+                except ValueError:
+                    if method == "get" and attempt < retries:
+                        time.sleep(30)
+                        attempt += 1
+                        continue
+                    logging.getLogger(__name__).warning(
+                        "%s request returned invalid JSON (HTTP %s)",
+                        method.upper(), response.status_code)
+                    return {"error": "Request Error"}
+                rate_limited = isinstance(result, dict) and result.get("error_code") == "429050"
+                if not rate_limited:
+                    return result
+            delay = self._retry_delay(response, rate_limit_attempt)
+            if verbose:
+                print(f"Rate limited; retrying in {delay:g} seconds")
+            time.sleep(delay)
+            rate_limit_attempt += 1
+
+    def getData(self, endpoint: str, params: dict = None, data: dict = None, headers: dict = None, *args, **kwargs):
+        """Get JSON data, always retrying rate limits independently of retry."""
+        return self._request("get", endpoint, params, data, headers,
+                             retry=kwargs.get("retry"), verbose=kwargs.get("verbose", False))
+
+    def postData(self, endpoint: str, params: dict = None, data: dict = None, headers: dict = None, *args, **kwargs):
+        """Post JSON data, always retrying rate limits."""
+        return self._request("post", endpoint, params, data, headers,
+                             retry=kwargs.get("retry"), verbose=kwargs.get("verbose", False))
+
+    def patchData(self, endpoint: str, params: dict = None, data=None, headers: dict = None, *args, **kwargs):
+        """Patch JSON data, always retrying rate limits."""
+        return self._request("patch", endpoint, params, data, headers,
+                             retry=kwargs.get("retry"), verbose=kwargs.get("verbose", False))
+
+    def putData(self, endpoint: str, params: dict = None, data=None, headers: dict = None, *args, **kwargs):
+        """Put JSON data, always retrying rate limits."""
+        return self._request("put", endpoint, params, data, headers,
+                             retry=kwargs.get("retry"), verbose=kwargs.get("verbose", False))
+
+    def deleteData(self, endpoint: str, params: dict = None, data=None, headers: dict = None, *args, **kwargs):
+        """Delete data and return the HTTP status, always retrying rate limits."""
+        return self._request("delete", endpoint, params, data, headers,
+                             retry=kwargs.get("retry"), verbose=kwargs.get("verbose", False))

{launchpy-0.5.0.post1 → launchpy-0.5.2}/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']: