("font_style", "normal"),

("text_decoration", "none"),

("text_align", None),

'api_secret',

'auth_token',

'cdn_subdomain',

'cloud_name',

'cname',

'format',

'private_cdn',

'resource_type',

'secure',

'secure_cdn_subdomain',

'secure_distribution',

'shorten',

'sign_url',

'ssl_detected',

'type',

'url_suffix',

'use_root_path',

'version',

'long_url_signature',

'signature_algorithm',

"public_id",

"public_id_prefix",

"callback",

"format",

"type",

"backup",

"faces",

"image_metadata",

"media_metadata",

"exif",

"colors",

"use_filename",

"unique_filename",

"display_name",

"use_filename_as_display_name",

"discard_original_filename",

"filename_override",

"invalidate",

"notification_url",

"eager_notification_url",

"eager_async",

"eval",

"on_success",

"proxy",

"folder",

"asset_folder",

"use_asset_folder_as_public_id_prefix",

"unique_display_name",

"overwrite",

"moderation",

"raw_convert",

"quality_override",

"quality_analysis",

"ocr",

"categorization",

"detection",

"similarity_search",

"visual_search",

"background_removal",

"upload_preset",

"phash",

"return_delete_token",

"auto_tagging",

"async",

"cinemagraph_analysis",

"accessibility_analysis",

"auto_chaptering",

"timestamp",

"transformation",

"headers",

"eager",

"tags",

"allowed_formats",

"face_coordinates",

"custom_coordinates",

"regions",

"context",

"auto_tagging",

"responsive_breakpoints",

"access_control",

"metadata",

"auto_transcription",

"ac": "audio_codec",

"af": "audio_frequency",

"br": "bit_rate",

"cs": "color_space",

"d": "default_image",

"dl": "delay",

"dn": "density",

"f": "fetch_format",

"g": "gravity",

"p": "prefix",

"pg": "page",

"sp": "streaming_profile",

"vs": "video_sampling",

"""

try:

hash_fn = signature_algorithms[algorithm]

except KeyError:

raise ValueError('Unsupported hash algorithm: {}'.format(algorithm))

if isinstance(arg, (list, tuple)):

return arg

elif arg is None:

return []

"""

if val is None:

return []

if isinstance(val, str):

# use OrderedDict to preserve order

val = json.loads(val, object_pairs_hook=OrderedDict)

if isinstance(val, dict):

val = [val]

for index, item in enumerate(val):

if isinstance(item, str):

# use OrderedDict to preserve order

val[index] = json.loads(item, object_pairs_hook=OrderedDict)

if not isinstance(val[index], dict):

raise ValueError("Expected a list of dicts")

array = build_array(array)

if len(array) > 0 and isinstance(array[0], list):

return "|".join([",".join([str(i) for i in build_array(inner)]) for inner in array])

if isinstance(arg, dict):

if PY3:

items = arg.items()

else:

items = arg.iteritems()

return "|".join((k + "=" + v) for k, v in items)

"""

if isinstance(value, (list, tuple)):

value = json_encode(value)

"""

if not isinstance(context, dict):

return context

"""

if isinstance(value, str) or value is None:

return value

"""

"""

use_fetch_format = options.pop("use_fetch_format", cloudinary.config().use_fetch_format)

if options.get("type", "upload") != "fetch" and not use_fetch_format:

return

resource_format = options.pop("format", None)

if "fetch_format" not in options:

responsive_width = options.pop("responsive_width", cloudinary.config().responsive_width)

size = options.pop("size", None)

if size:

options["width"], options["height"] = size.split("x")

width = options.get("width")

height = options.get("height")

has_layer = ("underlay" in options) or ("overlay" in options)

crop = options.pop("crop", None)

angle = ".".join([str(value) for value in build_array(options.pop("angle", None))])

no_html_sizes = has_layer or angle or crop == "fit" or crop == "limit" or responsive_width

if width and (str(width).startswith("auto") or str(width) == "ow" or is_fraction(width) or no_html_sizes):

del options["width"]

if height and (str(height) == "oh" or is_fraction(height) or no_html_sizes):

del options["height"]

background = options.pop("background", None)

if background:

background = background.replace("#", "rgb:")

color = options.pop("color", None)

if color:

color = color.replace("#", "rgb:")

base_transformations = build_array(options.pop("transformation", None))

if any(isinstance(bs, dict) for bs in base_transformations):

def recurse(bs):

if isinstance(bs, dict):

return generate_transformation_string(**bs)[0]

return generate_transformation_string(transformation=bs)[0]

base_transformations = list(map(recurse, base_transformations))

named_transformation = None

else:

named_transformation = ".".join(base_transformations)

base_transformations = []

effect = options.pop("effect", None)

if isinstance(effect, list):

effect = ":".join([str(x) for x in effect])

elif isinstance(effect, dict):

effect = ":".join([str(x) for x in list(effect.items())[0]])

border = options.pop("border", None)

if isinstance(border, dict):

border_color = border.get("color", "black").replace("#", "rgb:")

border = "%(width)spx_solid_%(color)s" % {"color": border_color,

"width": str(border.get("width", 2))}

flags = ".".join(build_array(options.pop("flags", None)))

dpr = options.pop("dpr", cloudinary.config().dpr)

duration = norm_range_value(options.pop("duration", None))

so_raw = options.pop("start_offset", None)

start_offset = norm_auto_range_value(so_raw)

if start_offset == None:

start_offset = so_raw

eo_raw = options.pop("end_offset", None)

end_offset = norm_range_value(eo_raw)

if end_offset == None:

end_offset = eo_raw

offset = split_range(options.pop("offset", None))

if offset:

start_offset = norm_auto_range_value(offset[0])

end_offset = norm_range_value(offset[1])

video_codec = process_video_codec_param(options.pop("video_codec", None))

aspect_ratio = options.pop("aspect_ratio", None)

if isinstance(aspect_ratio, Fraction):

aspect_ratio = str(aspect_ratio.numerator) + ":" + str(aspect_ratio.denominator)

overlay = process_layer(options.pop("overlay", None), "overlay")

underlay = process_layer(options.pop("underlay", None), "underlay")

if_value = process_conditional(options.pop("if", None))

custom_function = process_custom_function(options.pop("custom_function", None))

custom_pre_function = process_custom_pre_function(options.pop("custom_pre_function", None))

fps = process_fps(options.pop("fps", None))

params = {

"a": normalize_expression(angle),

"ar": normalize_expression(aspect_ratio),

"b": background,

"bo": border,

"c": crop,

"co": color,

"dpr": normalize_expression(dpr),

"du": normalize_expression(duration),

"e": normalize_expression(effect),

"eo": normalize_expression(end_offset),

"fl": flags,

"fn": custom_function or custom_pre_function,

"fps": fps,

"h": normalize_expression(height),

"ki": process_ki(options.pop("keyframe_interval", None)),

"l": overlay,

"o": normalize_expression(options.pop('opacity', None)),

"q": normalize_expression(options.pop('quality', None)),

"r": process_radius(options.pop('radius', None)),

"so": normalize_expression(start_offset),

"t": named_transformation,

"u": underlay,

"w": normalize_expression(width),

"x": normalize_expression(options.pop('x', None)),

"y": normalize_expression(options.pop('y', None)),

"vc": video_codec,

"z": normalize_expression(options.pop('zoom', None))

}

for param, option in _SIMPLE_TRANSFORMATION_PARAMS.items():

params[param] = options.pop(option, None)

variables = options.pop('variables', {})

var_params = []

for key, value in options.items():

if re.match(r'^\$', key):

var_params.append(u"{0}_{1}".format(key, normalize_expression(str(value))))

var_params.sort()

if variables:

for var in variables:

var_params.append(u"{0}_{1}".format(var[0], normalize_expression(str(var[1]))))

variables = ','.join(var_params)

sorted_params = sorted([param + "_" + str(value) for param, value in params.items() if (value or value == 0)])

if variables:

sorted_params.insert(0, str(variables))

if if_value is not None:

sorted_params.insert(0, "if_" + str(if_value))

if "raw_transformation" in options and (options["raw_transformation"] or options["raw_transformation"] == 0):

sorted_params.append(options.pop("raw_transformation"))

transformation = ",".join(sorted_params)

transformations = base_transformations + [transformation]

if responsive_width:

responsive_width_transformation = cloudinary.config().responsive_width_transformation \

or DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION

transformations += [generate_transformation_string(**responsive_width_transformation)[0]]

url = "/".join([trans for trans in transformations if trans])

if str(width).startswith("auto") or responsive_width:

options["responsive"] = True

if dpr == "auto":

options["hidpi"] = True

"""

transformations = copy.deepcopy(transformations)

transformations = build_array(transformations)

# preserve url options

url_options = dict((o, options[o]) for o in __URL_KEYS if o in options)

transformations.insert(0, options)

url_options["transformation"] = transformations

if (isinstance(range, list) or isinstance(range, tuple)) and len(range) >= 2:

return [range[0], range[-1]]

elif isinstance(range, string_types) and re.match(RANGE_RE, range):

return range.split("..", 1)

if value is None:

return None

match = re.match(RANGE_VALUE_RE, str(value))

if match is None:

return None

modifier = ''

if match.group('modifier') is not None:

modifier = 'p'

out_param = param

if isinstance(out_param, dict):

out_param = param['codec']

if 'profile' in param:

out_param = out_param + ':' + param['profile']

if 'level' in param:

out_param = out_param + ':' + param['level']

if param.get('b_frames') is False:

out_param = out_param + ':' + 'bframes_no'

if param is None:

return

if isinstance(param, (list, tuple)):

if not 1 <= len(param) <= 4:

raise ValueError("Invalid radius param")

return ':'.join(normalize_expression(t) for t in param)

processed_params = None

if isinstance(params, dict):

processed_params = {}

for key, value in params.items():

if isinstance(value, list) or isinstance(value, tuple):

if len(value) == 2 and value[0] == "file": # keep file parameter as is.

processed_params[key] = value

continue

value_list = {"{}[{}]".format(key, i): i_value for i, i_value in enumerate(value)}

processed_params.update(value_list)

elif value is not None:

processed_params[key] = value

"""

"""

if not params or not isinstance(params, dict):

return params

api_key = options.get("api_key", cloudinary.config().api_key)

if not api_key:

raise ValueError("Must supply api_key")

api_secret = options.get("api_secret", cloudinary.config().api_secret)

if not api_secret:

raise ValueError("Must supply api_secret")

signature_algorithm = options.get("signature_algorithm", cloudinary.config().signature_algorithm)

signature_version = options.get("signature_version", cloudinary.config().signature_version)

params = cleanup_params(params)

params["signature"] = api_sign_request(params, api_secret, signature_algorithm, signature_version)

params["api_key"] = api_key

"""

to_sign = api_string_to_sign(params_to_sign, signature_version)

"""

params = []

for k, v in params_to_sign.items():

if v:

if isinstance(v, list):

value = ",".join(v)

elif isinstance(v, bool):

value = str(v).lower()

else:

value = str(v)

param_string = k + "=" + value

if signature_version >= 2:

param_string = _encode_param(param_string)

params.append(param_string)

"""

breakpoint_settings = copy.deepcopy(breakpoint_settings)

transformation = breakpoint_settings.get("transformation")

if transformation is not None:

breakpoint_settings["transformation"], _ = generate_transformation_string(**transformation)

if breakpoints is None:

return None

breakpoints = build_array(breakpoints)

source = re.sub(r'([^:])/+', r'\1/', source)

if re.match(r'^https?:/', source):

source = smart_escape(source)

source_to_sign = source

else:

source = unquote(source)

if not PY3:

source = source.encode('utf8')

source = smart_escape(source)

source_to_sign = source

if url_suffix is not None:

if re.search(r'[\./]', url_suffix):

raise ValueError("url_suffix should not include . or /")

source = source + "/" + url_suffix

if format is not None:

source = source + "." + format

source_to_sign = source_to_sign + "." + format

upload_type = type or "upload"

if url_suffix is not None:

if resource_type == "image" and upload_type == "upload":

resource_type = "images"

upload_type = None

elif resource_type == "raw" and upload_type == "upload":

resource_type = "files"

upload_type = None

else:

raise ValueError("URL Suffix only supported for image/upload and raw/upload")

if use_root_path:

if (resource_type == "image" and upload_type == "upload") or (

resource_type == "images" and upload_type is None):

resource_type = None

upload_type = None

else:

raise ValueError("Root path only supported for image/upload")

if shorten and resource_type == "image" and upload_type == "upload":

resource_type = "iu"

upload_type = None

secure_cdn_subdomain, cname, secure, secure_distribution):

"""cdn_subdomain and secure_cdn_subdomain

shared_domain = not private_cdn

shard = __crc(source)

if secure:

if secure_distribution is None or secure_distribution == cloudinary.OLD_AKAMAI_SHARED_CDN:

secure_distribution = cloud_name + "-res.cloudinary.com" \

if private_cdn else cloudinary.SHARED_CDN

shared_domain = shared_domain or secure_distribution == cloudinary.SHARED_CDN

if secure_cdn_subdomain is None and shared_domain:

secure_cdn_subdomain = cdn_subdomain

if secure_cdn_subdomain:

secure_distribution = re.sub('res.cloudinary.com', "res-" + shard + ".cloudinary.com",

secure_distribution)

prefix = "https://" + secure_distribution

elif cname:

subdomain = "a" + shard + "." if cdn_subdomain else ""

prefix = "http://" + subdomain + cname

else:

subdomain = cloud_name + "-res" if private_cdn else "res"

if cdn_subdomain:

subdomain = subdomain + "-" + shard

prefix = "http://" + subdomain + ".cloudinary.com"

if shared_domain:

prefix += "/" + cloud_name

source = options.pop('source', '')

cloud_name = options.pop("cloud_name", cloudinary.config().cloud_name or None)

if cloud_name is None:

raise ValueError("Must supply cloud_name in tag or in configuration")

secure = options.pop("secure", cloudinary.config().secure)

private_cdn = options.pop("private_cdn", cloudinary.config().private_cdn)

cname = options.pop("cname", cloudinary.config().cname)

secure_distribution = options.pop("secure_distribution",

cloudinary.config().secure_distribution)

cdn_subdomain = options.pop("cdn_subdomain", cloudinary.config().cdn_subdomain)

secure_cdn_subdomain = options.pop("secure_cdn_subdomain",

cloudinary.config().secure_cdn_subdomain)

return unsigned_download_url_prefix(

source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain,

result = None

for dictionary in dict_args:

if dictionary is not None:

if result is None:

result = dictionary.copy()

else:

result.update(dictionary)

original_source = source

patch_fetch_format(options)

type = options.pop("type", "upload")

transformation, options = generate_transformation_string(**options)

resource_type = options.pop("resource_type", "image")

force_version = options.pop("force_version", cloudinary.config().force_version)

if force_version is None:

force_version = True

version = options.pop("version", None)

format = options.pop("format", None)

shorten = options.pop("shorten", cloudinary.config().shorten)

sign_url = options.pop("sign_url", cloudinary.config().sign_url)

api_secret = options.pop("api_secret", cloudinary.config().api_secret)

url_suffix = options.pop("url_suffix", None)

use_root_path = options.pop("use_root_path", cloudinary.config().use_root_path)

auth_token = options.pop("auth_token", None)

long_url_signature = options.pop("long_url_signature", cloudinary.config().long_url_signature)

signature_algorithm = options.pop("signature_algorithm", cloudinary.config().signature_algorithm)

if auth_token is not False:

auth_token = merge(cloudinary.config().auth_token, auth_token)

if (not source) or type == "upload" and re.match(r'^https?:', source):

return original_source, options

resource_type, type = finalize_resource_type(

resource_type, type, url_suffix, use_root_path, shorten)

source, source_to_sign = finalize_source(source, format, url_suffix)

if not version and force_version \

and source_to_sign.find("/") >= 0 \

and not re.match(r'^https?:/', source_to_sign) \

and not re.match(r'^v[0-9]+', source_to_sign):

version = "1"

if version:

version = "v" + str(version)

else:

version = None

transformation = re.sub(r'([^:])/+', r'\1/', transformation)

signature = None

if sign_url and (not auth_token or auth_token.pop('set_url_signature', False)):

to_sign = "/".join(__compact([transformation, source_to_sign]))

if long_url_signature:

# Long signature forces SHA256

signature_algorithm = SIGNATURE_SHA256

chars_length = LONG_URL_SIGNATURE_LENGTH

else:

chars_length = SHORT_URL_SIGNATURE_LENGTH

if signature_algorithm not in signature_algorithms:

raise ValueError("Unsupported signature algorithm '{}'".format(signature_algorithm))

hash_fn = signature_algorithms[signature_algorithm]

signature = "s--" + to_string(

base64.urlsafe_b64encode(

hash_fn(to_bytes(to_sign + api_secret)).digest())[0:chars_length]) + "--"

options["source"] = source

prefix = build_distribution_domain(options)

source = "/".join(__compact(

[prefix, resource_type, type, signature, transformation, version, source]))

if sign_url and auth_token:

path = urlparse(source).path

token = cloudinary.auth_token.generate(**merge(auth_token, {"url": path}))

source = "%s?%s" % (source, token)

cloudinary_prefix = options.get("upload_prefix", cloudinary.config().upload_prefix) \

or "https://api.cloudinary.com"

cloud_name = options.get("cloud_name", cloudinary.config().cloud_name)

if not cloud_name:

raise ValueError("Must supply cloud_name")

path = build_array(path)

params = params.copy()

params["mode"] = "download"

cloudinary_params = sign_request(params, options)

"""

# preserve options from being destructed

options = copy.deepcopy(options)

if transformation:

if isinstance(transformation, string_types):

transformation = {"raw_transformation": transformation}

# Remove all transformation related options

options = dict((o, options[o]) for o in __URL_KEYS if o in options)

options.update(transformation)

scale_transformation = {"crop": "scale", "width": width}

url_options = options

patch_fetch_format(url_options)

url_options = chain_transformations(url_options, scale_transformation)

"""

def pack(m):

return to_bytes('%' + "%".join(

["%02X" % x for x in struct.unpack('B' * len(m.group(1)), m.group(1))]

).upper())

cloudinary_params = sign_request({

"timestamp": now(),

"public_id": public_id,

"format": format,

"type": options.get("type"),

"attachment": options.get("attachment"),