launchpy 0.5.2__tar.gz → 0.5.3__tar.gz

{launchpy-0.5.2 → launchpy-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.2
+Version: 0.5.3
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0
@@ -71,6 +71,30 @@ Most of the documentation has been imported from the datanalyst website [here](.
 
 You can find release information [here](./docs/releases.md).
 
+## Proxy support
+
+Pass a `proxy` URL to `launchpy.configure(...)`, or add `"proxy"` to
+your JSON configuration file. The same proxy serves both HTTP and HTTPS.
+Proxy settings apply to OAuth authentication,
+API requests, and asynchronous property exports, with separate settings per
+organization.
+
+```python
+launchpy.configure(
+    org_id="your-org@AdobeOrg",
+    client_id="your-client-id",
+    secret="your-secret",
+    scopes="your-scopes",
+    proxy="http://proxy.example.com:8080",
+)
+```
+
+The CLI accepts `--proxy URL` at startup and in the interactive `config`
+command. An explicit CLI proxy overrides the file setting.
+Without an explicit proxy, existing environment-based proxy behavior is unchanged.
+See the [Python and JSON examples](./docs/getstarted.md#proxy-configuration)
+and [CLI examples](./docs/cli.md#proxy-configuration).
+
 ## HTTP retries
 
 The `AdobeRequest` connector always retries HTTP 429 responses for GET, POST,

{launchpy-0.5.2 → launchpy-0.5.3}/README.md

@@ -40,6 +40,30 @@ Most of the documentation has been imported from the datanalyst website [here](.
 
 You can find release information [here](./docs/releases.md).
 
+## Proxy support
+
+Pass a `proxy` URL to `launchpy.configure(...)`, or add `"proxy"` to
+your JSON configuration file. The same proxy serves both HTTP and HTTPS.
+Proxy settings apply to OAuth authentication,
+API requests, and asynchronous property exports, with separate settings per
+organization.
+
+```python
+launchpy.configure(
+    org_id="your-org@AdobeOrg",
+    client_id="your-client-id",
+    secret="your-secret",
+    scopes="your-scopes",
+    proxy="http://proxy.example.com:8080",
+)
+```
+
+The CLI accepts `--proxy URL` at startup and in the interactive `config`
+command. An explicit CLI proxy overrides the file setting.
+Without an explicit proxy, existing environment-based proxy behavior is unchanged.
+See the [Python and JSON examples](./docs/getstarted.md#proxy-configuration)
+and [CLI examples](./docs/cli.md#proxy-configuration).
+
 ## HTTP retries
 
 The `AdobeRequest` connector always retries HTTP 429 responses for GET, POST,

{launchpy-0.5.2 → launchpy-0.5.3}/docs/cli.md

@@ -10,6 +10,7 @@ This document provides an overview of the command line interface (CLI) for `laun
     - [Instantiation](#instantiation)
       - [create\_config\_file](#create_config_file)
       - [config](#config)
+      - [Proxy configuration](#proxy-configuration)
       - [change\_org](#change_org)
       - [get\_properties](#get_properties)
       - [create\_property](#create_property)
@@ -148,6 +149,7 @@ Arguments
 `-cf`,`--config_file`: The path to the config file that contains your credentials and other necessary information.
 `-p`,`--property` : The property name to be used and directly instantiated the property layer. This is an optional parameter.
 `-on`,`--org_name`: The organization name to use when your `--config_file` is a multi-org config file (see [create_config_file](#create_config_file)). This is an optional parameter, it defaults to the first organization found in the file (or `default` when using individual parameters).
+`--proxy`: Proxy URL for both HTTP and HTTPS destinations.
 
 Example via parameters:
 ```bash
@@ -195,6 +197,47 @@ launchpy:client_a>
 When in a non-multi-org environment, the prompt of the CLI will be `launchpy>`, and when in a multi-org environment, the prompt will be `launchpy:<org_name>`, where `<org_name>` is the name of the organization you are currently connected to.\
 By default, the first organization found in the multi-org config file will be used if no `--org_name` is provided. You can switch between organizations using the `change_org` command.
 
+#### Proxy configuration
+
+The single `--proxy` option works both at startup and in the interactive `config` command,
+with either a config file or individual credentials:
+
+```bash
+python -m launchpy.cli --config_file config.json --proxy http://proxy.example.com:8080
+```
+
+```text
+(Cmd) config --config_file config.json --proxy http://proxy.example.com:8080
+(Cmd) config --client_id <client_id> --secret <secret> --org_id <org_id> --scopes <scopes> --proxy http://proxy.example.com:8080
+```
+
+You can also store a single `proxy` URL in the JSON file:
+
+```json
+{
+    "org_id": "your-org@AdobeOrg",
+    "client_id": "your-client-id",
+    "secret": "your-secret",
+    "scopes": "your-scopes",
+    "proxy": "http://proxy.example.com:8080"
+}
+```
+
+The same proxy is used for both HTTP and HTTPS destinations. `--proxy` overrides
+the file's proxy URL. For multi-org files, put `proxy` in each organization's
+object; `--proxy` overrides it for every organization loaded from that file.
+`change_org` preserves each organization's effective proxy settings.
+
+The proxy covers authentication, token refresh, API calls, and property
+exports. Existing files and commands without proxy options continue to work,
+including environment-based proxy settings. Omitting `proxy` or setting it to
+`null` in JSON does not disable environment proxies. Empty strings and non-string
+values are rejected. TLS verification remains
+enabled. For URL schemes, authentication, and Python configuration examples,
+see [Proxy configuration in Getting Started](./getstarted.md#proxy-configuration).
+Avoid putting proxy credentials on a shared terminal's command line or in
+committed configuration files.
+
 #### change_org
 Switch the current CLI session to another organization that has already been loaded from a multi-org config file (via `config` or `--config_file` at startup). This avoids re-running `config` when you need to move between organizations.\
 Arguments:

{launchpy-0.5.2 → launchpy-0.5.3}/docs/getstarted.md

@@ -101,6 +101,61 @@ So your config file will look like this:
 ```
 
 
+### Proxy configuration
+
+To connect through a proxy, pass the optional `proxy` URL to `configure`.
+The same proxy is used for both HTTP and HTTPS:
+
+```python
+lp.configure(
+    org_id="your-org@AdobeOrg",
+    client_id="your-client-id",
+    secret="your-secret",
+    scopes="your-scopes",
+    proxy="http://proxy.example.com:8080",
+)
+```
+
+Alternatively, add `proxy` to your configuration JSON and load it with
+`lp.importConfigFile("myconfig.json")` as usual:
+
+```json
+{
+    "org_id": "your-org@AdobeOrg",
+    "client_id": "your-client-id",
+    "secret": "your-secret",
+    "scopes": "your-scopes",
+    "proxy": "http://proxy.example.com:8080"
+}
+```
+
+The proxy URL includes its scheme and port.
+An HTTPS destination commonly uses an `http://` proxy
+URL, which tunnels HTTPS with CONNECT; use `https://` only if the proxy itself
+requires TLS. TLS certificate verification remains enabled.
+
+For proxy authentication, use `http://username:password@proxy.example.com:8080`,
+URL-encoding special characters in the username and password. Treat files and
+command-line arguments containing proxy credentials as secrets.
+
+In a multi-org JSON file, put `proxy` inside each organization's object.
+Organizations can use different proxies, or omit the field independently.
+To override the file's proxy for every imported organization, use
+`lp.importConfigFile("myconfig.json", proxy="http://other-proxy:8080")`.
+
+The settings apply to initial OAuth token acquisition, token refresh, all API
+methods and their retries, and asynchronous rule-component downloads during
+`extractProperty`. Configure before creating `Admin`, `Property`, `Library`,
+or `Synchronizer` instances; existing connectors retain their configuration.
+Calling `configure` again without `proxy` clears the previous explicit
+proxy for that organization.
+
+Omitting `proxy` or passing `None` preserves the HTTP libraries'
+normal environment-based behavior (`HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY`,
+and `NO_PROXY`). This does **not** disable environment proxies.
+Empty strings and non-string proxy values are rejected.
+Existing configuration files without a proxy require no changes.
+
 ## 5. Instantiate the Admin class & get Company ID to retrieve properties
 
 Once all of these setup steps are completed, you can instantiate the `Admin` class.

{launchpy-0.5.2 → launchpy-0.5.3}/docs/main.md

@@ -37,6 +37,11 @@ launchpy.importConfigFile('myConfig.json')
 launchpy.config.config_object
 ```
 
+Configuration JSON files can include an optional `proxy` URL, independently
+for each organization in multi-org files. `importConfigFile` also accepts
+`proxy=...` to override the file's proxy for all imported organizations.
+See [Proxy configuration](./getstarted.md#proxy-configuration) for examples.
+
 ### Configure method
 
 The configure method enables you to configure the `config_object` directly from the python console with environment.\
@@ -56,6 +61,12 @@ lp.configure(
 )
 ```
 
+`configure` also accepts `proxy="http://proxy.example.com:8080"`.
+This single URL is used for both HTTP and HTTPS destinations. These settings
+apply to OAuth, API requests, and property exports. Omit the argument to retain
+normal environment-based proxy behavior; configuring an organization again
+without it clears that organization's previous explicit proxy.
+
 ## 1. The Admin class
 
 The Admin methods helps your retrieving vital information to use the API later, such as the companyId.\

{launchpy-0.5.2 → launchpy-0.5.3}/docs/releases.md

@@ -3,6 +3,14 @@
 This page gathered the changes made between version of the launchpy module.\
 This has been started after the 0.3.0 release.\
 
+## 0.5.3
+* Adding optional `proxy` support to `configure`, `importConfigFile`, `createConfigFile` and JSON configuration files. A single proxy URL is used for both HTTP and HTTPS, with separate settings per organization.
+* Applying proxy settings to OAuth token acquisition and refresh, all API requests and their retries, and asynchronous rule-component downloads during `extractProperty`.
+* Adding `--proxy` to CLI startup and the interactive `config` command. Explicit CLI and `importConfigFile` proxy arguments override file settings for all organizations loaded from the file.
+* Preserving environment-based proxy behavior when no explicit proxy is supplied. Existing configuration files require no changes; empty strings and non-string proxy values are rejected.
+* Fixing CLI configuration state and organization selection when `--org_name` is omitted. `change_org` now uses the shared connection setup and preserves each organization's proxy settings.
+* Adding proxy configuration examples and documentation for Python, JSON, and CLI usage.
+
 ## 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.

{launchpy-0.5.2 → launchpy-0.5.3}/launchpy/__init__.py

@@ -5,6 +5,7 @@ May  15 12:04:49 2019
 """
 from launchpy.__version__ import __version__
 from launchpy.configs import *
+from launchpy.configs import _validate_proxy
 from launchpy.library import Library
 from launchpy.admin import Admin
 from launchpy.property import Property
@@ -42,10 +43,13 @@ async def __extractRuleComponents__(rule: dict, client: httpx.AsyncClient, folde
                 json.dump(component, f, indent=4)
 
 # 3. Use an orchestrator instead of ThreadPoolExecutor
-async def process_all_rules(rules_list, folder, header):
+async def process_all_rules(rules_list, folder, header,
+                           proxy: str | None = None):
+    proxy = _validate_proxy(proxy)
     timeout = httpx.Timeout(10.0, read=120.0)
     limits = httpx.Limits(max_connections=100, max_keepalive_connections=50)
-    async with httpx.AsyncClient(timeout=timeout, limits=limits) as client:
+    proxy_kwargs = {"proxy": proxy} if proxy is not None else {}
+    async with httpx.AsyncClient(timeout=timeout, limits=limits, **proxy_kwargs) as client:
         # Create a list of "tasks" to run
         tasks = [__extractRuleComponents__(rule, client, folder, header) for rule in rules_list]
         # 'gather' runs them all concurrently
@@ -90,7 +94,7 @@ def extractProperty(property: dict | Property, publishedVersion: bool = False,fo
             except Exception as e:
                 published_rules.append(rule)
         rules = published_rules
-    asyncio.run(process_all_rules(rules, folder, property.header))
+    asyncio.run(process_all_rules(rules, folder, property.header, property.connector.proxy))
     dataElements = property.getDataElements()
     if publishedVersion:
         published_data_elements = []

launchpy-0.5.3/launchpy/__version__.py

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

{launchpy-0.5.2 → launchpy-0.5.3}/launchpy/cli/__main__.py

@@ -1,5 +1,6 @@
 import launchpy
 from launchpy.config import config_objects, headers
+from launchpy.configs import _validate_proxy
 import argparse, cmd, shlex, json
 from functools import wraps
 from rich.console import Console
@@ -961,6 +962,7 @@ class MainShell(cmd.Cmd):
 
     def __init__(self, **kwargs:ParamSpecKwargs) -> None:
         super().__init__()
+        proxy = _validate_proxy(kwargs.get("proxy"))
         self.admin = None
         self.cid = None
         self.properties = None
@@ -988,12 +990,13 @@ class MainShell(cmd.Cmd):
             with open(config_path, "rb") as f:
                 dict_config = json.load(f)
             if type(dict_config) == dict:
-                config_key = kwargs.get("org_name", "default")
+                config_key = kwargs.get("org_name") or "default"
                 self.config = {config_key: deepcopy(self.config_template)}
                 self.config[config_key]['secret'] = dict_config.get("secret", kwargs.get("secret"))
                 self.config[config_key]['org_id'] = dict_config.get("org_id", kwargs.get("org_id"))
                 self.config[config_key]['client_id'] = dict_config.get("client_id", dict_config.get("api_key", kwargs.get("client_id", kwargs.get("api_key"))))
                 self.config[config_key]['scopes'] = dict_config.get("scopes", kwargs.get("scopes"))
+                self.config[config_key]['proxy'] = proxy if proxy is not None else _validate_proxy(dict_config.get("proxy"))
                 config_objects.update(self.config)
             elif type(dict_config) == list:
                 self.config = {}
@@ -1007,15 +1010,17 @@ class MainShell(cmd.Cmd):
                     self.config[config_key]['org_id'] = config.get("org_id", kwargs.get("org_id"))
                     self.config[config_key]['client_id'] = config.get("client_id", config.get("api_key", kwargs.get("client_id", kwargs.get("api_key"))))
                     self.config[config_key]['scopes'] = config.get("scopes", kwargs.get("scopes"))
+                    self.config[config_key]['proxy'] = proxy if proxy is not None else _validate_proxy(config.get("proxy"))
                 config_objects.update(self.config)
                 config_key = dict_config[0].get("org_name", "default")
         else:
-            config_key = kwargs.get("org_name", "default")
+            config_key = kwargs.get("org_name") or "default"
             self.config = {config_key: deepcopy(self.config_template)}
             self.config[config_key]['secret'] = kwargs.get("secret")
             self.config[config_key]['org_id'] = kwargs.get("org_id")
             self.config[config_key]['client_id'] = kwargs.get("client_id",kwargs.get("api_key"))
             self.config[config_key]['scopes'] = kwargs.get("scopes")
+            self.config[config_key]['proxy'] = proxy
             config_objects.update(self.config)
         if self.config[config_key]['secret'] is not None and self.config[config_key]['org_id'] is not None and self.config[config_key]['client_id'] is not None and self.config[config_key]['scopes'] is not None:
             myheaders = {}
@@ -1024,7 +1029,7 @@ class MainShell(cmd.Cmd):
                 myheaders[org_name]["x-gw-ims-org-id"] = config['org_id']
                 myheaders[org_name]["x-api-key"] = config['client_id']
             headers.update(myheaders)
-            config_key = kwargs.get("org_name", config_key)
+            config_key = kwargs.get("org_name") or config_key
             console.print("Configuring connection...", style="blue")
             self._configure_connection(config_key)
             if kwargs.get("property") is not None:
@@ -1051,13 +1056,15 @@ class MainShell(cmd.Cmd):
         else:
             config_key = list(self.config.keys())[0]
         self.org_name = config_key
-        self.config = launchpy.configure(
+        launchpy.configure(
             secret=config_objects[config_key]['secret'],
             org_id=config_objects[config_key]['org_id'],
             client_id=config_objects[config_key]['client_id'],
             scopes=config_objects[config_key]['scopes'],
-            org_name=config_key
+            org_name=config_key,
+            proxy=config_objects[config_key].get("proxy")
         )
+        self.config = config_objects
         self.admin = launchpy.Admin(org_name=config_key)
         self.cid = self.admin.getCompanyId()
         if config_key == 'default' or config_key is None:
@@ -1075,16 +1082,7 @@ class MainShell(cmd.Cmd):
             if org_name not in config_objects.keys():
                 console.print(f"(!) Error: Organization '{org_name}' not found in the configuration.", style="red")
                 return
-            self.config = launchpy.configure(
-                secret=config_objects[org_name]['secret'],
-                org_id=config_objects[org_name]['org_id'],
-                client_id=config_objects[org_name]['client_id'],
-                scopes=config_objects[org_name]['scopes'],
-                org_name=org_name
-            )
-            self.admin = launchpy.Admin(org_name=org_name)
-            self.cid = self.admin.getCompanyId()
-            self.prompt = f"launchpy:{org_name}> "
+            self._configure_connection(org_name)
             console.print(f"Switched to organization '{org_name}'.", style="green")
         except Exception as e:
             console.print(f"(!) Error: {str(e)}", style="red")
@@ -1097,10 +1095,11 @@ class MainShell(cmd.Cmd):
         parser = argparse.ArgumentParser(prog='create_config_file', add_help=True)
         parser.add_argument("-fn", "--file_name", help="file name for your config file", default="launchpy_config.json",type=str)
         parser.add_argument("-m","--multi_org", help="Enable multi-org configuration", action="store_true", default=False)
+        parser.add_argument("-p","--proxy", help="Enable proxy for the connection", action="store_true", default=False) 
         try:
             args = parser.parse_args(shlex.split(arg))
             filename = args.file_name
-            launchpy.createConfigFile(filename=filename,multi_org=args.multi_org)
+            launchpy.createConfigFile(filename=filename,proxy=args.proxy,multi_org=args.multi_org)
             filename_json = filename + ".json" if not filename.endswith(".json") else filename
             console.print(f"Configuration file created at {Path.cwd() / Path(filename_json)}", style="green")
             return
@@ -1121,8 +1120,10 @@ class MainShell(cmd.Cmd):
         parser.add_argument("-cf", "--config_file", help="Path to config file", default=None)
         parser.add_argument("-p", "--property", help="Property Name to auto-load on startup", default=None)
         parser.add_argument("-on", "--org_name", help="Organization Name to use from config file", default=None)
+        parser.add_argument("--proxy", help="Proxy URL for both HTTP and HTTPS")
         try:
             args = parser.parse_args(shlex.split(arg))
+            proxy = _validate_proxy(args.proxy)
             if args.config_file is not None:
                 config_path = Path(args.config_file)
                 if not config_path.is_absolute():
@@ -1136,6 +1137,7 @@ class MainShell(cmd.Cmd):
                     self.config[config_key]['org_id'] = dict_config.get("org_id", args.org_id)
                     self.config[config_key]['client_id'] = dict_config.get("client_id", dict_config.get("api_key", args.client_id))
                     self.config[config_key]['scopes'] = dict_config.get("scopes", args.scopes)
+                    self.config[config_key]['proxy'] = proxy if proxy is not None else _validate_proxy(dict_config.get("proxy"))
                     config_objects.update(self.config)
                 elif type(dict_config) == list:
                     self.config = {}
@@ -1149,6 +1151,7 @@ class MainShell(cmd.Cmd):
                         self.config[config_key]['org_id'] = config.get("org_id", args.org_id)
                         self.config[config_key]['client_id'] = config.get("client_id", config.get("api_key", args.client_id))
                         self.config[config_key]['scopes'] = config.get("scopes", args.scopes)
+                        self.config[config_key]['proxy'] = proxy if proxy is not None else _validate_proxy(config.get("proxy"))
                     config_objects.update(self.config)
                     config_key = dict_config[0].get("org_name")
             else:
@@ -1160,6 +1163,7 @@ class MainShell(cmd.Cmd):
                 if args.org_id: self.config[config_key]['org_id'] = str(args.org_id)
                 if args.scopes: self.config[config_key]['scopes'] = str(args.scopes)
                 if args.client_id: self.config[config_key]['client_id'] = str(args.client_id)
+                self.config[config_key]['proxy'] = proxy
                 config_objects.update(self.config)
             missing = [
                 key for key, value in {
@@ -1423,6 +1427,7 @@ def main():
     parser.add_argument("-cf", "--config_file", help="Path to config file", default=None)
     parser.add_argument("-p", "--property", help="Property Name to auto-load on startup", default=None)
     parser.add_argument("-on", "--org_name", help="Organization Name to use from config file", default=None)
+    parser.add_argument("--proxy", help="Proxy URL for both HTTP and HTTPS")
     args = parser.parse_args() 
     shell = MainShell(**vars(args))
     try:

{launchpy-0.5.2 → launchpy-0.5.3}/launchpy/configs.py

@@ -3,6 +3,14 @@ from pathlib import Path
 from typing import Optional
 from launchpy.config import config_objects, headers
 
+def _validate_proxy(proxy: str | None) -> str | None:
+    if proxy is None:
+        return None
+    if not isinstance(proxy, str) or not proxy.strip():
+        raise ValueError("`proxy` must be a non-empty proxy URL string.")
+    return proxy
+
+
 def find_path(path: str) -> Optional[Path]:
     """Checks if the file denoted by the specified `path` exists and returns the Path object
     for the file.
@@ -22,7 +30,12 @@ def find_path(path: str) -> Optional[Path]:
         return None
 
 
-def createConfigFile(filename:str='config_launch',auth_type: str = "oauthV2", scope: str = "https://ims-na1.adobelogin.com/s/ent_reactor_admin_sdk", multi_org:bool=False, verbose: object = False)->None:
+def createConfigFile(filename:str='config_launch',
+                    auth_type: str = "oauthV2", 
+                    proxy:bool=False, 
+                    scope: str = "https://ims-na1.adobelogin.com/s/ent_reactor_admin_sdk",
+                    multi_org:bool=False, 
+                    verbose: object = False)->None:
     """
     This function will create a 'config_launch_admin.json' file where you can store your access data. 
     Arguments:
@@ -31,6 +44,9 @@ def createConfigFile(filename:str='config_launch',auth_type: str = "oauthV2", sc
             or 
             scope="https://ims-na1.adobelogin.com/s/ent_reactor_sdk"
         auth_type : OPTIONAL : The type of Oauth type you want to use for your config file. Possible value: "oauthV2"
+        proxy: OPTIONAL : Whether to use a proxy for the connection. Default is False.
+        multi_org: OPTIONAL : Whether to enable multi-organization configuration. Default is False.
+        verbose: OPTIONAL : Whether to print verbose output during the creation of the config file. Default is False.
     """
     json_data = {
         'org_id': '<orgID>',
@@ -39,7 +55,8 @@ def createConfigFile(filename:str='config_launch',auth_type: str = "oauthV2", sc
     }
     if auth_type == 'oauthV2':
         json_data['scopes'] = "<scopes>"
-    
+    if proxy:
+        json_data['proxy'] = "<proxy_url>"
     if multi_org:
         json_data['org_name'] = '<org_name>'
         json_data = [json_data]
@@ -50,8 +67,11 @@ def createConfigFile(filename:str='config_launch',auth_type: str = "oauthV2", sc
     if verbose:
         print(
             f" file created at this location : {os.getcwd()}{os.sep}{filename}")
+    if proxy and verbose:
+        print("Proxy has been enabled for the connection.")
 
-def importConfigFile(path: str = None,auth_type:str=None) -> None:
+def importConfigFile(path: str = None,auth_type:str=None,
+                     proxy: str | None = None) -> None:
     """Reads the file denoted by the supplied `path` and retrieves the configuration information
     from it.
 
@@ -59,6 +79,7 @@ def importConfigFile(path: str = None,auth_type:str=None) -> None:
         path: REQUIRED : path to the configuration file. Can be either a fully-qualified or relative.
         auth_type : OPTIONAL : The type of Auth to be used by default. Detected if none is passed, OauthV2 takes precedence.
                         Possible values: "jwt" or "oauthV2"
+        proxy : OPTIONAL : Proxy URL overriding the file's proxy for all organizations.
     Example of path value.
     "config.json"
     "./config.json"
@@ -89,7 +110,8 @@ def importConfigFile(path: str = None,auth_type:str=None) -> None:
                 "org_id" : provided_config['org_id'],
                 "secret" : provided_config['secret'],
                 "client_id" : client_id,
-                "scope" : provided_config.get('scope')
+                "scope" : provided_config.get('scope'),
+                "proxy": provided_config.get("proxy") if proxy is None else proxy
             }
             if auth_type == 'oauthV2':
                 args["scopes"] = provided_config["scopes"].replace(' ','')
@@ -114,7 +136,8 @@ def importConfigFile(path: str = None,auth_type:str=None) -> None:
                     "secret" : config['secret'],
                     "client_id" : client_id,
                     "org_name" : config['org_name'],
-                    "scope" : config.get('scope')
+                    "scope" : config.get('scope'),
+                    "proxy": config.get("proxy") if proxy is None else proxy
                 }
                 if auth_type == 'oauthV2':
                     args["scopes"] = config["scopes"].replace(' ','')
@@ -156,6 +179,7 @@ def configure(org_id: str = None,
               scopes : str= None,
               scope: str="https://ims-na1.adobelogin.com/s/ent_reactor_admin_sdk",
               org_name: str = "default",
+              proxy: str | None = None,
               **kwargs
               ):
     """Performs programmatic configuration of the API using provided values.
@@ -168,6 +192,8 @@ def configure(org_id: str = None,
         scope : OPTIONAL : Scope that is needed for JWT auth.
         org_name : OPTIONAL : The name of the org for multi-org configuration. If not provided, the "default" org will be used.
             Possible scope: https://www.adobe.io/authentication/auth-methods.html#!AdobeDocs/adobeio-auth/master/JWT/Scopes.md
+        proxy : OPTIONAL : A single proxy URL for both HTTP and HTTPS.
+            Used for OAuth, API calls, and property exports. None preserves environment settings.
     """
     if not org_id:
         raise ValueError("`org_id` must be specified in the configuration.")
@@ -177,6 +203,7 @@ def configure(org_id: str = None,
         raise ValueError("`scopes` must be specified in the configuration.")
     if not secret:
         raise ValueError("`secret` must be specified in the configuration.")
+    proxy = _validate_proxy(proxy)
     header = {"Accept": "application/vnd.api+json;revision=1",
           "Content-Type": "application/vnd.api+json",
           "Authorization": "Bearer ",
@@ -204,6 +231,7 @@ def configure(org_id: str = None,
     config_object[org_name]["secret"] = secret
     config_object[org_name]["official_scope"] = scope
     config_object[org_name]["scopes"] = scopes
+    config_object[org_name]["proxy"] = proxy
     # ensure the reset of the state by overwriting possible values from previous import.
     config_object[org_name]["date_limit"] = 0
     config_object[org_name]["token"] = ""

{launchpy-0.5.2 → launchpy-0.5.3}/launchpy/connector.py

@@ -46,6 +46,7 @@ class AdobeRequest:
             raise Exception(
                 'You have to upload the configuration file with importConfigFile method.')
         self.config = {self.config_key: deepcopy(config_object)}
+        self.proxy = configs._validate_proxy(config_object.get("proxy"))
         header = headers[self.config_key]
         self.header = deepcopy(header)
         self.retry = retry
@@ -79,8 +80,10 @@ class AdobeRequest:
             "client_secret": config["secret"],
             "scope": config["scopes"]
         }
+        proxy = configs._validate_proxy(config.get("proxy"))
+        proxy_kwargs = {"proxies": {"http": proxy, "https": proxy}} if proxy is not None else {}
         response = requests.post(
-            config["oauthTokenEndpointV2"], data=oauth_payload)
+            config["oauthTokenEndpointV2"], data=oauth_payload, **proxy_kwargs)
         json_response = response.json()
         if 'access_token' in json_response.keys():
             token = json_response['access_token']
@@ -130,6 +133,8 @@ class AdobeRequest:
         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 self.proxy is not None:
+            request_kwargs["proxies"] = {"http": self.proxy, "https": self.proxy}
         if params is not None:
             request_kwargs["params"] = params
         if data is not None:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.2
+Version: 0.5.3
 Summary: Adobe Launch API wrapper
 Author-email: Julien Piccini <piccini.julien@gmail.com>
 License: Apache License 2.0
@@ -71,6 +71,30 @@ Most of the documentation has been imported from the datanalyst website [here](.
 
 You can find release information [here](./docs/releases.md).
 
+## Proxy support
+
+Pass a `proxy` URL to `launchpy.configure(...)`, or add `"proxy"` to
+your JSON configuration file. The same proxy serves both HTTP and HTTPS.
+Proxy settings apply to OAuth authentication,
+API requests, and asynchronous property exports, with separate settings per
+organization.
+
+```python
+launchpy.configure(
+    org_id="your-org@AdobeOrg",
+    client_id="your-client-id",
+    secret="your-secret",
+    scopes="your-scopes",
+    proxy="http://proxy.example.com:8080",
+)
+```
+
+The CLI accepts `--proxy URL` at startup and in the interactive `config`
+command. An explicit CLI proxy overrides the file setting.
+Without an explicit proxy, existing environment-based proxy behavior is unchanged.
+See the [Python and JSON examples](./docs/getstarted.md#proxy-configuration)
+and [CLI examples](./docs/cli.md#proxy-configuration).
+
 ## HTTP retries
 
 The `AdobeRequest` connector always retries HTTP 429 responses for GET, POST,

{launchpy-0.5.2 → launchpy-0.5.3}/launchpy.egg-info/SOURCES.txt

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

{launchpy-0.5.2 → launchpy-0.5.3}/tests/test_connector.py

@@ -17,6 +17,7 @@ class ConnectorRetryTests(unittest.TestCase):
         self.connector = AdobeRequest.__new__(AdobeRequest)
         self.connector.header = {"Authorization": "test"}
         self.connector.retry = 2
+        self.connector.proxy = None
         self.connector._checkingDate = Mock()
         sleep_patch = patch("launchpy.connector.time.sleep")
         self.sleep = sleep_patch.start()

launchpy-0.5.3/tests/test_proxies.py

@@ -0,0 +1,337 @@
+import asyncio
+import json
+import tempfile
+import unittest
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from threading import Thread
+from unittest.mock import AsyncMock, Mock, patch
+
+import launchpy
+from launchpy.cli.__main__ import MainShell, main
+from launchpy.config import config_objects, headers
+from launchpy.connector import AdobeRequest
+
+
+class ProxyTestCase(unittest.TestCase):
+    credentials = {
+        "org_id": "test@AdobeOrg",
+        "client_id": "client",
+        "secret": "secret",
+        "scopes": "scope",
+    }
+    proxy = "http://proxy.example:8080"
+
+    def setUp(self):
+        for target in (config_objects, headers):
+            patcher = patch.dict(target, {}, clear=True)
+            patcher.start()
+            self.addCleanup(patcher.stop)
+        self.directory = tempfile.TemporaryDirectory()
+        self.addCleanup(self.directory.cleanup)
+
+    def config_file(self, data):
+        path = Path(self.directory.name) / "config.json"
+        path.write_text(json.dumps(data), encoding="utf-8")
+        return str(path)
+
+
+class ProxyConfigTests(ProxyTestCase):
+    def test_configure_stores_proxy_and_resets_it_on_reconfiguration(self):
+        launchpy.configure(**self.credentials, proxy=self.proxy)
+        self.assertEqual(config_objects["default"]["proxy"], self.proxy)
+        launchpy.configure(**self.credentials)
+        self.assertIsNone(config_objects["default"]["proxy"])
+
+    def test_invalid_proxy_configurations_are_rejected(self):
+        for proxy in ([], {}, {"https": self.proxy}, 1, True, "", " "):
+            with self.subTest(proxy=proxy):
+                with self.assertRaises(ValueError):
+                    launchpy.configure(**self.credentials, proxy=proxy)
+        self.assertEqual(config_objects, {})
+
+    def test_import_single_config_with_legacy_api_key(self):
+        config = dict(self.credentials, proxy=self.proxy)
+        config["api_key"] = config.pop("client_id")
+        launchpy.importConfigFile(self.config_file(config))
+        self.assertEqual(config_objects["default"]["proxy"], self.proxy)
+        self.assertEqual(config_objects["default"]["client_id"], "client")
+
+    def test_import_multi_org_keeps_proxy_independent(self):
+        configs = [
+            dict(self.credentials, org_name="first", proxy=self.proxy),
+            dict(self.credentials, org_name="second", proxy="http://other:8080"),
+            dict(self.credentials, org_name="third"),
+        ]
+        launchpy.importConfigFile(self.config_file(configs))
+        self.assertEqual(config_objects["first"]["proxy"], self.proxy)
+        self.assertEqual(config_objects["second"]["proxy"], configs[1]["proxy"])
+        self.assertIsNone(config_objects["third"]["proxy"])
+
+    def test_import_proxy_override_applies_to_single_and_multi_org(self):
+        override = "http://override:8080"
+        for multi in (False, True):
+            with self.subTest(multi=multi):
+                config = dict(self.credentials, org_name="first", proxy=self.proxy)
+                data = [config] if multi else config
+                launchpy.importConfigFile(self.config_file(data), proxy=override)
+                self.assertEqual(config_objects["first" if multi else "default"]["proxy"],
+                                 override)
+
+    def test_import_without_proxy_preserves_old_configuration_format(self):
+        launchpy.importConfigFile(self.config_file(self.credentials))
+        self.assertIsNone(config_objects["default"]["proxy"])
+
+
+class ConnectorProxyTests(ProxyTestCase):
+    def make_connector(self, proxy=None):
+        launchpy.configure(**self.credentials, proxy=proxy)
+        return AdobeRequest()
+
+    @patch("launchpy.connector.requests.post")
+    def test_oauth_initial_request_and_refresh_use_proxy(self, post):
+        post.return_value.json.return_value = {"access_token": "token", "expires_in": 3600}
+        connector = self.make_connector(self.proxy)
+        connector.config["default"]["date_limit"] = 0
+        connector._checkingDate()
+        self.assertEqual(post.call_count, 2)
+        for call in post.call_args_list:
+            self.assertEqual(call.kwargs["proxies"], {"http": self.proxy, "https": self.proxy})
+        config_objects["default"]["proxy"] = "http://changed:8080"
+        self.assertEqual(connector.proxy, self.proxy)
+
+    @patch("launchpy.connector.requests.post")
+    def test_legacy_oauth_configuration_does_not_add_proxy_kwargs(self, post):
+        post.return_value.json.return_value = {"access_token": "token", "expires_in": 3600}
+        connector = self.make_connector()
+        connector.config["default"]["date_limit"] = 0
+        connector._checkingDate()
+        for call in post.call_args_list:
+            self.assertNotIn("proxies", call.kwargs)
+
+    def test_all_api_methods_preserve_proxy_when_retrying(self):
+        with patch("launchpy.connector.requests.post") as post:
+            post.return_value.json.return_value = {"access_token": "token", "expires_in": 3600}
+            connector = self.make_connector(self.proxy)
+        for method in ("get", "post", "put", "patch", "delete"):
+            with self.subTest(method=method):
+                limited = Mock(status_code=429, headers={"Retry-After": "0"})
+                success = Mock(status_code=200)
+                success.json.return_value = {"data": []}
+                with patch(f"launchpy.connector.requests.{method}",
+                           side_effect=[limited, success]) as request:
+                    with patch("launchpy.connector.time.sleep"):
+                        getattr(connector, method + "Data")("https://example.invalid")
+                self.assertEqual(request.call_count, 2)
+                for call in request.call_args_list:
+                    self.assertEqual(call.kwargs["proxies"],
+                                     {"http": self.proxy, "https": self.proxy})
+
+    def test_organizations_use_their_own_proxy_for_authentication(self):
+        launchpy.configure(**self.credentials, org_name="first", proxy=self.proxy)
+        launchpy.configure(**self.credentials, org_name="second",
+                           proxy="http://other:8080")
+        with patch("launchpy.connector.requests.post") as post:
+            post.return_value.json.return_value = {"access_token": "token", "expires_in": 3600}
+            first = AdobeRequest(org_name="first")
+            second = AdobeRequest(org_name="second")
+        self.assertEqual(post.call_args_list[0].kwargs["proxies"],
+                         {"http": first.proxy, "https": first.proxy})
+        self.assertEqual(post.call_args_list[1].kwargs["proxies"],
+                         {"http": second.proxy, "https": second.proxy})
+        self.assertNotEqual(first.proxy, second.proxy)
+
+
+class CLIProxyTests(ProxyTestCase):
+    def setUp(self):
+        super().setUp()
+        for target in ("launchpy.cli.__main__.console", "launchpy.Admin"):
+            patcher = patch(target)
+            patcher.start()
+            self.addCleanup(patcher.stop)
+
+    def test_startup_direct_credentials_and_proxy(self):
+        shell = MainShell(**self.credentials, proxy=self.proxy)
+        self.assertEqual(config_objects["default"]["proxy"], self.proxy)
+        self.assertEqual(shell.org_name, "default")
+
+    def test_interactive_direct_credentials_and_proxy(self):
+        shell = MainShell()
+        shell.do_config("--client_id client --secret secret --org_id org --scopes scope "
+                        f"--proxy {self.proxy}")
+        self.assertEqual(config_objects["default"]["proxy"], self.proxy)
+        self.assertIsNotNone(shell.cid)
+
+    def test_single_file_proxy_and_cli_override_at_startup_and_interactively(self):
+        path = self.config_file(dict(self.credentials, proxy=self.proxy))
+        for interactive in (False, True):
+            for override in (False, True):
+                with self.subTest(interactive=interactive, override=override):
+                    expected = "http://override:8080" if override else self.proxy
+                    if interactive:
+                        shell = MainShell()
+                        extra = " --proxy http://override:8080" if override else ""
+                        shell.do_config(f'--config_file "{path}"{extra}')
+                    else:
+                        options = {"proxy": "http://override:8080"} if override else {}
+                        shell = MainShell(config_file=path, **options)
+                    self.assertEqual(config_objects["default"]["proxy"], expected)
+                    self.assertIsNotNone(shell.cid)
+
+    def test_multi_org_proxy_survives_switching_and_reconfiguration(self):
+        configs = [
+            dict(self.credentials, org_name="first", proxy=self.proxy),
+            dict(self.credentials, org_name="second", proxy="http://other:8080"),
+        ]
+        path = self.config_file(configs)
+        for interactive in (False, True):
+            with self.subTest(interactive=interactive):
+                shell = MainShell() if interactive else MainShell(config_file=path)
+                if interactive:
+                    shell.do_config(f'--config_file "{path}"')
+                for org in ("second", "first", "second"):
+                    shell.do_change_org(org)
+                    expected = configs[0 if org == "first" else 1]["proxy"]
+                    self.assertEqual(config_objects[org]["proxy"], expected)
+                    self.assertEqual(shell.org_name, org)
+                shell.do_config("--client_id client --secret secret --org_id org "
+                                "--scopes scope --proxy http://new:8080")
+                self.assertEqual(config_objects["default"]["proxy"], "http://new:8080")
+
+    def test_startup_parser_and_default_org_with_proxy(self):
+        with patch("sys.argv", ["launchpy", "--client_id", "client", "--secret", "secret",
+                                "--org_id", "org", "--scopes", "scope",
+                                "--proxy", "http://proxy:8080"]):
+            with patch.object(MainShell, "cmdloop"):
+                main()
+        self.assertEqual(config_objects["default"]["proxy"], "http://proxy:8080")
+
+    def test_multi_org_overrides_apply_to_every_org_at_startup_and_interactively(self):
+        configs = [
+            dict(self.credentials, org_name="first", proxy=self.proxy),
+            dict(self.credentials, org_name="second"),
+        ]
+        path = self.config_file(configs)
+        for interactive in (False, True):
+            with self.subTest(interactive=interactive):
+                if interactive:
+                    shell = MainShell()
+                    shell.do_config(f'--config_file "{path}" --org_name second '
+                                    '--proxy http://common:8080')
+                else:
+                    shell = MainShell(config_file=path, org_name="second",
+                                      proxy="http://common:8080")
+                for org in ("first", "second"):
+                    self.assertEqual(config_objects[org]["proxy"], "http://common:8080")
+                self.assertEqual(shell.org_name, "second")
+
+    def test_invalid_file_proxy_is_reported_before_connecting(self):
+        path = self.config_file(dict(self.credentials, proxy={"https": self.proxy}))
+        shell = MainShell()
+        with patch("launchpy.Admin") as admin:
+            with patch("launchpy.cli.__main__.console") as console:
+                shell.do_config(f'--config_file "{path}"')
+        admin.assert_not_called()
+        self.assertIn("`proxy` must be", console.print.call_args.args[0])
+
+    def test_empty_proxy_url_is_reported_before_connecting(self):
+        shell = MainShell()
+        with patch("launchpy.Admin") as admin:
+            with patch("launchpy.cli.__main__.console") as console:
+                shell.do_config('--client_id client --secret secret --org_id org '
+                                '--scopes scope --proxy ""')
+        admin.assert_not_called()
+        self.assertIn("`proxy` must be", console.print.call_args.args[0])
+
+
+class LocalProxyTests(ProxyTestCase):
+    def test_requests_and_httpx_route_through_configured_proxy(self):
+        received = []
+
+        class ProxyHandler(BaseHTTPRequestHandler):
+            def respond(self):
+                received.append((self.command, self.path))
+                self.rfile.read(int(self.headers.get("Content-Length", 0)))
+                payload = (
+                    {"access_token": "test-token", "expires_in": 3600}
+                    if self.path.endswith("/token") else {"data": []}
+                )
+                body = json.dumps(payload).encode()
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            do_GET = do_POST = do_PUT = do_PATCH = do_DELETE = respond
+
+            def log_message(self, format, *args):
+                pass
+
+        server = ThreadingHTTPServer(("127.0.0.1", 0), ProxyHandler)
+        thread = Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        self.addCleanup(server.server_close)
+        self.addCleanup(thread.join, 5)
+        self.addCleanup(server.shutdown)
+        proxy = f"http://127.0.0.1:{server.server_port}"
+        launchpy.configure(**self.credentials, proxy=proxy)
+        config_objects["default"]["oauthTokenEndpointV2"] = "http://example.invalid/token"
+        connector = AdobeRequest()
+        for method in ("get", "post", "put", "patch", "delete"):
+            result = getattr(connector, method + "Data")("http://example.invalid/api")
+            self.assertEqual(result, 200 if method == "delete" else {"data": []})
+        connector.config["default"]["date_limit"] = 0
+        connector._checkingDate()
+        rule = {
+            "attributes": {"name": "test-rule"},
+            "relationships": {
+                "rule_components": {"links": {"related": "http://example.invalid/components"}},
+            },
+        }
+        asyncio.run(launchpy.process_all_rules(
+            [rule], self.directory.name, {}, connector.proxy))
+        self.assertEqual(received, [
+            ("POST", "http://example.invalid/token"),
+            ("GET", "http://example.invalid/api"),
+            ("POST", "http://example.invalid/api"),
+            ("PUT", "http://example.invalid/api"),
+            ("PATCH", "http://example.invalid/api"),
+            ("DELETE", "http://example.invalid/api"),
+            ("POST", "http://example.invalid/token"),
+            ("GET", "http://example.invalid/components"),
+        ])
+
+
+class AsyncProxyTests(unittest.TestCase):
+    def test_async_rule_downloads_use_single_proxy(self):
+        proxy = "http://proxy.example:8080"
+        with patch("launchpy.httpx.AsyncClient") as client_class:
+            with patch("launchpy.__extractRuleComponents__", new_callable=AsyncMock) as extract:
+                rules = [{"id": "rule1"}, {"id": "rule2"}]
+                asyncio.run(launchpy.process_all_rules(rules, "folder", {}, proxy))
+        self.assertEqual(client_class.call_args.kwargs["proxy"], proxy)
+        self.assertNotIn("mounts", client_class.call_args.kwargs)
+        self.assertEqual(extract.await_count, 2)
+
+    def test_no_proxy_keeps_default_async_client_settings(self):
+        with patch("launchpy.httpx.AsyncClient") as client_class:
+            asyncio.run(launchpy.process_all_rules([], "folder", {}))
+        self.assertNotIn("proxy", client_class.call_args.kwargs)
+
+    def test_property_export_passes_connector_proxy(self):
+        property = Mock(spec=launchpy.Property)
+        property.name = "test"
+        property.header = {}
+        property.connector = Mock(proxy="http://proxy.example:8080")
+        property.getRules.return_value = []
+        property.getDataElements.return_value = []
+        property.getExtensions.return_value = []
+        with tempfile.TemporaryDirectory() as folder:
+            with patch("launchpy.process_all_rules", new_callable=AsyncMock) as process:
+                launchpy.extractProperty(property, folder=folder)
+        process.assert_awaited_once_with([], folder, {}, property.connector.proxy)
+
+
+if __name__ == "__main__":
+    unittest.main()

launchpy-0.5.2/launchpy/__version__.py

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