launchpy 0.5.2__tar.gz → 0.5.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: launchpy
-Version: 0.5.2
+Version: 0.5.4
 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.4}/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.4}/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:
@@ -490,9 +533,12 @@ Arguments:
 `-r`, `--regex`: Regex pattern to filter rules by name (partial match, non-case sensitive). This is an optional parameter, if not provided, all rules are synced.
 `-c`, `--create` : Flag. Create rules that do not exist in the destination property. Default False.
 `-p`, `--published` : Flag. Sync the latest published version of the rules. Default False.
+`-i`, `--ignore_disabled` : Optional boolean. Skip disabled source rules. Default False; a bare flag means True. With `-p`, checks the latest published source revision.
 
 ```bash
 synchronizer:Base_Property_Name> sync_rules -r "Rule Name" -c
+synchronizer:Base_Property_Name> sync_rules -i
+synchronizer:Base_Property_Name> sync_rules --ignore_disabled True -p
 ```
 
 #### sync_data_elements
@@ -501,9 +547,12 @@ Arguments:
 `-r`, `--regex`: Regex pattern to filter data elements by name (partial match, non-case sensitive). This is an optional parameter, if not provided, all data elements are synced.
 `-c`, `--create` : Flag. Create data elements that do not exist in the destination property. Default False.
 `-p`, `--published` : Flag. Sync the latest published version of the data elements. Default False.
+`-i`, `--ignore_disabled` : Optional boolean. Skip disabled source data elements. Default False; a bare flag means True. With `-p`, checks the latest published source revision.
 
 ```bash
 synchronizer:Base_Property_Name> sync_data_elements -r "Data Element Name" -c
+synchronizer:Base_Property_Name> sync_data_elements -i
+synchronizer:Base_Property_Name> sync_data_elements --ignore_disabled False
 ```
 
 #### sync_extensions

{launchpy-0.5.2 → launchpy-0.5.4}/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.4}/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.4}/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.4
+* Fixing enabled state handling for rules, data elements, and extensions during synchronization. Before release, state enablement was respected only during -published synchronization.
+* Ensuring that the verbose flag correctly displays detailed information for all synchronized entities, including those with enabled state changes.
+* Adding the `ignore_disabled` flag to the synchronization commands to allow skipping disabled source entities.
+* Adding `-i` / `--ignore_disabled` flag to the CLI synchronization commands.
+
+
+## 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.4}/docs/synchronizer.md

@@ -150,6 +150,7 @@ synchronizor.syncComponent('my Component Name',publishedVersion=True)
 #### Data Elements
 The method will replace the existing configuration of a data element by the template configuration.\
 Completely overriding the existing element configuration in the target properties.
+When a data element is created, its enabled state is updated if needed to match the selected source revision. The response from that update is retained in the target cache and library stack.
 
 #### Rules
 The method will delete all rule components existing in the Target property for that rule.\
@@ -198,6 +199,7 @@ Arguments:
 *  regex : OPTIONAL : If you want to filter the data elements to sync based on a regex pattern. Default: None (sync all data elements)
 *  forceCreation : OPTIONAL : If set to True, it will sync the data elements even if they do not exist in the target properties. If set to False, it will only sync the data elements that already exist in the target properties. Default: False.
 *  publishedVersion : OPTIONAL : If set to True, it will sync the latest published version of the data elements. Default: False.
+*  ignoreDisabled : OPTIONAL : If set to True, skip data elements whose selected source revision has `enabled=False`. Default: False.
 
 ## SyncRules
 It will synchronize the rules in the base property to the target properties.
@@ -205,7 +207,14 @@ Arguments:
 *  regex : OPTIONAL : If you want to filter the rules to sync based on a regex pattern. Default: None (sync all rules)
 *  forceCreation : OPTIONAL : If set to True, it will sync the rules even if they do not exist in the target properties. If set to False, it will only sync the rules that already exist in the target properties. Default: False.
 *  publishedVersion : OPTIONAL : If set to True, it will sync the latest published version of the rules. Default: False.
+*  ignoreDisabled : OPTIONAL : If set to True, skip rules whose selected source revision has `enabled=False`. Default: False.
 
+For both methods, `ignoreDisabled=True` checks the source revision being synchronized, not the target's enabled state. With `publishedVersion=True`, it checks the latest published source revision rather than the current draft. Disabled components are not created or updated, even with `forceCreation=True`, and retain an empty per-target dictionary in the returned results.
+
+```python
+synchronizor.syncRules(ignoreDisabled=True)
+synchronizor.syncDataElements(ignoreDisabled=True, publishedVersion=True)
+```
 
 ## createTargetsLibrary
 
@@ -238,6 +247,7 @@ Check if the component,from the base property, is synced to the different target
 It can also check for the Extensions.\
 It will return a dictionary with the key being the target property and the value being the result of the evaluation, such as {targetProperty: 'similar'} when component have same settings or {targetPropery : '<difference>'} when component do not have same settings.\
 See below for differences.\
+For rules and data elements, enabled-state differences are checked in both current and published modes. A matching configuration does not override an enabled-state difference with `"Similar"`. When a data element has multiple differences, they are returned together as a comma-separated message. Library dry runs use the same comparison logic.
 Arguments:
 * componentName : REQUIRED : the name of the component to compare
 * componentID : REQUIRED : the id of the component to compare

{launchpy-0.5.2 → launchpy-0.5.4}/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.4/launchpy/__version__.py

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

{launchpy-0.5.2 → launchpy-0.5.4}/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
@@ -594,10 +595,11 @@ class SynchronizerCLI(cmd.Cmd):
         parser.add_argument("-r", "--regex", help="Regex pattern to filter rules by name (partial match, non-case sensitive). Default None.", type=str, default=None)
         parser.add_argument("-c", "--create", help="Create rules that do not exist in the destination property. Default False.", action="store_true", default=False)
         parser.add_argument("-p", "--published", help="Sync the latest published version of the rules. Default False.", action="store_true", default=False)
+        parser.add_argument("-i", "--ignore_disabled", help="Skip disabled source rules. Default False. A bare flag means True.", type=str2bool, nargs="?", const=True, default=False)
         parser.add_argument("-v", "--verbose", help="Print detailed information about the sync process, including successes. Default False.", action="store_true", default=False)
         try:
             args = parser.parse_args(shlex.split(args))
-            result = self.synchronizer.syncRules(regex=args.regex, forceCreation=args.create, publishedVersion=args.published)
+            result = self.synchronizer.syncRules(regex=args.regex, forceCreation=args.create, publishedVersion=args.published, ignoreDisabled=args.ignore_disabled)
             for ruleName, targetResults in result.items():
                 for prop, message in (targetResults or {}).items():
                     if "does not exist" in message:
@@ -616,10 +618,11 @@ class SynchronizerCLI(cmd.Cmd):
         parser.add_argument("-r", "--regex", help="Regex pattern to filter data elements by name (partial match, non-case sensitive). Default None.", type=str, default=None)
         parser.add_argument("-c", "--create", help="Create data elements that do not exist in the destination property. Default False.", action="store_true", default=False)
         parser.add_argument("-p", "--published", help="Sync the latest published version of the data elements. Default False.", action="store_true", default=False)
+        parser.add_argument("-i", "--ignore_disabled", help="Skip disabled source data elements. Default False. A bare flag means True.", type=str2bool, nargs="?", const=True, default=False)
         parser.add_argument("-v", "--verbose", help="Print detailed information about the sync process, including successes. Default False.", action="store_true", default=False)
         try:
             args = parser.parse_args(shlex.split(args))
-            result = self.synchronizer.syncDataElements(regex=args.regex, forceCreation=args.create, publishedVersion=args.published)
+            result = self.synchronizer.syncDataElements(regex=args.regex, forceCreation=args.create, publishedVersion=args.published, ignoreDisabled=args.ignore_disabled)
             for deName, targetResults in result.items():
                 for prop, message in (targetResults or {}).items():
                     if "does not exist" in message:
@@ -961,6 +964,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 +992,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 +1012,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 +1031,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 +1058,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 +1084,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 +1097,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 +1122,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 +1139,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 +1153,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 +1165,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 +1429,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.4}/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"] = ""