launchpy 0.5.1__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.1
+Version: 0.5.2
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0
@@ -34,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:\
@@ -66,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.1 → 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.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.1 → launchpy-0.5.2/launchpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.1
+Version: 0.5.2
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0
@@ -34,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:\
@@ -66,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.1 → launchpy-0.5.2}/launchpy.egg-info/SOURCES.txt

@@ -28,4 +28,5 @@ launchpy.egg-info/entry_points.txt
 launchpy.egg-info/requires.txt
 launchpy.egg-info/top_level.txt
 launchpy/cli/__init__.py
-launchpy/cli/__main__.py
+launchpy/cli/__main__.py
+tests/test_connector.py

launchpy-0.5.2/tests/test_connector.py

@@ -0,0 +1,253 @@
+import json
+import unittest
+from datetime import datetime, timedelta, timezone
+from email.utils import format_datetime
+from unittest.mock import Mock, patch
+
+import requests
+
+from launchpy.connector import AdobeRequest
+
+
+class ConnectorRetryTests(unittest.TestCase):
+    methods = ("get", "post", "put", "patch", "delete")
+    endpoint = "https://example.invalid/components"
+
+    def setUp(self):
+        self.connector = AdobeRequest.__new__(AdobeRequest)
+        self.connector.header = {"Authorization": "test"}
+        self.connector.retry = 2
+        self.connector._checkingDate = Mock()
+        sleep_patch = patch("launchpy.connector.time.sleep")
+        self.sleep = sleep_patch.start()
+        self.addCleanup(sleep_patch.stop)
+
+    def response(self, status=200, payload=None, headers=None, body=None):
+        response = requests.Response()
+        response.status_code = status
+        response.headers.update(headers or {})
+        response._content = (
+            body.encode() if body is not None else json.dumps(payload).encode()
+        )
+        response.request = requests.Request("GET", self.endpoint).prepare()
+        return response
+
+    def call(self, method, **kwargs):
+        return getattr(self.connector, method + "Data")(self.endpoint, **kwargs)
+
+    def test_consecutive_429s_retry_all_methods_and_preserve_request(self):
+        for method in self.methods:
+            with self.subTest(method=method):
+                self.sleep.reset_mock()
+                self.connector._checkingDate.reset_mock()
+                limited = self.response(429, headers={"Retry-After": "2"}, body="not JSON")
+                success = self.response(204 if method == "delete" else 200, {"data": []})
+                with patch(f"launchpy.connector.requests.{method}",
+                           side_effect=[limited, limited, success]) as request:
+                    result = self.call(method, params={"page": 1}, data={"value": 1},
+                                       headers={"X-Test": "custom"})
+                self.assertEqual(result, 204 if method == "delete" else {"data": []})
+                self.assertEqual(request.call_count, 3)
+                self.assertEqual(self.connector._checkingDate.call_count, 3)
+                expected_data = {"value": 1} if method == "get" else '{"value": 1}'
+                for call in request.call_args_list:
+                    self.assertEqual(call.args, (self.endpoint,))
+                    self.assertEqual(call.kwargs, {
+                        "headers": {"X-Test": "custom"},
+                        "params": {"page": 1},
+                        "data": expected_data,
+                    })
+                self.assertEqual([call.args for call in self.sleep.call_args_list],
+                                 [(2.0,), (2.0,)])
+
+    def test_rate_limits_retry_beyond_budget_with_capped_backoff(self):
+        for method in self.methods:
+            with self.subTest(method=method):
+                self.sleep.reset_mock()
+                limited = self.response(429)
+                success = self.response(204 if method == "delete" else 200, {"data": []})
+                with patch(f"launchpy.connector.requests.{method}",
+                           side_effect=[limited] * 5 + [success]) as request:
+                    self.assertEqual(self.call(method),
+                                     204 if method == "delete" else {"data": []})
+                self.assertEqual(request.call_count, 6)
+                self.assertEqual([call.args for call in self.sleep.call_args_list],
+                                 [(45,), (90,), (180,), (300,), (300,)])
+
+    def test_rate_limits_ignore_per_call_retry_override(self):
+        for method in self.methods:
+            for retries in (0, 1, 3):
+                with self.subTest(method=method, retry=retries):
+                    self.sleep.reset_mock()
+                    success = self.response(204 if method == "delete" else 200, {"data": []})
+                    with patch(f"launchpy.connector.requests.{method}",
+                               side_effect=[self.response(429)] * 4 + [success]) as request:
+                        self.assertEqual(self.call(method, retry=retries),
+                                         204 if method == "delete" else {"data": []})
+                    self.assertEqual(request.call_count, 5)
+                    self.assertEqual(self.sleep.call_count, 4)
+                    self.assertEqual(self.connector.retry, 2)
+
+    def test_rate_limits_retry_with_zero_budget(self):
+        self.connector.retry = 0
+        for method in self.methods:
+            with self.subTest(method=method):
+                self.sleep.reset_mock()
+                success = self.response(204 if method == "delete" else 200, {"data": []})
+                with patch(f"launchpy.connector.requests.{method}",
+                           side_effect=[self.response(429)] * 3 + [success]) as request:
+                    self.assertEqual(self.call(method),
+                                     204 if method == "delete" else {"data": []})
+                self.assertEqual(request.call_count, 4)
+                self.assertEqual(self.sleep.call_count, 3)
+
+    def test_adobe_rate_limit_code(self):
+        self.connector.retry = 0
+        for method in ("get", "post", "put", "patch"):
+            with self.subTest(method=method):
+                self.sleep.reset_mock()
+                with patch(f"launchpy.connector.requests.{method}", side_effect=[
+                    self.response(400, {"error_code": "429050"}),
+                    self.response(200, {"data": []}),
+                ]) as request:
+                    self.assertEqual(self.call(method), {"data": []})
+                self.assertEqual(request.call_count, 2)
+                self.sleep.assert_called_once_with(45)
+
+    def test_retry_after_http_date(self):
+        now = datetime(2026, 10, 5, 10, tzinfo=timezone.utc)
+        for offset, expected in ((20, 20.0), (-20, 0.0)):
+            with self.subTest(offset=offset):
+                response = self.response(429, headers={
+                    "Retry-After": format_datetime(now + timedelta(seconds=offset), usegmt=True),
+                })
+                with patch("launchpy.connector.datetime") as clock:
+                    clock.now.return_value = now
+                    self.assertEqual(self.connector._retry_delay(response, 0), expected)
+
+    def test_retry_after_zero_invalid_and_missing(self):
+        for value, expected in (("0", 0.0), ("invalid", 45), ("-1", 45), (None, 45)):
+            with self.subTest(value=value):
+                headers = {} if value is None else {"Retry-After": value}
+                self.assertEqual(self.connector._retry_delay(self.response(429, headers=headers), 0),
+                                 expected)
+        self.assertEqual(self.connector._retry_delay(self.response(429), 100), 300)
+
+    def test_successful_return_types_and_empty_requests(self):
+        for method in self.methods:
+            with self.subTest(method=method):
+                response = self.response(204, body="") if method == "delete" else self.response(
+                    200, ["one", "two"])
+                with patch(f"launchpy.connector.requests.{method}", return_value=response) as request:
+                    self.assertEqual(self.call(method), 204 if method == "delete" else ["one", "two"])
+                request.assert_called_once_with(self.endpoint, headers=self.connector.header)
+        self.sleep.assert_not_called()
+
+    def test_get_json_decode_failure_retries(self):
+        with patch("launchpy.connector.requests.get", side_effect=[
+            self.response(body="invalid JSON"), self.response(payload={"data": []}),
+        ]) as request:
+            self.assertEqual(self.call("get"), {"data": []})
+        self.assertEqual(request.call_count, 2)
+        self.sleep.assert_called_once_with(30)
+
+    def test_rate_limits_neither_consume_nor_reset_other_error_budget(self):
+        with patch("launchpy.connector.requests.get", side_effect=[
+            self.response(body="invalid JSON"),
+            self.response(429),
+            self.response(429),
+            self.response(body="invalid JSON"),
+            self.response(429),
+            self.response(body="invalid JSON"),
+        ]) as request:
+            with self.assertLogs("launchpy.connector", level="WARNING"):
+                self.assertEqual(self.call("get"), {"error": "Request Error"})
+        self.assertEqual(request.call_count, 6)
+        self.assertEqual([call.args for call in self.sleep.call_args_list],
+                         [(30,), (45,), (90,), (30,), (180,)])
+
+    def test_per_call_budget_still_limits_other_errors(self):
+        for retries in (0, 1, 3):
+            with self.subTest(retry=retries):
+                self.sleep.reset_mock()
+                with patch("launchpy.connector.requests.get",
+                           return_value=self.response(body="invalid JSON")) as request:
+                    with self.assertLogs("launchpy.connector", level="WARNING"):
+                        self.assertEqual(self.call("get", retry=retries),
+                                         {"error": "Request Error"})
+                self.assertEqual(request.call_count, retries + 1)
+                self.assertEqual(self.sleep.call_count, retries)
+                self.assertEqual(self.connector.retry, 2)
+
+    def test_rate_limit_wait_can_be_interrupted(self):
+        self.sleep.side_effect = KeyboardInterrupt
+        with patch("launchpy.connector.requests.get",
+                   return_value=self.response(429)) as request:
+            with self.assertRaises(KeyboardInterrupt):
+                self.call("get")
+        request.assert_called_once()
+
+    def test_retries_use_refreshed_default_headers(self):
+        def refresh_headers():
+            self.connector.header = {"Authorization": str(
+                self.connector._checkingDate.call_count)}
+
+        self.connector._checkingDate.side_effect = refresh_headers
+        with patch("launchpy.connector.requests.post", side_effect=[
+            self.response(429), self.response(payload={"data": []}),
+        ]) as request:
+            self.assertEqual(self.call("post"), {"data": []})
+        self.assertEqual(request.call_args_list[0].kwargs["headers"],
+                         {"Authorization": "1"})
+        self.assertEqual(request.call_args_list[1].kwargs["headers"],
+                         {"Authorization": "2"})
+
+    def test_invalid_json_write_is_not_replayed(self):
+        for method in ("post", "put", "patch"):
+            with self.subTest(method=method):
+                with patch(f"launchpy.connector.requests.{method}",
+                           return_value=self.response(body="invalid JSON")) as request:
+                    with self.assertLogs("launchpy.connector", level="WARNING"):
+                        self.assertEqual(self.call(method), {"error": "Request Error"})
+                request.assert_called_once()
+        self.sleep.assert_not_called()
+
+    def test_get_json_decode_exhaustion_is_logged(self):
+        with patch("launchpy.connector.requests.get",
+                   return_value=self.response(body="invalid JSON")) as request:
+            with self.assertLogs("launchpy.connector", level="WARNING"):
+                self.assertEqual(self.call("get"), {"error": "Request Error"})
+        self.assertEqual(request.call_count, 3)
+        self.assertEqual(self.sleep.call_count, 2)
+
+    def test_other_http_errors_are_not_retried(self):
+        for method in self.methods:
+            with self.subTest(method=method):
+                payload = {"errors": ["bad request"]}
+                with patch(f"launchpy.connector.requests.{method}",
+                           return_value=self.response(400, payload)) as request:
+                    self.assertEqual(self.call(method), 400 if method == "delete" else payload)
+                request.assert_called_once()
+        self.sleep.assert_not_called()
+
+    def test_network_errors_propagate_without_replaying_writes(self):
+        for method in self.methods:
+            with self.subTest(method=method):
+                with patch(f"launchpy.connector.requests.{method}",
+                           side_effect=requests.ConnectionError("connection failed")) as request:
+                    with self.assertRaises(requests.ConnectionError):
+                        self.call(method)
+                request.assert_called_once()
+        self.sleep.assert_not_called()
+
+    def test_invalid_retry_budget_is_rejected(self):
+        for value in (-1, 1.5, "2", True):
+            with self.subTest(value=value):
+                with patch("launchpy.connector.requests.get") as request:
+                    with self.assertRaises(ValueError):
+                        self.call("get", retry=value)
+                request.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

launchpy-0.5.1/README.md

@@ -1,37 +0,0 @@
-# Launchpy
-
-Python wrapper for the Adobe Launch API.\
-This module is named launchpy.
-
-## 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).

launchpy-0.5.1/launchpy/__version__.py

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

launchpy-0.5.1/launchpy/connector.py

@@ -1,237 +0,0 @@
-import os
-import json
-import time
-from typing import 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 : If you wish to retry failed GET requests
-        """
-        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}'})
-
-    def getData(self, endpoint: str, params: dict = None, data: dict = None, headers: dict = None, *args, **kwargs):
-        """
-        Abstraction for getting data
-        """
-        internRetry = self.retry - kwargs.get("retry", 0)
-        self._checkingDate()
-        if headers is None:
-            headers = self.header
-        if params is None and data is None:
-            res = requests.get(
-                endpoint, headers=headers)
-        elif params is not None and data is None:
-            res = requests.get(
-                endpoint, headers=headers, params=params)
-        elif params is None and data is not None:
-            res = requests.get(
-                endpoint, headers=headers, data=data)
-        elif params is not None and data is not None:
-            res = requests.get(endpoint, headers=headers, params=params, data=data)
-        if kwargs.get("verbose", False):
-            print(f"request URL : {res.request.url}")
-            print(f"statut_code : {res.status_code}")
-        try:
-            if res.status_code == 429:
-                if kwargs.get("verbose", False):
-                    print(f'Too many requests')
-                time.sleep(45)
-                res_json = self.getData(endpoint, params=params, data=data, headers=headers, retry=internRetry, **kwargs)
-                return res_json
-            res_json = res.json()
-        except:
-            res_json = {'error': 'Request Error'}
-            while internRetry > 0:
-                internRetry -= 1
-                if kwargs.get("verbose", False):
-                    print('Retry parameter activated')
-                    print(f'{internRetry} retry left')
-                if 'error' in res_json.keys():
-                    time.sleep(30)
-                    res_json = self.getData(endpoint, params=params, data=data, headers=headers, retry=internRetry, **kwargs)
-                    return res_json
-        return res_json
-
-    def postData(self, endpoint: str, params: dict = None, data: dict = None, headers: dict = None, *args, **kwargs):
-        """
-        Abstraction for posting data
-        """
-        self._checkingDate()
-        if headers is None:
-            headers = self.header
-        if params is None and data is None:
-            res = requests.post(endpoint, headers=headers)
-        elif params is not None and data is None:
-            res = requests.post(endpoint, headers=headers, params=params)
-        elif params is None and data is not None:
-            res = requests.post(endpoint, headers=headers, data=json.dumps(data))
-        elif params is not None and data is not None:
-            res = requests.post(endpoint, headers=headers, params=params, data=json.dumps(data))
-        try:
-            res_json = res.json()
-            if res.status_code == 429 or res_json.get('error_code', None) == "429050":
-                time.sleep(45)
-                res_json = self.postData(endpoint, params=params, data=data, headers=headers, **kwargs)
-                return res_json
-        except:
-            if kwargs.get("verbose", False):
-                print("status_code: {res.status_code}")
-                print(res.text)
-            res_json = {'error': 'Request Error'}
-        return res_json
-
-    def patchData(self, endpoint: str, params: dict = None, data=None, headers: dict = None, *args, **kwargs):
-        """
-        Abstraction for deleting data
-        """
-        self._checkingDate()
-        if headers is None:
-            headers = self.header
-        if params is not None and data is None:
-            res = requests.patch(endpoint, headers=headers, params=params)
-        elif params is None and data is not None:
-            res = requests.patch(endpoint, headers=headers, data=json.dumps(data))
-        elif params is not None and data is not None:
-            res = requests.patch(endpoint, headers=headers, params=params, data=json.dumps(data))
-        try:
-            status_code = res.json()
-        except:
-            if kwargs.get("verbose", False):
-                print(res.text)
-            status_code = {'error': 'Request Error'}
-        return status_code
-
-    def putData(self, endpoint: str, params: dict = None, data=None, headers: dict = None, *args, **kwargs):
-        """
-        Abstraction for deleting data
-        """
-        self._checkingDate()
-        if headers is None:
-            headers = self.header
-        if params is not None and data is None:
-            res = requests.put(endpoint, headers=headers, params=params)
-        elif params is None and data is not None:
-            res = requests.put(endpoint, headers=headers, data=json.dumps(data))
-        elif params is not None and data is not None:
-            res = requests.put(endpoint, headers=headers, params=params, data=json.dumps(data))
-        try:
-            status_code = res.json()
-        except:
-            if kwargs.get("verbose", False):
-                print(res.text)
-            status_code = {'error': 'Request Error'}
-        return status_code
-
-    def deleteData(self, endpoint: str, params: dict = None, data=None, headers: dict = None, *args, **kwargs):
-        """
-        Abstraction for deleting data
-        """
-        self._checkingDate()
-        if headers is None:
-            headers = self.header
-        if params is None:
-            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:
-            status_code = {'error': 'Request Error'}
-        return status_code