cloudinary-cli 1.10.3__tar.gz → 1.11.1__tar.gz

{cloudinary_cli-1.10.3/cloudinary_cli.egg-info → cloudinary_cli-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudinary-cli
-Version: 1.10.3
+Version: 1.11.1
 Summary: A command line interface for Cloudinary with full API support
 Home-page: https://github.com/cloudinary/cloudinary-cli
 Author: Cloudinary, Brian Luk
@@ -13,13 +13,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cloudinary>=1.37.0
+Requires-Dist: cloudinary>=1.42.2
 Requires-Dist: pygments
 Requires-Dist: jinja2
 Requires-Dist: click
 Requires-Dist: click-log
 Requires-Dist: requests
 Requires-Dist: docstring-parser
+Requires-Dist: urllib3>=2.2.2
+Requires-Dist: zipp>=3.19.1
 
 [![Build Status](https://app.travis-ci.com/cloudinary/cloudinary-cli.svg)](https://app.travis-ci.com/cloudinary/cloudinary-cli)
 [![PyPI Downloads](https://img.shields.io/pypi/dm/cloudinary-cli.svg)](https://pypistats.org/packages/cloudinary-cli)

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli/core/__init__.py

@@ -2,7 +2,7 @@ import click
 
 from cloudinary_cli.core.admin import admin
 from cloudinary_cli.core.config import config
-from cloudinary_cli.core.search import search
+from cloudinary_cli.core.search import search, search_folders
 from cloudinary_cli.core.uploader import uploader
 from cloudinary_cli.core.provisioning import provisioning
 from cloudinary_cli.core.utils import url, utils
@@ -13,6 +13,7 @@ setattr(click.MultiCommand, "resolve_command", resolve_command)
 commands = [
     config,
     search,
+    search_folders,
     admin,
     uploader,
     provisioning,

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli/core/overrides.py

@@ -35,6 +35,24 @@ def resolve_command(self, ctx, args):
 
 # Patch to set `auto` resource type
 def upload(file, **options):
+    """
+    Uploads an asset to a Cloudinary cloud.
+
+    The asset can be:
+       * a local file path
+       * the actual data (byte array buffer)
+       * the Data URI (Base64 encoded), max ~60 MB (62,910,000 chars)
+       * the remote FTP, HTTP or HTTPS URL address of an existing file
+       * a private storage bucket (S3 or Google Storage) URL of a whitelisted bucket
+
+    See: https://cloudinary.com/documentation/image_upload_api_reference#upload_method
+    :param file: The asset to upload.
+    :type file: Any or str
+    :param options: The optional parameters. See the upload API documentation.
+    :type options: dict, optional
+    :return: The result of the upload API call.
+    :rtype: dict
+    """
     if "resource_type" not in options.keys():
         options["resource_type"] = "auto"
     return original_upload(file, **options)

cloudinary_cli-1.11.1/cloudinary_cli/core/search.py

@@ -0,0 +1,171 @@
+import cloudinary
+from click import command, argument, option, launch
+from functools import wraps
+
+from cloudinary_cli.defaults import logger
+from cloudinary_cli.utils.json_utils import write_json_to_file, print_json
+from cloudinary_cli.utils.utils import write_json_list_to_csv, confirm_action, whitelist_keys, \
+    normalize_list_params
+
+DEFAULT_MAX_RESULTS = 500
+
+
+def shared_options(func):
+    @option("-f", "--with_field", multiple=True, help="Specify which non-default asset attributes to include "
+                                                      "in the result as a comma separated list.")
+    @option("-fi", "--fields", multiple=True, help="Specify which asset attributes to include in the result "
+                                                   "(together with a subset of the default attributes) as a comma separated"
+                                                   " list. This overrides any value specified for with_field.")
+    @option("-s", "--sort_by", nargs=2, help="Sort search results by (field, <asc|desc>).")
+    @option("-a", "--aggregate", nargs=1,
+            help="Specify the attribute for which an aggregation count should be calculated and returned.")
+    @option("-n", "--max_results", nargs=1, default=10,
+            help="The maximum number of results to return. Default: 10, maximum: 500.")
+    @option("-c", "--next_cursor", nargs=1, help="Continue a search using an existing cursor.")
+    @option("-A", "--auto_paginate", is_flag=True, help="Return all results. Will call Admin API multiple times.")
+    @option("-F", "--force", is_flag=True, help="Skip confirmation when running --auto-paginate.")
+    @option("-ff", "--filter_fields", multiple=True, help="Specify which attributes to show in the response. "
+                                                          "None of the others will be shown.")
+    @option("-sq", "--search-query", is_flag=True, help="Show the search request query.", hidden=True)
+    @option("--json", nargs=1, help="Save JSON output to a file. Usage: --json <filename>")
+    @option("--csv", nargs=1, help="Save CSV output to a file. Usage: --csv <filename>")
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+@command("search",
+         short_help="Run the Admin API search method.",
+         help="""\b
+Run the Admin API search method.
+Format: cld <cli options> search <command options> <Lucene query syntax string>
+e.g. cld search cat AND tags:kitten -s public_id desc -f context -f tags -n 10
+""")
+@argument("query", nargs=-1)
+@shared_options
+@option("-t", "--ttl", nargs=1, default=300, help="Set the Search URL TTL in seconds. Default: 300.")
+@option("-u", "--url", is_flag=True, help="Build a signed search URL.")
+@option("-d", "--doc", is_flag=True, help="Open Search API documentation page.")
+def search(query, with_field, fields, sort_by, aggregate, max_results, next_cursor,
+           auto_paginate, force, filter_fields, ttl, url, search_query, json, csv, doc):
+    search_instance = cloudinary.search.Search()
+    doc_url = "https://cloudinary.com/documentation/search_api"
+    result_field = 'resources'
+    return _perform_search(query, with_field, fields, sort_by, aggregate, max_results, next_cursor,
+                           auto_paginate, force, filter_fields, ttl, url, search_query, json, csv, doc,
+                           search_instance, doc_url, result_field)
+
+
+@command("search_folders",
+         short_help="Run the Admin API search folders method.",
+         help="""\b
+Run the Admin API search folders method.
+Format: cld <cli options> search_folders <command options> <Lucene query syntax string>
+e.g. cld search_folders name:folder AND path:my_parent AND created_at>4w
+""")
+@argument("query", nargs=-1)
+@shared_options
+@option("-d", "--doc", is_flag=True, help="Open Search Folders API documentation page.")
+def search_folders(query, with_field, fields, sort_by, aggregate, max_results, next_cursor,
+                   auto_paginate, force, filter_fields, search_query, json, csv, doc):
+    search_instance = cloudinary.search_folders.SearchFolders()
+    doc_url = "https://cloudinary.com/documentation/admin_api#search_folders"
+    result_field = 'folders'
+    return _perform_search(query, with_field, fields, sort_by, aggregate, max_results, next_cursor,
+                           auto_paginate, force, filter_fields, 300, False, search_query, json, csv, doc,
+                           search_instance, doc_url, result_field)
+
+
+def _perform_search(query, with_field, fields, sort_by, aggregate, max_results, next_cursor,
+                    auto_paginate, force, filter_fields, ttl, url, search_query, json, csv, doc,
+                    search_instance, doc_url, result_field):
+    """Shared logic for running a search."""
+    if doc:
+        return launch(doc_url)
+
+    fields_to_keep = []
+    if filter_fields:
+        fields_to_keep = tuple(normalize_list_params(filter_fields)) + tuple(normalize_list_params(with_field))
+
+    search = search_instance.expression(" ".join(query))
+
+    if auto_paginate:
+        max_results = DEFAULT_MAX_RESULTS
+    if with_field:
+        search.with_field(normalize_list_params(with_field))
+    if fields:
+        search.fields(normalize_list_params(fields))
+    if sort_by:
+        search.sort_by(*sort_by)
+    if aggregate:
+        search.aggregate(aggregate)
+    if next_cursor:
+        search.next_cursor(next_cursor)
+    if ttl:
+        search.ttl(ttl)
+
+    search.max_results(max_results)
+
+    if url:
+        print(search.to_url())
+        return True
+
+    if search_query:
+        print_json(search.as_dict())
+        return True
+
+    res = execute_single_request(search, fields_to_keep, result_field)
+
+    if auto_paginate:
+        res = handle_auto_pagination(res, search, force, fields_to_keep, result_field)
+
+    print_json(res)
+
+    if json:
+        write_json_to_file(res[result_field], json)
+        logger.info(f"Saved search JSON to '{json}' file")
+
+    if csv:
+        write_json_list_to_csv(res[result_field], csv, fields_to_keep)
+        logger.info(f"Saved search to '{csv}.csv' file")
+
+
+def execute_single_request(expression, fields_to_keep, result_field='resources'):
+    res = expression.execute()
+
+    if fields_to_keep:
+        res[result_field] = whitelist_keys(res[result_field], fields_to_keep)
+
+    return res
+
+
+def handle_auto_pagination(res, expression, force, fields_to_keep, result_field='resources'):
+    if 'next_cursor' not in res:
+        return res
+
+    if not force:
+        if not confirm_action(
+                f"{res['total_count']} total results. "
+                f"{res.rate_limit_remaining + 1} Admin API rate limit remaining.\n"
+                f"Running this query will use {res['total_count'] // DEFAULT_MAX_RESULTS + 1} Admin API calls. "
+                f"Continue? (y/N)"):
+            logger.info("Stopping. Please run again without -A.")
+
+            return res
+        else:
+            logger.info("Continuing. You may use the -F flag to force auto_pagination.")
+
+    all_results = res
+    while 'next_cursor' in res.keys():
+        expression.next_cursor(res['next_cursor'])
+
+        res = execute_single_request(expression, fields_to_keep, result_field)
+
+        all_results[result_field] += res[result_field]
+        all_results['time'] += res['time']
+
+    all_results.pop('next_cursor', None)  # it is empty by now
+
+    return all_results

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli/modules/__init__.py

@@ -3,11 +3,13 @@ from .migrate import migrate
 from .sync import sync
 from .upload_dir import upload_dir
 from .regen_derived import regen_derived
+from .clone import clone
 
 commands = [
     upload_dir,
     make,
     migrate,
     sync,
-    regen_derived
+    regen_derived,
+    clone
 ]

cloudinary_cli-1.11.1/cloudinary_cli/modules/clone.py

@@ -0,0 +1,112 @@
+from click import command, option, style, argument
+from cloudinary_cli.utils.utils import normalize_list_params, print_help_and_exit
+import cloudinary
+from cloudinary_cli.utils.utils import run_tasks_concurrently
+from cloudinary_cli.utils.api_utils import upload_file
+from cloudinary_cli.utils.config_utils import load_config, get_cloudinary_config, config_to_dict
+from cloudinary_cli.defaults import logger
+from cloudinary_cli.core.search import execute_single_request, handle_auto_pagination
+
+DEFAULT_MAX_RESULTS = 500
+
+
+@command("clone",
+         short_help="""Clone assets from one product environment to another.""",
+         help="""
+\b
+Clone assets from one product environment to another with/without tags and/or context (structured metadata is not currently supported).
+Source will be your `CLOUDINARY_URL` environment variable but you also can specify a different source using the `-c/-C` option.
+Cloning restricted assets is also not supported currently.
+Format: cld clone <target_environment> <command options>
+`<target_environment>` can be a CLOUDINARY_URL or a saved config (see `config` command)
+Example 1 (Copy all assets including tags and context using CLOUDINARY URL):
+    cld clone cloudinary://<api_key>:<api_secret>@<cloudname> -fi tags,context
+Example 2 (Copy all assets with a specific tag via a search expression using a saved config):
+    cld clone <config_name> -se "tags:<tag_name>"
+""")
+@argument("target")
+@option("-F", "--force", is_flag=True,
+        help="Skip confirmation.")
+@option("-ow", "--overwrite", is_flag=True, default=False,
+        help="Specify whether to overwrite existing assets.")
+@option("-w", "--concurrent_workers", type=int, default=30,
+        help="Specify the number of concurrent network threads.")
+@option("-fi", "--fields", multiple=True,
+        help="Specify whether to copy tags and/or context. Valid options: `tags,context`.")
+@option("-se", "--search_exp", default="",
+        help="Define a search expression to filter the assets to clone.")
+@option("--async", "async_", is_flag=True, default=False,
+        help="Clone the assets asynchronously.")
+@option("-nu", "--notification_url",
+        help="Webhook notification URL.")
+def clone(target, force, overwrite, concurrent_workers, fields, search_exp, async_, notification_url):
+    if not target:
+        print_help_and_exit()
+
+    target_config = get_cloudinary_config(target)
+    if not target_config:
+        logger.error("The specified config does not exist or the CLOUDINARY_URL scheme provided is invalid"
+                     " (expecting to start with 'cloudinary://').")
+        return False
+
+    if cloudinary.config().cloud_name == target_config.cloud_name:
+        logger.error("Target environment cannot be the same as source environment.")
+        return False
+
+    source_assets = search_assets(force, search_exp)
+
+    upload_list = []
+    for r in source_assets.get('resources'):
+        updated_options, asset_url = process_metadata(r, overwrite, async_, notification_url,
+                                                      normalize_list_params(fields))
+        updated_options.update(config_to_dict(target_config))
+        upload_list.append((asset_url, {**updated_options}))
+
+    if not upload_list:
+        logger.error(style(f'No assets found in {cloudinary.config().cloud_name}', fg="red"))
+        return False
+
+    logger.info(style(f'Copying {len(upload_list)} asset(s) from {cloudinary.config().cloud_name} to {target_config.cloud_name}', fg="blue"))
+
+    run_tasks_concurrently(upload_file, upload_list, concurrent_workers)
+
+    return True
+
+
+def search_assets(force, search_exp):
+    search = cloudinary.search.Search().expression(search_exp)
+    search.fields(['tags', 'context', 'access_control', 'secure_url', 'display_name'])
+    search.max_results(DEFAULT_MAX_RESULTS)
+
+    res = execute_single_request(search, fields_to_keep="")
+    res = handle_auto_pagination(res, search, force, fields_to_keep="")
+
+    return res
+
+
+def process_metadata(res, overwrite, async_, notification_url, copy_fields=""):
+    cloned_options = {}
+    asset_url = res.get('secure_url')
+    cloned_options['public_id'] = res.get('public_id')
+    cloned_options['type'] = res.get('type')
+    cloned_options['resource_type'] = res.get('resource_type')
+    cloned_options['overwrite'] = overwrite
+    cloned_options['async'] = async_
+    if "tags" in copy_fields:
+        cloned_options['tags'] = res.get('tags')
+    if "context" in copy_fields:
+        cloned_options['context'] = res.get('context')
+    if res.get('folder'):
+        # This is required to put the asset in the correct asset_folder
+        # when copying from a fixed to DF (dynamic folder) cloud as if
+        # you just pass a `folder` param to a DF cloud, it will append
+        # this to the `public_id` and we don't want this.
+        cloned_options['asset_folder'] = res.get('folder')
+    elif res.get('asset_folder'):
+        cloned_options['asset_folder'] = res.get('asset_folder')
+    if res.get('display_name'):
+        cloned_options['display_name'] = res.get('display_name')
+    if notification_url:
+        cloned_options['notification_url'] = notification_url
+
+    return cloned_options, asset_url

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli/modules/sync.py

@@ -41,14 +41,14 @@ _SYNC_META_FILE = '.cld-sync'
 @option("-o", "--optional_parameter", multiple=True, nargs=2, help="Pass optional parameters as raw strings.")
 @option("-O", "--optional_parameter_parsed", multiple=True, nargs=2,
         help="Pass optional parameters as interpreted strings.")
+@option("--dry-run", is_flag=True, help="Simulate the sync operation without making any changes.")
 def sync(local_folder, cloudinary_folder, push, pull, include_hidden, concurrent_workers, force, keep_unique,
-         deletion_batch_size, folder_mode, optional_parameter, optional_parameter_parsed):
+         deletion_batch_size, folder_mode, optional_parameter, optional_parameter_parsed, dry_run):
     if push == pull:
         raise UsageError("Please use either the '--push' OR '--pull' options")
 
     sync_dir = SyncDir(local_folder, cloudinary_folder, include_hidden, concurrent_workers, force, keep_unique,
-                       deletion_batch_size, folder_mode, optional_parameter, optional_parameter_parsed)
-
+                       deletion_batch_size, folder_mode, optional_parameter, optional_parameter_parsed, dry_run)
     result = True
     if push:
         result = sync_dir.push()
@@ -63,7 +63,7 @@ def sync(local_folder, cloudinary_folder, push, pull, include_hidden, concurrent
 
 class SyncDir:
     def __init__(self, local_dir, remote_dir, include_hidden, concurrent_workers, force, keep_deleted,
-                 deletion_batch_size, folder_mode, optional_parameter, optional_parameter_parsed):
+                 deletion_batch_size, folder_mode, optional_parameter, optional_parameter_parsed, dry_run):
         self.local_dir = local_dir
         self.remote_dir = remote_dir.strip('/')
         self.user_friendly_remote_dir = self.remote_dir if self.remote_dir else '/'
@@ -72,6 +72,7 @@ class SyncDir:
         self.force = force
         self.keep_unique = keep_deleted
         self.deletion_batch_size = deletion_batch_size
+        self.dry_run = dry_run
 
         self.folder_mode = folder_mode or get_folder_mode()
 
@@ -115,16 +116,16 @@ class SyncDir:
         local_file_names = self.local_files.keys()
         remote_file_names = self.remote_files.keys()
         """
-        Cloudinary is a very permissive service. When uploading files that contain invalid characters, 
-        unicode characters, etc, Cloudinary does the best effort to store those files. 
-        
-        Usually Cloudinary sanitizes those file names and strips invalid characters. Although it is a good best effort 
-        for a general use case, when syncing local folder with Cloudinary, it is not the best option, since directories 
+        Cloudinary is a very permissive service. When uploading files that contain invalid characters,
+        unicode characters, etc, Cloudinary does the best effort to store those files.
+
+        Usually Cloudinary sanitizes those file names and strips invalid characters. Although it is a good best effort
+        for a general use case, when syncing local folder with Cloudinary, it is not the best option, since directories
         will be always out-of-sync.
-        
+
         In addition in dynamic folder mode Cloudinary allows having identical display names for differrent files.
-         
-        To overcome this limitation, cloudinary-cli keeps .cld-sync hidden file in the sync directory that contains a 
+
+        To overcome this limitation, cloudinary-cli keeps .cld-sync hidden file in the sync directory that contains a
         mapping of the diverse file names. This file keeps tracking of the files and allows syncing in both directions.
         """
 
@@ -168,6 +169,12 @@ class SyncDir:
         if not files_to_push:
             return True
 
+        if self.dry_run:
+            logger.info("Dry run mode enabled. The following files would be uploaded:")
+            for file in files_to_push:
+                logger.info(f"{file}")
+            return True
+
         logger.info(f"Uploading {len(files_to_push)} items to Cloudinary folder '{self.user_friendly_remote_dir}'")
 
         options = {
@@ -215,6 +222,14 @@ class SyncDir:
         if not files_to_pull:
             return True
 
+        logger.info(f"Preparing to download {len(files_to_pull)} items from Cloudinary folder ")
+
+        if self.dry_run:
+            logger.info("Dry run mode enabled. The following files would be downloaded:")
+            for file in files_to_pull:
+                logger.info(f"{file}")
+            return True
+
         logger.info(f"Downloading {len(files_to_pull)} files from Cloudinary")
         downloads = []
         for file in files_to_pull:
@@ -348,6 +363,10 @@ class SyncDir:
 
             # Each batch is further chunked by a deletion batch size that can be specified by the user.
             for deletion_batch in chunker(batch, self.deletion_batch_size):
+                if self.dry_run:
+                    logger.info(f"Dry run mode enabled. Would delete {len(deletion_batch)} resources:\n" +
+                                                "\n".join(deletion_batch))
+                    continue
                 res = api.delete_resources(deletion_batch, invalidate=True, resource_type=attrs[0], type=attrs[1])
                 num_deleted = Counter(res['deleted'].values())["deleted"]
                 if self.verbose:
@@ -395,6 +414,9 @@ class SyncDir:
         logger.info(f"Deleting {len(self.unique_local_file_names)} local files...")
         for file in self.unique_local_file_names:
             full_path = path.abspath(self.local_files[file]['path'])
+            if self.dry_run:
+                logger.info(f"Dry run mode enabled. Would delete '{full_path}'")
+                continue
             remove(full_path)
             logger.info(f"Deleted '{full_path}'")
 

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli/utils/api_utils.py

@@ -13,6 +13,8 @@ from cloudinary_cli.utils.file_utils import (normalize_file_extension, posix_rel
 from cloudinary_cli.utils.json_utils import print_json, write_json_to_file
 from cloudinary_cli.utils.utils import log_exception, confirm_action, get_command_params, merge_responses, \
     normalize_list_params, ConfigurationError, print_api_help, duplicate_values
+import re
+from cloudinary.utils import is_remote_url
 
 PAGINATION_MAX_RESULTS = 500
 
@@ -118,15 +120,20 @@ def upload_file(file_path, options, uploaded=None, failed=None):
     verbose = logger.getEffectiveLevel() < logging.INFO
 
     try:
-        size = path.getsize(file_path)
+        size = 0 if is_remote_url(file_path) else path.getsize(file_path)
         upload_func = uploader.upload
         if size > 20000000:
             upload_func = uploader.upload_large
         result = upload_func(file_path, **options)
         disp_path = _display_path(result)
-        disp_str = f"as {result['public_id']}" if not disp_path \
-            else f"as {disp_path} with public_id: {result['public_id']}"
-        logger.info(style(f"Successfully uploaded {file_path} {disp_str}", fg="green"))
+        if "batch_id" in result:
+            starting_msg = "Uploading"
+            disp_str = f"asynchnously with batch_id: {result['batch_id']}"
+        else:
+            starting_msg = "Successfully uploaded"
+            disp_str = f"as {result['public_id']}" if not disp_path \
+                else f"as {disp_path} with public_id: {result['public_id']}"
+        logger.info(style(f"{starting_msg} {file_path} {disp_str}", fg="green"))
         if verbose:
             print_json(result)
         uploaded[file_path] = {"path": asset_source(result), "display_path": disp_path}
@@ -212,12 +219,15 @@ def asset_source(asset_details):
 
     :return:
     """
-    base_name = asset_details['public_id']
+    base_name = asset_details.get('public_id', '')
+
+    if not base_name:
+        return base_name
 
     if asset_details['resource_type'] == 'raw' or asset_details['type'] == 'fetch':
         return base_name
 
-    return base_name + '.' + asset_details['format']
+    return base_name + '.' + asset_details.get('format', '')
 
 
 def get_folder_mode():
@@ -278,7 +288,6 @@ def handle_api_command(
     """
     Used by Admin and Upload API commands
     """
-
     if doc:
         return launch(doc_url)
 

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli/utils/config_utils.py

@@ -44,16 +44,31 @@ def refresh_cloudinary_config(cloudinary_url):
 
 def verify_cloudinary_url(cloudinary_url):
     refresh_cloudinary_config(cloudinary_url)
-    try:
-        api.ping()
-    except Exception as e:
-        log_exception(e, f"Invalid Cloudinary URL: {cloudinary_url}")
+    return ping_cloudinary()
+
+
+def get_cloudinary_config(target):
+    target_config = cloudinary.Config()
+    if target.startswith("cloudinary://"):
+        parsed_url = target_config._parse_cloudinary_url(target)
+    elif target in load_config():
+        parsed_url = target_config._parse_cloudinary_url(load_config().get(target))
+    else:
         return False
-    return True
 
+    target_config._setup_from_parsed_url(parsed_url)
+
+    if not ping_cloudinary(**config_to_dict(target_config)):
+        logger.error(f"Invalid Cloudinary config: {target}")
+        return False
+
+    return target_config
+
+def config_to_dict(config):
+    return {k: v for k, v in config.__dict__.items() if not k.startswith("_")}
 
 def show_cloudinary_config(cloudinary_config):
-    obfuscated_config = {k: v for k, v in cloudinary_config.__dict__.items() if not k.startswith("_")}
+    obfuscated_config = config_to_dict(cloudinary_config)
 
     if "api_secret" in obfuscated_config:
         api_secret = obfuscated_config["api_secret"]
@@ -96,6 +111,14 @@ def is_valid_cloudinary_config():
 def initialize():
     migrate_old_config()
 
+def ping_cloudinary(**options):
+    try:
+        api.ping(**options)
+    except Exception as e:
+        logger.error(f"Failed to ping Cloudinary: {e}")
+        return False
+
+    return True
 
 def _verify_file_path(file):
     os.makedirs(os.path.dirname(file), exist_ok=True)

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli/utils/utils.py

@@ -7,6 +7,7 @@ from csv import DictWriter
 from functools import reduce
 from hashlib import md5
 from inspect import signature, getfullargspec
+from typing import get_type_hints
 from multiprocessing import pool
 
 import click
@@ -14,10 +15,11 @@ import cloudinary
 from jinja2 import Environment, FileSystemLoader
 from docstring_parser import parse
 from cloudinary_cli.defaults import logger, TEMPLATE_FOLDER
+from cloudinary.utils import build_array
 
 not_callable = ('is_appengine_sandbox', 'call_tags_api', 'call_context_api', 'call_cacheable_api', 'call_api',
                 'call_metadata_api', 'call_json_api', 'only', 'transformation_string', 'account_config',
-                'reset_config', 'upload_large_part', 'upload_image', 'upload_resource')
+                'reset_config', 'upload_large_part', 'upload_image', 'upload_resource', 'build_eager')
 
 BLOCK_SIZE = 65536
 
@@ -127,9 +129,11 @@ def parse_args_kwargs(func, params=None, kwargs=None):
     num_req = num_args - num_defaults
     num_provided_args = len(params)
     num_overall_provided = num_provided_args + len([p for p in kwargs.keys() if p in spec.args[num_provided_args:]])
+
     if num_overall_provided < num_req:
         func_sig = signature(func)
         raise Exception(f"Function '{func.__name__}{func_sig}' requires {num_req} positional arguments")
+
     # consume required args
     args = [parse_option_value(p) for p in params[:num_req]]
 
@@ -142,8 +146,30 @@ def parse_args_kwargs(func, params=None, kwargs=None):
         k, v = p.split('=', 1)
         kwargs[k] = parse_option_value(v)
 
+    params_specs = parse(func.__doc__).params
+
+    if len(args) > num_req:
+        # Here we consumed more args than the function can get,
+        # let's see if we have a list arg and pass everything as list.
+        # Otherwise, let's pass everything as is and hope for the best :)
+        last_positional_list_param = next((s for s in reversed(params_specs) if s.arg_name not in kwargs and s.type_name and s.type_name.startswith('list')), None)
+        if last_positional_list_param:
+            pos = get_index_by_name(spec.args, last_positional_list_param.arg_name)
+            args[pos] = [args[pos]] + args[num_args:]
+            args = args[:num_args]
+
+    for s in params_specs:
+        if s.type_name and s.type_name.startswith('list'):
+            pos = get_index_by_name(spec.args, s.arg_name)
+            if isinstance(pos, int) and 0 <= pos < len(args):
+                args[pos] = normalize_list_params(args[pos])
+            if s.arg_name in kwargs:
+                kwargs[s.arg_name] = normalize_list_params(kwargs[s.arg_name])
+
     return args, kwargs
 
+def get_index_by_name(lst, name):
+    return next((i for i, item in enumerate(lst) if item == name), -1)
 
 def remove_string_prefix(string, prefix):
     return string[string.startswith(prefix) and len(prefix):]
@@ -297,18 +323,21 @@ def normalize_list_params(params):
     """
     Normalizes parameters that could be provided as strings separated by ','.
 
-    >>> normalize_list_params(["f1,f2", "f3"])
-    ["f1", "f2", "f3"]
+    >>> normalize_list_params(['f1,f2', 'f3'])
+    ['f1', 'f2', 'f3']
+
+    >>> normalize_list_params('f1,f2,f3')
+    ['f1', 'f2', 'f3']
 
     :param params: Params to normalize.
-    :type params: list
+    :type params: list[string] or string
 
     :return: A list of normalized params.
     :rtype list
     """
     normalized_params = []
-    for f in list(params):
-        if "," in f:
+    for f in build_array(params):
+        if isinstance(f, str) and "," in f:
             normalized_params += f.split(",")
         else:
             normalized_params.append(f)

cloudinary_cli-1.11.1/cloudinary_cli/version.py

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

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1/cloudinary_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudinary-cli
-Version: 1.10.3
+Version: 1.11.1
 Summary: A command line interface for Cloudinary with full API support
 Home-page: https://github.com/cloudinary/cloudinary-cli
 Author: Cloudinary, Brian Luk
@@ -13,13 +13,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cloudinary>=1.37.0
+Requires-Dist: cloudinary>=1.42.2
 Requires-Dist: pygments
 Requires-Dist: jinja2
 Requires-Dist: click
 Requires-Dist: click-log
 Requires-Dist: requests
 Requires-Dist: docstring-parser
+Requires-Dist: urllib3>=2.2.2
+Requires-Dist: zipp>=3.19.1
 
 [![Build Status](https://app.travis-ci.com/cloudinary/cloudinary-cli.svg)](https://app.travis-ci.com/cloudinary/cloudinary-cli)
 [![PyPI Downloads](https://img.shields.io/pypi/dm/cloudinary-cli.svg)](https://pypistats.org/packages/cloudinary-cli)

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ cloudinary_cli/core/search.py
 cloudinary_cli/core/uploader.py
 cloudinary_cli/core/utils.py
 cloudinary_cli/modules/__init__.py
+cloudinary_cli/modules/clone.py
 cloudinary_cli/modules/make.py
 cloudinary_cli/modules/migrate.py
 cloudinary_cli/modules/regen_derived.py

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/cloudinary_cli.egg-info/requires.txt

@@ -1,7 +1,9 @@
-cloudinary>=1.37.0
+cloudinary>=1.42.2
 pygments
 jinja2
 click
 click-log
 requests
 docstring-parser
+urllib3>=2.2.2
+zipp>=3.19.1

cloudinary_cli-1.11.1/requirements.txt

@@ -0,0 +1,9 @@
+cloudinary>=1.42.2
+pygments
+jinja2
+click
+click-log
+requests
+docstring-parser
+urllib3>=2.2.2 # not directly required, pinned by Snyk to avoid a vulnerability
+zipp>=3.19.1 # not directly required, pinned by Snyk to avoid a vulnerability

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/test/test_cli_search_api.py

@@ -36,3 +36,11 @@ class TestCLISearchApi(unittest.TestCase):
         self.assertIn('eyJleHByZXNzaW9uIjoiY2F0IiwibWF4X3Jlc3VsdHMiOjEwfQ==', result.output)
         self.assertIn('1000', result.output)
         self.assertIn('NEXT_CURSOR', result.output)
+
+    @patch(URLLIB3_REQUEST)
+    def test_search_folders(self, mocker):
+        mocker.return_value = API_MOCK_RESPONSE
+        result = self.runner.invoke(cli, ['search_folders', 'cat_folder'])
+
+        self.assertEqual(0, result.exit_code)
+        self.assertIn('"foo": "bar"', result.output)

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/test/test_modules/test_cli_sync.py

@@ -184,3 +184,36 @@ class TestCLISync(unittest.TestCase):
         self.assertEqual(0, result.exit_code)
         self.assertIn("Skipping 12 items", result.output)
         self.assertIn("Done!", result.output)
+
+
+    @retry_assertion
+    def test_cli_sync_push_dry_run(self):
+        self._upload_sync_files(TEST_FILES_DIR)
+
+        # wait for indexing to be updated
+        time.sleep(self.GRACE_PERIOD)
+
+        result = self.runner.invoke(cli, ['sync', '--push', '-F', self.LOCAL_PARTIAL_SYNC_DIR, self.CLD_SYNC_DIR, '--dry-run'])
+
+        # check that no files were uploaded
+        self.assertEqual(0, result.exit_code)
+        self.assertIn("Dry run mode enabled. The following files would be uploaded:", result.output)
+        self.assertIn("Done!", result.output)
+
+
+    @retry_assertion
+    def test_cli_sync_pull_dry_run(self):
+        self._upload_sync_files(TEST_FILES_DIR)
+
+        # wait for indexing to be updated
+        time.sleep(self.GRACE_PERIOD)
+
+        shutil.copytree(self.LOCAL_PARTIAL_SYNC_DIR, self.LOCAL_SYNC_PULL_DIR)
+
+        result = self.runner.invoke(cli, ['sync', '--pull', '-F', self.LOCAL_SYNC_PULL_DIR, self.CLD_SYNC_DIR, '--dry-run'])
+
+        # check that no files were downloaded
+        self.assertEqual(0, result.exit_code)
+        self.assertIn("Dry run mode enabled. The following files would be downloaded:", result.output)
+        self.assertIn("Done!", result.output)
+        

{cloudinary_cli-1.10.3 → cloudinary_cli-1.11.1}/test/test_utils.py

@@ -14,7 +14,7 @@ class UtilsTest(unittest.TestCase):
         self.assertDictEqual({"foo": "bar"}, parse_option_value('{"foo":"bar"}'))
         self.assertDictEqual({"an": "object", "or": "dict"}, parse_option_value('{"an":"object","or":"dict"}'))
         self.assertListEqual(
-            ["this", "will", "be", "read", "as","a", "list"],
+            ["this", "will", "be", "read", "as", "a", "list"],
             parse_option_value('["this","will","be","read","as","a","list"]')
         )
         self.assertListEqual(
@@ -62,6 +62,23 @@ class UtilsTest(unittest.TestCase):
         self.assertEqual(0, len(args))
         self.assertDictEqual({"arg1": "a1", "arg2": "a2"}, kwargs)
 
+        # should consume list values separated by spaces and commas
+        args, kwargs = parse_args_kwargs(_list_args_test_func, ["l0a0,l0a1,l0a2", "sa0", "l1a0", "sa2", "l1a1,l1a2", "l1a3"])
+        self.assertEqual(4, len(args))
+        self.assertListEqual(["l0a0", "l0a1", "l0a2"], args[0])
+        self.assertEqual("sa0", args[1])
+        self.assertListEqual(["l1a0", "l1a1", "l1a2", "l1a3"], args[2])
+        self.assertEqual("sa2", args[3])
+
+        # should consume list values separated by spaces and commas in kwargs
+        args, kwargs = parse_args_kwargs(_list_args_test_func,
+                                         ["l0a0,l0a1,l0a2", "sa0"], {"list_arg": "l1a0,l1a1", "non_list_arg2": "sa2"})
+        self.assertEqual(2, len(args))
+        self.assertListEqual(["l0a0", "l0a1", "l0a2"], args[0])
+        self.assertEqual("sa0", args[1])
+        self.assertListEqual(["l1a0", "l1a1"], kwargs["list_arg"])
+        self.assertEqual("sa2", kwargs["non_list_arg2"])
+
     def test_group_params(self):
         self.assertDictEqual({}, group_params([]))
         self.assertDictEqual({"k1": "v1", "k2": "v2"}, group_params([("k1", "v1"), ("k2", "v2")]))
@@ -113,7 +130,9 @@ class UtilsTest(unittest.TestCase):
 
     def test_normalize_list_params(self):
         """ should normalize a list of parameters """
-        self.assertEqual(["f1", "f2", "f3"], normalize_list_params(["f1,f2", "f3"]))
+        self.assertListEqual(["f1"], normalize_list_params("f1"))
+        self.assertListEqual(["f1", "f2", "f3"], normalize_list_params(["f1,f2", "f3"]))
+        self.assertListEqual(["f1", "f2", "f3"], normalize_list_params("f1,f2,f3"))
 
     def test_chunker(self):
         animals = ['cat', 'dog', 'rabbit', 'duck', 'bird', 'cow', 'gnu', 'fish']
@@ -131,3 +150,21 @@ def _only_args_test_func(arg1, arg2):
 
 def _args_kwargs_test_func(arg1, arg2=None):
     return arg1, arg2
+
+
+def _list_args_test_func(fist_list_arg, non_list_arg, list_arg=None, non_list_arg2=None):
+    """
+    Function for testing list args.
+
+    :param fist_list_arg: first list argument
+    :type fist_list_arg: list
+    :param non_list_arg: some non-list argument
+    :type non_list_arg: str
+    :param list_arg: some list argument
+    :type list_arg: list
+    :param non_list_arg2: another non-list argument
+    :type non_list_arg2: str
+    :return: tuple of arguments
+    :rtype: tuple
+    """
+    return fist_list_arg, non_list_arg, list_arg, non_list_arg2

cloudinary_cli-1.10.3/cloudinary_cli/core/search.py

@@ -1,129 +0,0 @@
-import cloudinary
-from click import command, argument, option, launch
-
-from cloudinary_cli.defaults import logger
-from cloudinary_cli.utils.json_utils import write_json_to_file, print_json
-from cloudinary_cli.utils.utils import write_json_list_to_csv, confirm_action, whitelist_keys, \
-    normalize_list_params
-
-DEFAULT_MAX_RESULTS = 500
-
-
-@command("search",
-         short_help="Run the admin API search method.",
-         help="""\b
-Run the admin API search method.
-Format: cld <cli options> search <command options> <Lucene query syntax string>
-e.g. cld search cat AND tags:kitten -s public_id desc -f context -f tags -n 10
-""")
-@argument("query", nargs=-1)
-@option("-f", "--with_field", multiple=True, help="Specify which non-default asset attributes to include "
-                                                  "in the result as a comma separated list. ")
-@option("-fi", "--fields", multiple=True, help="Specify which asset attributes to include in the result "
-                                               "(together with a subset of the default attributes) as a comma separated"
-                                               " list. This overrides any value specified for with_field.")
-@option("-s", "--sort_by", nargs=2, help="Sort search results by (field, <asc|desc>).")
-@option("-a", "--aggregate", nargs=1,
-        help="Specify the attribute for which an aggregation count should be calculated and returned.")
-@option("-n", "--max_results", nargs=1, default=10,
-        help="The maximum number of results to return. Default: 10, maximum: 500.")
-@option("-c", "--next_cursor", nargs=1, help="Continue a search using an existing cursor.")
-@option("-A", "--auto_paginate", is_flag=True, help="Return all results. Will call Admin API multiple times.")
-@option("-F", "--force", is_flag=True, help="Skip confirmation when running --auto-paginate.")
-@option("-ff", "--filter_fields", multiple=True, help="Specify which attributes to show in the response. "
-                                                      "None of the others will be shown.")
-@option("-t", "--ttl", nargs=1, default=300, help="Set the Search URL TTL in seconds. Default: 300.")
-@option("-u", "--url", is_flag=True, help="Build a signed search URL.")
-@option("-sq", "--search-query", is_flag=True, help="Show the search request query.", hidden=True)
-@option("--json", nargs=1, help="Save JSON output to a file. Usage: --json <filename>")
-@option("--csv", nargs=1, help="Save CSV output to a file. Usage: --csv <filename>")
-@option("-d", "--doc", is_flag=True, help="Open Search API documentation page.")
-def search(query, with_field, fields, sort_by, aggregate, max_results, next_cursor,
-           auto_paginate, force, filter_fields, ttl, url, search_query, json, csv, doc):
-    if doc:
-        return launch("https://cloudinary.com/documentation/search_api")
-
-    fields_to_keep = []
-    if filter_fields:
-        fields_to_keep = tuple(normalize_list_params(filter_fields)) + tuple(normalize_list_params(with_field))
-
-    search = cloudinary.search.Search().expression(" ".join(query))
-
-    if auto_paginate:
-        max_results = DEFAULT_MAX_RESULTS
-    if with_field:
-        search.with_field(normalize_list_params(with_field))
-    if fields:
-        search.fields(normalize_list_params(fields))
-    if sort_by:
-        search.sort_by(*sort_by)
-    if aggregate:
-        search.aggregate(aggregate)
-    if next_cursor:
-        search.next_cursor(next_cursor)
-    if ttl:
-        search.ttl(ttl)
-
-    search.max_results(max_results)
-
-    if url:
-        print(search.to_url())
-        return True
-
-    if search_query:
-        print_json(search.as_dict())
-        return True
-
-    res = execute_single_request(search, fields_to_keep)
-
-    if auto_paginate:
-        res = handle_auto_pagination(res, search, force, fields_to_keep)
-
-    print_json(res)
-
-    if json:
-        write_json_to_file(res['resources'], json)
-        logger.info(f"Saved search JSON to '{json}' file")
-
-    if csv:
-        write_json_list_to_csv(res['resources'], csv, fields_to_keep)
-        logger.info(f"Saved search to '{csv}.csv' file")
-
-
-def execute_single_request(expression, fields_to_keep):
-    res = expression.execute()
-
-    if fields_to_keep:
-        res['resources'] = whitelist_keys(res['resources'], fields_to_keep)
-
-    return res
-
-
-def handle_auto_pagination(res, expression, force, fields_to_keep):
-    if 'next_cursor' not in res:
-        return res
-
-    if not force:
-        if not confirm_action(
-                f"{res['total_count']} total results. "
-                f"{res.rate_limit_remaining + 1} Admin API rate limit remaining.\n"
-                f"Running this query will use {res['total_count'] // DEFAULT_MAX_RESULTS + 1} Admin API calls. "
-                f"Continue? (y/N)"):
-            logger.info("Stopping. Please run again without -A.")
-
-            return res
-        else:
-            logger.info("Continuing. You may use the -F flag to force auto_pagination.")
-
-    all_results = res
-    while 'next_cursor' in res.keys():
-        expression.next_cursor(res['next_cursor'])
-
-        res = execute_single_request(expression, fields_to_keep)
-
-        all_results['resources'] += res['resources']
-        all_results['time'] += res['time']
-
-    all_results.pop('next_cursor', None)  # it is empty by now
-
-    return all_results

cloudinary_cli-1.10.3/cloudinary_cli/version.py

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

cloudinary_cli-1.10.3/requirements.txt

@@ -1,7 +0,0 @@
-cloudinary>=1.37.0
-pygments
-jinja2
-click
-click-log
-requests
-docstring-parser