"delete_all_resources",

"delete_resources_by_prefix",

"delete_resources_by_tag",

if force or not is_destructive_bulk_api_method(method_name):

return True

display_api_name = api_name.capitalize()

if not confirm_action(

f"This will delete up to {MAX_DESTRUCTIVE_BULK_PER_CALL} matching assets via "

f"{display_api_name} API method '{method_name}'. Continue? (y/N)"):

logger.info("Stopping.")

return False

files = {}

folder = folder.strip('/') # omit redundant leading slash and duplicate trailing slashes in query

folder_key = "asset_folder" if folder_mode == "dynamic" else "folder"

folder_query = f"{folder}/*" if folder else "*"

status_value = "(active OR pending)" if status == "all" else status

status_query = f" AND status:{status_value}" if status_value else ""

search = Search().expression(f"{folder_key}:\"{folder_query}\"{status_query}").with_field("image_analysis").max_results(500)

logger.debug(f"Search expression: {search.to_json()}")

next_cursor = True

while next_cursor:

res = call_api(search.execute)

for asset in res['resources']:

rel_path = _relative_path(asset, folder)

rel_display_path = _relative_display_path(asset, folder)

path_key = rel_display_path if folder_mode == "dynamic" else rel_path

normalized_path_key = normalize_file_extension(path_key)

files[asset["asset_id"]] = {

"asset_id": asset['asset_id'],

"normalized_path": normalized_path_key,

"normalized_unique_path": normalized_path_key,

"type": asset['type'],

"resource_type": asset['resource_type'],

"public_id": asset['public_id'],

"format": asset['format'],

"etag": asset.get('etag', '0'),

"relative_path": rel_path, # save for inner use

"access_mode": asset.get('access_mode', 'public'),

"created_at": asset.get('created_at'),

# dynamic folder mode fields

"asset_folder": asset.get('asset_folder'),

"display_name": asset.get('display_name'),

"relative_display_path": rel_display_path

}

# use := when switch to python 3.8

next_cursor = res.get('next_cursor')

search.next_cursor(next_cursor)

folder = folder.strip('/') # omit redundant leading slash and duplicate trailing slashes in query

if not folder:

return True # root folder

res = call_api(SearchFolders().expression(f"path=\"{folder}\"").execute)

if asset.get("display_name") is None:

return ""

if asset["resource_type"] == "raw" or asset["type"] == 'fetch':

normalized_display_name = asset["display_name"]

else:

normalized_display_name = ".".join(filter(None, [asset["display_name"], asset.get("format", None)]))

if asset.get("display_name") is None:

return ""

source = asset_source(asset)

if not source.startswith(folder):

return source

eager_trans, eager_async,

eager_notification_url):

options = {"type": delivery_type, "resource_type": res_type,

"eager": eager_trans, "eager_async": eager_async,

"eager_notification_url": eager_notification_url,

"overwrite": True, "invalidate": True}

try:

exp_res = call_api(uploader.explicit, public_id, **options)

derived_url = f'{exp_res.get("eager")[0].get("secure_url")}'

msg = ('Processing' if options.get('eager_async') else 'Regenerated') + f' {derived_url}'

logger.info(style(msg, fg="green"))

except Exception as e:

error_msg = (f"Failed to regenerate {public_id} of type: "

f"{options.get('type')} and resource_type: "

f"{options.get('resource_type')}")

uploaded = uploaded if uploaded is not None else {}

failed = failed if failed is not None else {}

verbose = should_dump_responses()

try:

size = 0 if is_remote_url(file_path) else path.getsize(file_path)

# Fresh options copy: upload_large mutates it (sets public_id), so a retry stays independent.

if size > 20000000:

# upload_large recovers from a token 401 per chunk (SDK oauth_token_refresh_callback),

# resuming the upload; a whole-file retry here would restart from byte 0.

result = uploader.upload_large(file_path, **dict(options))

else:

result = call_api(uploader.upload, file_path, **dict(options))

disp_path = _display_path(result)

if "batch_id" in result:

starting_msg = "Uploading"

disp_str = f"asynchronously 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}

except Exception as e:

log_exception(e, f"Failed uploading {file_path}")

options = {

'resource_type': 'auto'

}

if folder_mode == 'fixed':

options = {

**options,

'use_filename': True,

'unique_filename': False,

'invalidate': True,

}

if folder_mode == 'dynamic':

options = {

**options,

'use_filename_as_display_name': True,

}

destination_folder = get_destination_folder(remote_dir, file, parent)

if folder_mode == "dynamic":

return {"asset_folder": destination_folder}

downloaded = downloaded if downloaded is not None else {}

failed = failed if failed is not None else {}

makedirs(path.dirname(local_path), exist_ok=True)

if remote_file['type'] in ("private", "authenticated") or remote_file['access_mode'] == "authenticated":

sign_url = True

else:

sign_url = False

download_url = cloudinary_url(asset_source(remote_file), resource_type=remote_file['resource_type'],

type=remote_file['type'], sign_url=sign_url)[0]

result = requests.get(download_url)

if result.status_code != 200:

err = result.headers.get('x-cld-error')

msg = f"Failed downloading: {download_url}, status code: {result.status_code}, " \

f"details: {err}"

logger.error(msg)

failed[download_url] = err

return

with open(local_path, "wb") as f:

f.write(result.content)

downloaded[remote_file['relative_path']] = local_path

"""

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

"""

try:

config_res = call_api(api.config, settings="true")

mode = config_res["settings"]["folder_mode"]

logger.debug(f"Using {mode} folder mode")

except Exception as e:

log_exception(e, f"Failed getting cloud configuration")

raise

"""

config = cloudinary.config()

token = getattr(config, "oauth_token", None) # the token this request will carry

# Pin the token so the value sent is provably the value handed to invalidate_token: without it the

# SDK re-reads the self-refreshing oauth_token and a peer rotation between reads breaks the decision.

pinned = dict(kwargs, oauth_token=token) if token else kwargs

try:

try:

return func(*args, **pinned)

except AuthorizationRequired:

if not getattr(config, "has_oauth", False) or not config.invalidate_token(token):

raise

return func(*args, **kwargs) # retry unpinned: the SDK re-reads the freshly rotated token

except Exception:

logger.debug(f"Failed calling '{func.__name__}' with args: {args} and optional args {kwargs}", exc_info=True)

params,

optional_parameter,

optional_parameter_parsed,

module,

module_name):

try:

func, args, kwargs = get_command_params(params, optional_parameter, optional_parameter_parsed, module,

module_name)

except Exception as e:

log_exception(e)

return False

try:

return call_api(func, *args, **kwargs)

except Exception as e:

log_exception(e)

params,

optional_parameter,

optional_parameter_parsed,

ls,

save,

doc,

doc_url,

api_instance,

api_name,

auto_paginate=False,

force=False,

filter_fields=None,

return_data=False):

"""

if doc:

return launch(doc_url)

if ls or len(params) < 1:

return print_api_help(api_instance)

try:

func, args, kwargs = get_command_params(params, optional_parameter, optional_parameter_parsed, api_instance,

api_name)

except Exception as e:

log_exception(e)

return False

if not confirm_destructive_bulk_api_method(api_name, func.__name__, force):

return False

if not is_public_api_method(api_name, func.__name__) and not is_valid_cloudinary_config():

if user_config_names():

raise ConfigurationError("No default Cloudinary configuration is set. "

"Select one with `-C <name>` or set a default with `cld config -d <name>`.")

raise ConfigurationError("No Cloudinary configuration found.")

try:

res = call_api(func, *args, **kwargs)

except Exception as e:

log_exception(e)

return False

if auto_paginate:

res = handle_auto_pagination(res, func, args, kwargs, force, filter_fields)

if return_data:

return res

print_json(res)

if save:

cursor_field = _cursor_fields.get(func.__name__, "next_cursor")

if cursor_field not in res:

return res

if not force:

if not confirm_action(

"Using auto pagination will use multiple API calls.\n" +

f"You currently have {res.rate_limit_remaining} Admin API calls remaining. 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.")

fields_to_keep = []

if filter_fields:

fields_to_keep = normalize_list_params(filter_fields)

kwargs['max_results'] = PAGINATION_MAX_RESULTS

all_results = res

# We have many different APIs that have different fields that we paginate.

# The field is unknown before we perform the second call and then compare results and find the field.

pagination_field = None

while res.get(cursor_field, None):

kwargs[cursor_field] = res.get(cursor_field, None)

res = call_api(func, *args, **kwargs)

all_results, pagination_field = merge_responses(all_results, res, fields_to_keep=fields_to_keep,

pagination_field=pagination_field)

all_results.pop(cursor_field, None)