stack or with for auto-release?

[MarioMey]

As you, @upgradeQ suggested to me, I started using @contextmanager functions to auto-release elements. But now, I see that I use that functions in 2 different ways: with and stack. This is part of the code and then, the complete file:

from contextlib import contextmanager, ExitStack
@contextmanager
def source_auto_release(source_name):
	source = obs.obs_get_source_by_name(source_name)
	try:
		yield source
	finally:
		obs.obs_source_release(source)

@contextmanager
def source_list_auto_release(source_list):
	try:
		yield source_list
	finally:
		obs.source_list_release(source_list)

# Functions
def source_set_volume(unused_addr, source_name, volume):
	with ExitStack() as stack:
		source = stack.enter_context(source_auto_release(source_name))
		if source:
			obs.obs_source_set_volume(source, volume)
		else: print(f'Source no existe: {source_name}')

def item_set_visible(unused_addr, scene_name, item_name, visible):
	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_visible() Scene no existe: "{scene_name}"')
		return
	with source_list_auto_release(scenes_list):
		scene_item = obs.obs_scene_find_source(scene, item_name)
		if scene_item:
			obs.obs_sceneitem_set_visible(scene_item, bool(visible))
		else:
			print(f'item_set_visible() Item no existe: "{item_name}"')

Do they do the same? Is one better than the other? Can I unify and use only one method?

Full code

#!/usr/bin/env python3

from contextlib import contextmanager, ExitStack
import random, time, datetime, threading, logging, string, json
import obspython as obs

import requests
from io import BytesIO

from pythonosc import dispatcher
from pythonosc import osc_server
from pythonosc import udp_client


from PIL import Image

import globalDict

targetIp = "127.0.0.1"
targetPort = 10000

client = udp_client.SimpleUDPClient(targetIp, targetPort)
client.send_message("/init", 1)

bolita_image   = '/home/mario/videoconfestejo/juegos/ark/bola.png'


sd = obs.obs_video_info()
obs.obs_get_video_info(sd)


class Color:
	def __init__(self):
		self.reset = '\x1b[0m'
		self.blanco = '\x1b[97m'
		self.negro = '\x1b[90m'
		self.rojo = '\x1b[91m'
		self.verde = '\x1b[92m'
		self.azul = '\x1b[94m'
		self.amarillo = '\x1b[93m'
		self.magenta = '\x1b[95m'
		self.magenta_bold = '\x1b[95;1m'
		self.azul_bold = '\x1b[94;1m'
		self.cian = '\x1b[96m'
		self.naranja = '\x1b[38;5;202m'
		self.violeta = '\x1b[38;5;129m'
		self.rosa = '\x1b[38;5;213m'
		self.ocre = '\x1b[38;5;172m'
		self.marron = '\x1b[38;5;52m'
		self.musgo = '\x1b[38;5;58m'
		self.error = '\x1b[93;41m'
		self.remoto = '\x1b[93;42m'
		self.debug = '\x1b[93;44m'
		self.lista_attrs = []
		self.attrs = self.__dict__
		
		for k, v in self.attrs.items():
			if k not in ['lista_attrs', 'attrs', 'random']:
				self.lista_attrs.append(v)
	
		self.random = random.choice(self.lista_attrs)
c = Color()

def c1(texto, color_texto=c.azul_bold):
	if globalDict.gd['verbose'] > 0:
		texto = str(texto)
		print(color_texto, texto, c.reset)

def c2(texto, color_texto=c.azul):
	if globalDict.gd['verbose'] > 1:
		texto = str(texto)
		print(color_texto, texto, c.reset)

def c3(texto, color_texto=c.cian):
	if globalDict.gd['verbose'] > 2:
		texto = str(texto)
		print(color_texto, texto, c.reset)

def c4(texto, color_texto=c.rosa):
	if globalDict.gd['verbose'] > 3:
		texto = str(texto)
		print(color_texto, texto, c.reset)

def consola(texto, color_texto=c.verde):
	texto = str(texto)
	print(color_texto, texto, c.reset)

def consola_hslider(num1, start=0, end=1, largo=10, num2=None):
	print(start, c.amarillo, end='')
	for i in range(largo):
		lugar1 = int(((num1  - start) / (end - start)) * largo)
		lugar2 = int(((num2  - start) / (end - start)) * largo)
		if i == lugar1:                              print('*', end='')
		elif num2 != None and i == lugar2:           print('$', end='')
		elif num2 != None and i == lugar1 == lugar2: print('&', end='')
		else:
			if start < 0 < end and i == int((-start / (end - start)) * largo): print('0', end='')
			else:                                                              print('.', end='')
	print(end, num1, '\r', c.reset, end='')

# Conversión lineal de x0-x1 -> y0-y1.
def lin_eq_conv(x, x0, x1, y0, y1):
	a = (y0 - y1) / (x0 - x1)
	b = -(a * x0) + y0
	return a * x + b

# Threading
def th(function, args=[]):
	t = threading.Thread(
		target=function,
		args=(args),
		name=f'{function}({args})',
		daemon=True)
	t.start()

def delay_func(funcion, delay, args=[]):
	time.sleep(delay)
	funcion(*args)

# Convierte una línea de texto, cortando las palabras
def text2paragraph(text, max_char=22, new_line='\n'):
	palabras, lineas = text.split(' '), []
	palabra_count, linea_count = 0, 0
	while palabra_count < len(palabras):
		lineas.append('')
		lineas[linea_count] += palabras[palabra_count] + ' '
		palabra_count += 1
		while len(lineas[linea_count]) < max_char and palabra_count < len(palabras):
			lineas[linea_count] += palabras[palabra_count] + ' '
			palabra_count += 1
		linea_count += 1
	return str(new_line).join([str(linea) for linea in lineas])

# Convierte [r,g,b] en decimal
def rgb2decimal(rgb):
	return int((256**3)*1*255) + int((256**2)*rgb[2]*255) + int(256*rgb[1]*255) + int(rgb[0]*255)

@contextmanager
def scene_ar(scene):
	scene = obs.obs_scene_from_source(scene)
	try:
		yield scene
	finally:
		obs.obs_scene_release(scene)

@contextmanager
def scene_enum(items):
	items = obs.obs_scene_enum_items(items)
	try:
		yield items
	finally:
		obs.sceneitem_list_release(items)

@contextmanager
def source_auto_release(source_name):
	source = obs.obs_get_source_by_name(source_name)
	try:
		yield source
	finally:
		obs.obs_source_release(source)

@contextmanager
def source_list_auto_release(source_list):
	try:
		yield source_list
	finally:
		obs.source_list_release(source_list)

@contextmanager
def items_list_auto_release(items_list):
	try:
		yield items_list
	finally:
		obs.source_list_release(items_list)

@contextmanager
def new_settings():
	newSettings = obs.obs_data_create()
	try:
		yield newSettings
	finally:
		obs.obs_data_release(newSettings)

# contextmanagers MIOS???
@contextmanager
def get_source(item):
	source = obs.obs_sceneitem_get_source(item)
	try:
		yield source
	finally:
		obs.obs_source_release(source)

@contextmanager
def get_filter(source, filter_name):
	filter_ = obs.obs_source_get_filter_by_name(source, filter_name)
	try:
		yield filter_
	finally:
		obs.obs_source_release(filter_)


def get_selected_scene(scene_name):
	scenes = obs.obs_frontend_get_scenes()
	found = False
	for scene in scenes:
		name = obs.obs_source_get_name(scene)
		if name == scene_name:
			found = True
	obs.source_list_release(scenes)
	return found

def get_scene_context(scene_name):
	scenes_list = obs.obs_frontend_get_scenes()
	for scene in scenes_list:
		name = obs.obs_source_get_name(scene)
		# consola(name, c.debug)
		if name == scene_name:
			# consola(f'encontrada {name}', c.violeta)
			return_scene = obs.obs_scene_from_source(scene)
			return return_scene, scenes_list

def scene_change(unused_addr, scene_name, trans='Fade', duration=500):
	consola(f'Cambiando a escena "{scene_name}"')
	scenes = obs.obs_frontend_get_scenes()
	for scene in scenes:
		name = obs.obs_source_get_name(scene)
		if name == scene_name:
			obs.obs_frontend_set_current_scene(scene)
	obs.source_list_release(scenes)

def source_set_volume(unused_addr, source_name, volume):
	c2(f'source_set_volume(source_name="{source_name}", volume={volume})')
	with ExitStack() as stack:
		source = stack.enter_context(source_auto_release(source_name))
		if source:
			obs.obs_source_set_volume(source, volume)
		else: print(f'Source no existe: {source_name}')


def source_filter_set_value(unused_addr, source_name, filter_name, setting, value):
	c2(f'source_filter_set_value(source_name="{source_name}",')
	c2(f'	filter_name="{filter_name}", setting={setting}, value={value})')

	with ExitStack() as stack:
		source = stack.enter_context(source_auto_release(source_name))
		if source:
			filter_ = stack.enter_context(get_filter(source, filter_name))
			if filter_:
				newSettings = stack.enter_context(new_settings())
				if filter_name in ['opacity', 'hue_shift']:
					obs.obs_data_set_int(newSettings, setting, int(value))
				else:
					if type(value) == str:
						obs.obs_data_set_string(newSettings, setting, value)
					elif type(value) == int:
						obs.obs_data_set_int(newSettings, setting, value)
					elif type(value) == float:
						obs.obs_data_set_double(newSettings, setting, value)
				obs.obs_source_update(filter_, newSettings)
			else: print(f'Filter no existe: {filter_name}')
		else: print(f'Source no existe: {source_name}')

def source_set_opacity(unused_addr, source_name, opacity):
	source_filter_set_value(None, source_name, 'Color Correction', 'opacity', int(opacity))

def source_set_hue(unused_addr, source_name, hue):
	source_filter_set_value(None, source_name, 'Color Correction', 'hue_shift', int(hue))

def source_set_bri_sat_hue(unused_addr, source_name, valores):
	source_filter_set_value(None, source_name, 'Color Correction', 'brightness', float(valores[0]))
	source_filter_set_value(None, source_name, 'Color Correction', 'saturation', float(valores[1]))
	source_filter_set_value(None, source_name, 'Color Correction', 'hue_shift', int(valores[2]))

def source_set_con_bri_sat_hue(unused_addr, source_name, valores):
	source_filter_set_value(None, source_name, 'Color Correction', 'contrast', float(valores[0]))
	source_filter_set_value(None, source_name, 'Color Correction', 'brightness', float(valores[1]))
	source_filter_set_value(None, source_name, 'Color Correction', 'saturation', float(valores[2]))
	source_filter_set_value(None, source_name, 'Color Correction', 'hue_shift', int(valores[3]))

def source_filter_set_enabled(unused_addr, source_name, filter_name, boolean):
	c2(f'source_filter_set_enabled(source_name="{source_name}", {filter_name}, {boolean})')
	with ExitStack() as stack:
		source = stack.enter_context(source_auto_release(source_name))
		if source:
			filter_ = stack.enter_context(get_filter(source, filter_name))
			if filter_:
				obs.obs_source_set_enabled(filter_, bool(boolean))
			else: print(f'Filter no existe: {filter_name}')
		else: print(f'Source no existe: {source_name}')

def source_set_lut_file(unused_addr, source_name, filter_name, lut_file):
	source_filter_set_value(None, source_name=source_name,
		filter_name='lut', setting='image_path', value=lut_file)

def source_set_image_file(unused_addr, source_name, image_file, from_web=False):
	c2(f'source_set_image_file(source_name="{source_name}", image_file="{image_file}", from_web={from_web})')
	
	size_   = list()
	mode_   = str()
	format_ = str()

	# Chequear archivo
	if from_web:
		newSettings = requests.get(image_file)
		try:
			with Image.open(BytesIO(newSettings.content)) as im:
				size_   = list(im.size)
				mode_   = list(im.mode)
				format_ = list(im.format)
		except FileNotFoundError:
			print(f'Image_file (from_web) no existe: {image_file}')
			return
	else:
		try:
			with Image.open(image_file) as im:
				size_   = list(im.size)
				mode_   = list(im.mode)
				format_ = list(im.format)
		except FileNotFoundError:
			print(f'Image_file no existe: {image_file}')
			return
	
	source_set_setting(None, source_name=source_name, setting='file', value=image_file)
	return {'size': size_, 'mode': mode_, 'format':format_}

def source_set_setting(unused_addr, source_name, setting, value):
	c2(f'source_set_setting(source_name="{source_name}", setting="{setting}", value="{value}")')
	with ExitStack() as stack:
		source = stack.enter_context(source_auto_release(source_name))
		if source:
			newSettings = stack.enter_context(new_settings())
			if   type(value) == bool:  obs.obs_data_set_bool(newSettings, setting, value)
			elif type(value) == str and (value == 'true' or value == 'True'):
				obs.obs_data_set_bool(newSettings, setting, True)
			elif type(value) == str and (value == 'false' or value == 'False'):
				obs.obs_data_set_bool(newSettings, setting, False)
			elif type(value) == str:   obs.obs_data_set_string(newSettings, setting, value)
			elif type(value) == int:   obs.obs_data_set_int(newSettings, setting, value)
			elif type(value) == float: obs.obs_data_set_double(newSettings, setting, value)
			obs.obs_source_update(source, newSettings)
		else: print(f'Source no existe: {source_name}')

def source_set_video_file(unused_addr, source_name, video_file):
	c2(f'source_set_video_file(source_name="{source_name}", video_file="{video_file}")')
	source_set_setting(None, source_name=source_name, setting='local_file', value=video_file)

def source_set_slide_time(unused_addr, source_name, slide_time):
	c2(f'source_set_slide_time(source_name="{source_name}", slide_time={slide_time})')
	source_set_setting(None, source_name=source_name, setting='slide_time', value=slide_time)

def source_set_text(unused_addr, source_name, text_string):
	c2(f'source_set_text(source_name="{source_name}", text_string="{text_string}")')
	source_set_setting(None, source_name=source_name, setting='text', value=text_string)

def source_set_text_size(unused_addr, source_name, size):
	c2(f'source_set_text_size(source_name="{source_name}", size="{size}")')
	source_set_setting(None, source_name=source_name, setting='size', value=size)

def source_get_settings(unused_addr, source_name, print_=False):
	c2(f'source_get_settings(source_name="{source_name}")')
	source = obs.obs_get_source_by_name(source_name)
	sourceSettings = obs.obs_source_get_settings(source)

	with ExitStack() as stack:
		newSettings = stack.enter_context(new_settings())
		# newSettings = obs.obs_data_create()
		
		obs.obs_data_set_string(newSettings, "sourceName", obs.obs_source_get_name(source))
		obs.obs_data_set_string(newSettings, "sourceId", obs.obs_source_get_id(source))
		obs.obs_data_set_double(newSettings, "sourceType", obs.obs_source_get_type(source))
		obs.obs_data_set_obj(newSettings, "sourceSettings", sourceSettings)
		obs.obs_source_release(source)
		retorno = obs.obs_data_get_json(newSettings)
		
		if bool(print_):
			consola(retorno)
		return retorno

# Asigna un filtro a un source.
def source_assign_filter(unused_addr, source_name, filter_type='color_filter', filter_name="Color Correction"):
	c4(f'source_assign_filter(source_name="{source_name}", filter_type="{filter_type}", filter_name="{filter_name}")')

	with ExitStack() as stack:
		source = stack.enter_context(source_auto_release(source_name))
		if source:
			# Aplica filtro color_source para opacidad
			newSettings = stack.enter_context(new_settings())
			# filter_settings = obs.obs_data_create()
			source_color = obs.obs_source_create_private(filter_type, filter_name, newSettings)
			obs.obs_source_filter_add(source, source_color)
			# obs.obs_data_release(newSettings)
			# obs.obs_source_release(source_color)
		else:
			print(f'source_assign_filter() Source no existe: "{source_name}"')

# ITEMS
# ITEMS
# ITEMS
def item_get_props(unused_addr, scene_name, item_name):
	c2(f'item_get_props(scene_name="{scene_name}", item_name="{item_name}")')
	scene_item = obs.obs_scene_find_source(get_scene_context(scene_name), item_name)
	source = obs.obs_sceneitem_get_source(scene_item)
	
	itemInfo = obs.obs_transform_info()
	obs.obs_sceneitem_get_info(scene_item, itemInfo)

	with ExitStack() as stack:
		newSettings = stack.enter_context(new_settings())
		# newSettings = obs.obs_data_create()
		obs.obs_data_set_int(newSettings, "itemId", obs.obs_sceneitem_get_id(scene_item))
		obs.obs_data_set_string(newSettings, "sourceName", obs.obs_source_get_name(source))
		# TODO
		# obs.obs_data_set_array(newSettings, "itemInfo", obs.obs_data_get_json(itemInfo))

		return obs.obs_data_get_json(newSettings)

def item_get_transform(unused_addr, scene_name, item_name, print_=False):
	c2(f'item_get_transform(scene_name="{scene_name}", item_name="{item_name}")')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)
			
		if scene_item:
			source = obs.obs_sceneitem_get_source(scene_item)
			itemInfo = obs.obs_transform_info()
			crop = obs.obs_sceneitem_crop()
			obs.obs_sceneitem_get_info(scene_item, itemInfo)
			obs.obs_sceneitem_get_crop(scene_item, crop)
			todaladata = {
				'bounds': {'alignment': itemInfo.bounds_alignment, 'type': itemInfo.bounds_type,
				'x': itemInfo.bounds.x, 'y': itemInfo.bounds.y},
				# 'width': obs.obs_source_get_height(source) * itemInfo.scale.x,
				# 'height': obs.obs_source_get_width(source) * itemInfo.scale.y,
				'width':  (obs.obs_source_get_width(source)  - crop.left - crop.right)  * itemInfo.scale.x,
				'height': (obs.obs_source_get_height(source) - crop.top -  crop.bottom) * itemInfo.scale.y,
				'crop': {'bottom': crop.bottom, 'left': crop.left, 'right': crop.right, 'top': crop.top},
				'itemId': obs.obs_sceneitem_get_id(scene_item), 'locked': obs.obs_sceneitem_locked(scene_item), 'name': item_name,
				'position': {'alignment': itemInfo.alignment, 'x': itemInfo.pos.x, 'y': itemInfo.pos.y},
				'rotation': itemInfo.rot, 'scale': {'x': itemInfo.scale.x, 'y': itemInfo.scale.x},
				'sourceHeight': obs.obs_source_get_height(source), 'sourceWidth': obs.obs_source_get_width(source),
				'visible': obs.obs_sceneitem_visible(scene_item)}
	
			if bool(print_):
				consola(todaladata)
	
			return todaladata
		else:
			print(f'item_get_transform() Item no existe: "{item_name}"')
			return None


def item_set_pos(unused_addr, scene_name, item_name, pos_x=None, pos_y=None):
	c4(f'item_set_pos(scene_name="{scene_name}", item_name="{item_name}", {pos_x}, {pos_y})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_pos() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			new_pos = obs.vec2()
			if pos_x not in [None, 'none', 'None']: new_pos.x = pos_x
			if pos_y not in [None, 'none', 'None']: new_pos.y = pos_y
			obs.obs_sceneitem_set_pos(scene_item, new_pos)
			
		else:
			print(f'item_set_pos() Item no existe: "{item_name}"')

def item_set_scl(unused_addr, scene_name, item_name, scl_x=None, scl_y=None):
	c4(f'item_set_scl(scene_name="{scene_name}", item_name="{item_name}", scl_x={scl_x}, scl_y={scl_y})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_scl() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			new_scale = obs.vec2()
			
			if scl_x not in [None, 'none', 'None']: new_scale.x = scl_x
			if scl_y not in [None, 'none', 'None']: new_scale.y = scl_y
			obs.obs_sceneitem_set_scale(scene_item, new_scale)
		else:
			print(f'item_set_scl() Item no existe: "{item_name}"')

def item_set_scl_filter(unused_addr, scene_name, item_name, scl_filter):
	c4(f'item_set_scl_filter(scene_name="{scene_name}", item_name="{item_name}", scl_filter={scl_filter})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_scl() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:  obs.obs_sceneitem_set_scale_filter(scene_item, int(scl_filter))
		else:           print(f'item_set_scl() Item no existe: "{item_name}"')
		# OBS_SCALE_DISABLE  # OBS_SCALE_POINT     # OBS_SCALE_BICUBIC
		# OBS_SCALE_BILINEAR # OBS_SCALE_LANCZOS

def item_set_rot(unused_addr, scene_name, item_name, rot=None):
	c4(f'item_set_rot(scene_name="{scene_name}", item_name="{item_name}", rot={rot})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_rot() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			obs.obs_sceneitem_set_rot(scene_item, rot)
		else:
			print(f'item_set_rot() Item no existe: "{item_name}"')

def item_set_alignment(unused_addr, scene_name, item_name, alignment):
	c4(f'item_set_alignment(scene_name="{scene_name}", item_name="{item_name}", {alignment})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_alignment() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			obs.obs_sceneitem_set_alignment(scene_item, alignment)
		else:
			print(f'item_set_alignment() Item no existe: "{item_name}"')

def item_set_visible(unused_addr, scene_name, item_name, visible):
	c4(f'item_set_visible(scene_name="{scene_name}", item_name="{item_name}", {bool(visible)})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_visible() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			obs.obs_sceneitem_set_visible(scene_item, bool(visible))
		else:
			print(f'item_set_visible() Item no existe: "{item_name}"')

def item_set_transform(unused_addr, 
	scene_name, 
	item_name, 
	pos_x=None, pos_y=None,
	scl_x=None, scl_y=None, 
	width=None, height=None, 
	rot=None, 
	alignment=None, 
	visible=None):
	c4(f'item_set_transform(scene_name="{scene_name}", item_name="{item_name}", pos_x={pos_x}, pos_y={pos_y},')
	c4(f'	scl_x={scl_x}, scl_y={scl_y}, rot={rot}, alignment={alignment}, visible={bool(visible)})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_transform() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			info = obs.obs_transform_info()
			obs.obs_sceneitem_get_info(scene_item, info)
			if pos_x     not in [None, 'none', 'None']: info.pos.x     = pos_x
			if pos_y     not in [None, 'none', 'None']: info.pos.y     = pos_y
			if scl_x     not in [None, 'none', 'None']: info.scale.x   = scl_x
			if scl_y     not in [None, 'none', 'None']: info.scale.y   = scl_y
			if rot       not in [None, 'none', 'None']: info.rot       = rot
			if alignment not in [None, 'none', 'None']: info.alignment = alignment

			# Para usar Width y Height. Sobrescribe info.scale.x/y
			if width not in [None, 'none', 'None'] or height not in [None, 'none', 'None']:
				crop = obs.obs_sceneitem_crop()
				obs.obs_sceneitem_get_crop(scene_item, crop)
				source = obs.obs_sceneitem_get_source(scene_item)
	
				if width  not in [None, 'none', 'None']:
					info.scale.x = width  / obs.obs_source_get_width(source)  - crop.left - crop.right
				if height not in [None, 'none', 'None']:
					info.scale.y = height / obs.obs_source_get_height(source) - crop.top  - crop.bottom

			obs.obs_sceneitem_set_info(scene_item, info)
		
			if visible != None:
				obs.obs_sceneitem_set_visible(scene_item, bool(visible))
		else:
			print(f'item_set_transform() Item no existe: "{item_name}"')

def item_remove(unused_addr, scene_name, item_name):
	c3(f'item_remove(scene_name="{scene_name}", item_name="{item_name}")')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_remove() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			obs.obs_sceneitem_remove(scene_item)
			c3(f'ITEM REMOVED item_remove(scene_name="{scene_name}", item_name="{item_name}")')
		else:
			print(f'item_remove() Item no existe: "{item_name}"')

def item_set_private_setting(unused_addr, scene_name, item_name, setting, value):
	c4(f'item_set_private_setting(scene_name="{scene_name}", item_name="{item_name}", setting="{setting}", value={value})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_remove() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			data = obs.obs_sceneitem_get_private_settings(scene_item)
			# obs.obs_data_release(data)
			if   type(value) == bool:  obs.obs_data_set_bool(data, setting, value)
			elif type(value) == str:   obs.obs_data_set_string(data, setting, value)
			elif type(value) == int:   obs.obs_data_set_int(data, setting, value)
			elif type(value) == float: obs.obs_data_set_double(data, setting, value)
		else:
			print(f'item_set_private_setting() Item no existe: "{item_name}"')


def item_set_crop(unused_addr, 
	scene_name, 
	item_name, 
	left=None, 
	right=None, 
	top=None, 
	bottom=None):
	
	c3(f'item_set_crop(scene_name="{scene_name}", item_name="{item_name}",')
	c3(f'	left={left}, right={right}, top={top}, bottom={bottom})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_crop() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)
		
		if scene_item:
			crop = obs.obs_sceneitem_crop()
			obs.obs_sceneitem_get_crop(scene_item, crop)
			if left != None:   crop.left   = int(left)
			if right != None:  crop.right  = int(right)
			if top != None:    crop.top    = int(top)
			if bottom != None: crop.bottom = int(bottom)
			obs.obs_sceneitem_set_crop(scene_item, crop)
		else:
			print(f'item_set_crop() Item no existe: "{item_name}"')

# Cropea un item dentro de un grupo en una escena
def item_set_crop2(unused_addr, 
	scene_name, 
	group_name, 
	item_name, 
	left=None, 
	right=None, 
	top=None, 
	bottom=None):
	
	c3(f'item_set_crop2(scene_name="{scene_name}", group_name="{group_name}", item_name="{item_name}",')
	c3(f'	left={left}, right={right}, top={top}, bottom={bottom})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_crop2() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if group_name.startswith('id='): group_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else:                            group_item = obs.obs_scene_find_source(scene, group_name)
		group_scene = obs.obs_sceneitem_group_get_scene(group_item)
		if item_name.startswith('id='):  scene_item = obs.obs_scene_find_sceneitem_by_id(group_scene, int(item_name[3:]))
		else:                            scene_item = obs.obs_scene_find_source(group_scene, item_name)
		
		if scene_item:
			crop = obs.obs_sceneitem_crop()
			obs.obs_sceneitem_get_crop(scene_item, crop)
			if left != None:   crop.left   = int(left)
			if right != None:  crop.right  = int(right)
			if top != None:    crop.top    = int(top)
			if bottom != None: crop.bottom = int(bottom)
			obs.obs_sceneitem_set_crop(scene_item, crop)
		else:
			print(f'item_set_crop2() Item no existe: "{item_name}"')
	
def sprite_covid(unused_addr, scene_name, item_name, pos_x):
	c4(f'sprite_covid({scene_name}, {item_name}, {pos_x})')
	d = [256,256]
	q = [16, 1]
	left =   pos_x * d[0]
	right = (q[0] - 1 - pos_x) * d[0]
	item_set_crop(None, scene_name, item_name, left, right, None, None)

# Cambia de sprite de un item
def item_set_sprite(unused_addr, scene_name='', item_name='', img_size=[], grid=[], pos=[]):
	c4(f'sprite_(scene_name="{scene_name}", item_name="{item_name}", img_size={img_size}, grid={grid}, pos={pos})')
	sprite_size = [img_size[0] / grid[0], img_size[1] / grid[1]]
	
	left   = pos[0] * sprite_size[0]
	top    = pos[1] * sprite_size[1]
	right  = (grid[0] - 1 - pos[0]) * sprite_size[0]
	bottom = (grid[1] - 1 - pos[1]) * sprite_size[1]
	item_set_crop(None, scene_name, item_name, left, right, top, bottom)

# Cambia de sprite de un item dentro de un grupo (en una escena)
def item_set_sprite2(unused_addr, scene_name='', group_name='', item_name='', img_size=[], grid=[], pos=[]):
	c4(f'sprite_(scene_name="{scene_name}", item_name="{item_name}", img_size={img_size}, grid={grid}, pos={pos})')
	sprite_size = [img_size[0] / grid[0], img_size[1] / grid[1]]
	
	left   = pos[0] * sprite_size[0]
	top    = pos[1] * sprite_size[1]
	right  = (grid[0] - 1 - pos[0]) * sprite_size[0]
	bottom = (grid[1] - 1 - pos[1]) * sprite_size[1]
	item_set_crop2(None, scene_name, group_name, item_name, left, right, top, bottom)

def item_reference(unused_addr, 
	fromScene_name, 
	toScene_name, 
	item_name, 
	new_item_name):
	
	item_duplicate(None, 
		fromScene_name=fromScene_name, 
		toScene_name=toScene_name,
		item_name=item_name, 
		new_item_name=new_item_name, 
		reference=True)

def item_duplicate(unused_addr, 
	fromScene_name, 
	toScene_name,
	item_name, 
	new_item_name=None, 
	copy_info_crop=True, 
	visible=None, 
	reference=False):
	
	c3(f'item_duplicate(fromScene_name="{fromScene_name}", toScene_name="{toScene_name}",')
	c3(f'	item_name="{item_name}", new_item_name="{new_item_name}",')
	c3(f'	copy_info_crop={copy_info_crop}, visible={visible})')

	fromScene, scenes_list1 = get_scene_context(fromScene_name)
	if not fromScene:
		obs.source_list_release(scenes_list1)
		print(f'item_duplicate() fromScene no existe: {fromScene_name}')
		return
	
	toScene, scenes_list2 = get_scene_context(toScene_name)
	if not toScene:
		obs.source_list_release(scenes_list2)
		print(f'item_duplicate() toScene no existe: {toScene_name}')
		return

	with source_list_auto_release(scenes_list1):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(fromScene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(fromScene, item_name)
	
		if scene_item:

			if copy_info_crop:
				info = obs.obs_transform_info()
				crop = obs.obs_sceneitem_crop()
				obs.obs_sceneitem_get_info(scene_item, info)
				obs.obs_sceneitem_get_crop(scene_item, crop)

			# Lo elije como source
			source = obs.obs_sceneitem_get_source(scene_item)

			if reference:
				# Crea item tomando como referencia el source
				new_item = obs.obs_scene_add(toScene, source)
			else:
				# Duplica
				duplicated = obs.obs_source_duplicate(source, new_item_name, False)
				# Crea item con 
				new_item = obs.obs_scene_add(toScene, duplicated)
				obs.obs_source_release(duplicated)

			if copy_info_crop:
				obs.obs_sceneitem_set_info(new_item, info)
				obs.obs_sceneitem_set_crop(new_item, crop)

			if visible != None:
				obs.obs_sceneitem_set_visible(new_item, bool(visible))

			obs.obs_scene_release(fromScene)
			obs.obs_scene_release(toScene)

			item_id = obs.obs_sceneitem_get_id(new_item)
			return item_id
		else:
			print(f'item_duplicate() Item no existe: "{item_name}"')

def item_create_group(unused_addr, scene_name, group_name, items=[], visible=True):
	c2(f'item_create_group(scene_name="{scene_name}", group_name="{group_name}", items="{items}", visible={visible})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_create_group() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		# new_group = obs.obs_scene_add_group(scene, group_name)
		scene_items = []
	
		# new_group = obs.obs_scene_insert_group(scene, group_name, scene_items, len(scene_items))
		new_group = obs.obs_scene_insert_group(scene, group_name, None, 0)

		for item_name in items:
			if item_name.startswith('id='): 
				scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
				obs.obs_sceneitem_group_add_item(new_group, scene_item)
			else:
				scene_item = obs.obs_scene_find_source(scene, item_name)
				obs.obs_sceneitem_group_add_item(new_group, scene_item)

		group_id = obs.obs_sceneitem_get_id(new_group)
		return group_id

def item_create_image(unused_addr, scene_name, item_name, image_file, visible=True):
	c2(f'item_create_image(scene_name="{scene_name}", item_name="{item_name}", image_file="{image_file}", visible={visible})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_create_image() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		settings = obs.obs_data_create()
		obs.obs_data_set_string(settings, "file", image_file)

		source = obs.obs_source_create("image_source", item_name, settings, None)
		new_item = obs.obs_scene_add(scene, source)

		if visible != None:
			obs.obs_sceneitem_set_visible(new_item, bool(visible))

		# obs.obs_scene_release(scene)
		obs.obs_data_release(settings)
		obs.obs_source_release(source)
		
		item_id = obs.obs_sceneitem_get_id(new_item)
		return item_id

def item_create_text(unused_addr, 
	scene_name, 
	item_name, 
	text='', 
	face='Sans Serif', 
	size=28, 
	color1=None, 
	color2=None,
	outline=None,
	drop_shadow=None,
	visible=True):
	
	c2(f'item_create_text(scene_name="{scene_name}", item_name="{item_name}", text="{text}", size="{size}", visible={visible})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_create_text() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		settings = obs.obs_data_create()
		obs.obs_data_set_string(settings, 'text', text)
		
		if color1 != None: 	    obs.obs_data_set_int(settings,  'color1', rgb2decimal(color1))
		if color2 != None:	    obs.obs_data_set_int(settings,  'color2', rgb2decimal(color2))
		if drop_shadow != None:	obs.obs_data_set_bool(settings, 'drop_shadow', bool(drop_shadow))
		if outline != None:     obs.obs_data_set_bool(settings, 'outline',     bool(outline))

		# font_array = obs.obs_data_array_create()
		item = obs.obs_data_create()
		obs.obs_data_set_string(item, "face", face)
		obs.obs_data_set_int   (item, "flags", 0)
		obs.obs_data_set_double(item, "size", size)
		obs.obs_data_set_string(item, "style", '')
		
		# obs.obs_data_array_push_back(font_array, item)

		obs.obs_data_set_obj(settings, 'font', item)

		source = obs.obs_source_create("text_ft2_source", item_name, settings, None)
		new_item = obs.obs_scene_add(scene, source)

		if visible != None:
			obs.obs_sceneitem_set_visible(new_item, bool(visible))

		# obs.obs_scene_release(scene)
		obs.obs_data_release(settings)
		obs.obs_source_release(source)
		
		item_id = obs.obs_sceneitem_get_id(new_item)
		return item_id

def item_create_debug_box(unused_addr, 
	scene_name, item_name, 
	pos_x=0, pos_y=0, 
	width=100, height=100, 
	rgb=[1,1,1], opacity=50):
	
	c2(f'item_create_debug_box(scene_name="{scene_name}", item_name="{item_name}", rgb={rgb}, opacity={opacity})')

	color_decimal = rgb2decimal(rgb)

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_create_debug_box() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		settings = obs.obs_data_create()
		obs.obs_data_set_int(settings, "color", color_decimal)
		obs.obs_data_set_int(settings, "width", int(width))
		obs.obs_data_set_int(settings, "height", int(height))

		source = obs.obs_source_create_private("color_source", item_name, settings)
		new_item = obs.obs_scene_add(scene, source)

		# Aplica filtro color_source para opacidad
		filter_settings = obs.obs_data_create()
		obs.obs_data_set_int(filter_settings, "opacity", int(opacity))
		source_color = obs.obs_source_create_private("color_filter", "transparency", filter_settings)
		obs.obs_source_filter_add(source, source_color)

		obs.obs_data_release(filter_settings)
		obs.obs_source_release(source_color)

		scene_item = obs.obs_scene_find_source(scene, item_name)
		new_pos = obs.vec2()
		new_pos.x, new_pos.y = pos_x, pos_y
		obs.obs_sceneitem_set_pos(scene_item, new_pos)
			
		obs.obs_data_release(settings)
		obs.obs_source_release(source)
		
		item_id = obs.obs_sceneitem_get_id(new_item)
		return item_id

def item_dupli_set_prop(unused_addr, 
	fromScene_name, 
	toScene_name, 
	item_name, 
	new_item_name=None, 
	reference=False,
	pos_x=None, pos_y=None, 
	scl_x=None, scl_y=None, 
	rot=None, alignment=None, visible=None):

	item_id = item_duplicate(None, 
		fromScene_name=fromScene_name, 
		toScene_name=toScene_name,
		item_name=item_name, 
		new_item_name=new_item_name, 
		visible=False, 
		reference=reference)
	
	item_set_transform(None, 
		scene_name=toScene_name, 
		item_name=new_item_name,
		pos_x=pos_x, pos_y=pos_y, 
		scl_x=scl_x, scl_y=scl_y,
		rot=rot, alignment=alignment, 
		visible=visible)
	
	return item_id	

def item_create_image_set_prop(unused_addr, 
	scene_name, 
	item_name, 
	image_file, 
	pos_x=None, pos_y=None, 
	scl_x=None, scl_y=None, 
	rot=None, alignment=None, visible=None):

	item_id = item_create_image(None, scene_name=scene_name,
		item_name=item_name, 
		image_file=image_file,
		visible=False)
	
	item_set_transform(None, scene_name=scene_name, 
		item_name={'id': item_id},
		pos_x=pos_x, pos_y=pos_y, 
		scl_x=scl_x, scl_y=scl_y,
		rot=rot, alignment=alignment, visible=visible)
	
	return item_id	

# devuelve una lista con dicts con 'index', 'name', 'scene_item'(Swig Object) e 'id' c/u
def get_order(scene_items=None):
	order = list()
	for i, s in enumerate(scene_items):
		source  = obs.obs_sceneitem_get_source(s)
		name    = obs.obs_source_get_name(source)
		item_id = obs.obs_sceneitem_get_id(s)
		order.append({"index": i, "name": name, "scene_item": s, 'id': item_id})
	return order

def item_swap_order_index(unused_addr,scene_name, item_name1, item_name2):
	c2(f'item_swap_order_index(scene_name={scene_name}, item_name1={item_name1}, item_name2={item_name2})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_swap_order_index() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		with scene_enum(scene) as scene_items:

			# order es una lista con {"index": i, "name": name, "scene_item": s, 'id': item_id}
			order = get_order(scene_items)
			for dic in order:
				if   (item_name1.startswith('id=') and int(item_name1[3:]) == dic['id']) or item_name1 == dic['name']:
					item_pos1 = dic['index']
				elif (item_name2.startswith('id=') and int(item_name2[3:]) == dic['id']) or item_name2 == dic['name']:
					item_pos2 = dic['index']
			
			if 'item_pos1' not in locals() or 'item_pos2' not in locals():
				consola(f'No existe {item_name1} o {item_name2}.')
				return
			
			# consola(order, c.debug)
			# for i in sorted(order, key=lambda item: item['index'], reverse=True):
			# 	consola(f"{i['index']}: {i['name']}", c.violeta)
			
			# print([item_pos1, order[item_pos1]["name"]])
			# print([item_pos2, order[item_pos2]["name"]])
			
			obs.obs_sceneitem_set_order_position(order[item_pos1]["scene_item"], item_pos2)
			obs.obs_sceneitem_set_order_position(order[item_pos2]["scene_item"], item_pos1)

			
			# order[item_pos1]["index"], order[item_pos2]["index"] = order[item_pos2]["index"], order[item_pos1]["index"]
			# for s in sorted(order, key=lambda i: i["index"]):
			# 	obs.obs_sceneitem_set_order_position(s["scene_item"], s["index"])

# Devuelve el orden de items en la escena.
def items_get_order(unused_addr, scene_name):
	c2(f'items_get_order(scene_name={scene_name})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_get_order_index() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		with scene_enum(scene) as scene_items:
			order = get_order(scene_items)
			return order

# Devuelve la posición de orden en la lista de items en la escena.
def item_get_order_index(unused_addr, scene_name, item_name):
	c2(f'item_get_order_index(scene_name={scene_name}, item_name={item_name})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_get_order_index() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		with scene_enum(scene) as scene_items:
			order = get_order(scene_items)
			for i, dic in enumerate(order):

				if type(item_name) == str or (type(item_name) == dict and 'id' in item_name):
					if dic['name'] == item_name:
						return i
				elif type(item_name) == dict and 'id' in item_name:
					if dic['id'] == item_name['id']:
						return i
			
			print(f'item_get_order_index() Item no existe: "{item_name}"')

# Mueve de lugar. 0 y positivos de abajo hacia arriba. Negativos, de arriba hacia abajo.
def item_set_order_index(unused_addr, scene_name, item_name, index=None):
	c2(f'item_set_order_index(scene_name="{scene_name}", item_name="{item_name}")')
		
	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		print(f'item_set_order_index() Scene no existe: "{scene_name}"')
		return

	with source_list_auto_release(scenes_list):
		if item_name.startswith('id='): scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
		else: scene_item = obs.obs_scene_find_source(scene, item_name)

		if scene_item:
			if index >= 0:
				obs.obs_sceneitem_set_order_position(scene_item, int(index))
			elif index < 0:
				with scene_enum(scene) as scene_items:
					order = len(get_order(scene_items))
					obs.obs_sceneitem_set_order_position(scene_item, int(order + 1 + index))
		else:
			print(f'item_set_order_index() Item no existe: "{item_name}"')

zoom_window = ''
def source_capture_window(unused_addr, source_name, que, restore_name=None):
	global zoom_window

	source = obs.obs_get_source_by_name(source_name)
	source_name = obs.obs_source_get_name(source)
	consola(f'source_name: {source_name}', c.debug)

	if source:

		if que == 'backup':

			oldSettings = obs.obs_source_get_settings(source)
			zoom_window = obs.obs_data_get_string(oldSettings, 'capture_window')
			print(zoom_window)
			# client.send_message("/source_capture_window", zoom_window)
			obs.obs_data_release(oldSettings)

		elif que == 'restore':
			with ExitStack() as stack:
				newSettings = stack.enter_context(new_settings())
				# newSettings = obs.obs_data_create()
				obs.obs_data_set_string(newSettings, "capture_window", restore_name)
				obs.obs_source_update(source, newSettings)
				# obs.obs_data_release(newSettings)

		else:
			print('Solo recibe backup o restore.')
		
		obs.obs_source_release(source)

# TODO
def monitorFix():
	pass
# 	lista = ws.call(requests.GetSourcesList())
# 	for i in lista.getSources():
# 		o = i['name']
# 		actual = ws.call(requests.GetAudioMonitorType(o)).getMonitorType()
# 		print(o, actual)
# 		if actual == 'monitorAndOutput':
# 			ws.call(requests.SetAudioMonitorType(o, 'none'))
# 			ws.call(requests.SetAudioMonitorType(o, 'monitorAndOutput'))

def item_tween(unused_addr,
	scene_name,            item_name,
	from_pos_y=None,       to_pos_x=None,
	from_pos_x=None,       to_pos_y=None,
	from_scl_x=None,       to_scl_x=None,
	from_scl_y=None,       to_scl_y=None,
	from_rot=None,         to_rot=None,
	alignment=None,        visible=True,
	duration=1000,         delay=0,
	ease_type='outQuad',   fps=30,
	extra=None,            eval_=None): 

	c2(f'item_tween(scene_name="{scene_name}", item_name="{item_name}",')
	c2(f'	duration={duration}, delay={delay}, ease_type={ease_type},')
	c2(f'	from_pos_x={from_pos_x}, from_pos_y={from_pos_y},')
	c2(f'	from_scl_x={from_scl_x}, from_scl_y={from_scl_y},')
	c2(f'	from_rot={from_rot}, to_pos_x={to_pos_x}, to_pos_y={to_pos_y},')
	c2(f'	to_scl_x={to_scl_x}, to_scl_y={to_scl_y}, to_scl_rot={to_rot},')
	c2(f'	alignment={alignment}, visible={visible}, fps={fps}, extra={extra}),')
	c2(f'	eval_={eval_})')

	scene, scenes_list = get_scene_context(scene_name)
	if not scene:
		obs.source_list_release(scenes_list)
		return

	with source_list_auto_release(scenes_list):
		
		if item_name.startswith('id='):
			scene_item = obs.obs_scene_find_sceneitem_by_id(scene, int(item_name[3:]))
			if scene_item: item_id = int(item_name[3:])
		else:
			scene_item = obs.obs_scene_find_source(scene, item_name)
			if scene_item: item_id = obs.obs_sceneitem_get_id(scene_item)


		if scene_item:
			item_info = obs.obs_transform_info()
			obs.obs_sceneitem_get_info(scene_item, item_info)

			if from_pos_x == None: from_pos_x = item_info.pos.x 
			if from_pos_y == None: from_pos_y = item_info.pos.y 
			if from_scl_x == None: from_scl_x = item_info.scale.x
			if from_scl_y == None: from_scl_y = item_info.scale.y
			if from_rot   == None: from_rot   = item_info.rot

			# Código único para que se ejecute un tween a la vez
			code = ''.join(random.choice(string.ascii_letters) for i in range(10))

			# Momento en que comienza el tween.
			init_time = time.time()*1000
			
			# Crea elemento en diccionario. Queda forever.
			globalDict.tween_sceneitems[item_id] = {
				'scene_name': scene_name,
				'item_name':  item_name,
				'code':       code,
				'init_time':  init_time,
				'pos_x':      from_pos_x,
				'pos_y':      from_pos_y,
				'scl_x':      from_scl_x,
				'scl_y':      from_scl_y,
				'rot':        from_rot,
				'alignment':  alignment,
				'visible':    visible,
				'extra':      extra,
				'eval_':      eval_,
			}

			# Función en Thread
			th(th_tween, [scene_name, item_name, scene_item, item_info, item_id, code,
				init_time, duration, delay, ease_type,
				from_pos_x, from_pos_y, from_scl_x, from_scl_y, from_rot,
				to_pos_x, to_pos_y, to_scl_x, to_scl_y, to_rot,
				alignment, visible, fps, extra, eval_])
		else:
			print(f'item_tween() Item no existe: "{item_name}"')


def th_tween(scene_name, item_name, scene_item, item_info, item_id, code,
	init_time, duration, delay, ease_type,
	from_pos_x, from_pos_y, from_scl_x, from_scl_y, from_rot,
	to_pos_x, to_pos_y, to_scl_x, to_scl_y, to_rot,
	alignment, visible, fps, extra, eval_):
		# Delay
		if delay > 0:
			time.sleep(delay/1000)
			init_time += delay

		# Lo hace visible al comienzo o no
		obs.obs_sceneitem_set_visible(scene_item, bool(visible))
		
		# Loop
		while init_time + duration > time.time()*1000:

			# Si no está en la lista de tweens, muere tween.
			if item_id not in globalDict.tween_sceneitems:
				return
			
			# Si el código no es el mismo que el registrado, muere tween.
			if code != globalDict.tween_sceneitems[item_id]['code']:
				return
			
			elapsed_time = time.time()*1000 - init_time
			pos_change_x = None if to_pos_x == None else to_pos_x - from_pos_x
			pos_change_y = None if to_pos_y == None else to_pos_y - from_pos_y
			scl_change_x = None if to_scl_x == None else to_scl_x - from_scl_x
			scl_change_y = None if to_scl_y == None else to_scl_y - from_scl_y
			rot_change   = None if to_rot   == None else to_rot   - from_rot
			
			# time, beginning position, change inposition, and duration
			pos_x = None if to_pos_x == None else tween_eq(ease_type, elapsed_time, from_pos_x, pos_change_x, duration)
			pos_y = None if to_pos_y == None else tween_eq(ease_type, elapsed_time, from_pos_y, pos_change_y, duration)
			scl_x = None if to_scl_x == None else tween_eq(ease_type, elapsed_time, from_scl_x, scl_change_x, duration)
			scl_y = None if to_scl_y == None else tween_eq(ease_type, elapsed_time, from_scl_y, scl_change_y, duration)
			rot   = None if to_rot   == None else tween_eq(ease_type, elapsed_time, from_rot  , rot_change  , duration)

			c4(f'item_set_transform(scene_name="{scene_name}", item_name="{item_name}",')
			c4(f'	pos_x={pos_x}, pos_y={pos_y}, scl_x={scl_x}, scl_y={scl_y},')
			c4(f'	rot={rot}, alignment={alignment}, visible={visible})')

			# Si hay modificaciones, las hace y guarda info del objeto
			if pos_x     != None:
				item_info.pos.x                               = int(pos_x)
				globalDict.tween_sceneitems[item_id]['pos_x'] = int(pos_x)
			if pos_y     != None:
				item_info.pos.y                               = int(pos_y)
				globalDict.tween_sceneitems[item_id]['pos_y'] = int(pos_y)
			if scl_x     != None:
				item_info.scale.x                             = scl_x
				globalDict.tween_sceneitems[item_id]['scl_x'] = scl_x
			if scl_y     != None:
				item_info.scale.y                             = scl_y
				globalDict.tween_sceneitems[item_id]['scl_y'] = scl_y
			if rot       != None:
				item_info.rot                                 = rot
				globalDict.tween_sceneitems[item_id]['rot']   = rot
			if alignment != None:
				item_info.alignment                               = alignment
				globalDict.tween_sceneitems[item_id]['alignment'] = alignment
			obs.obs_sceneitem_set_info(scene_item, item_info)


			if eval_ != None:
				eval(eval_)

			time_sleep = 1 / fps
			time.sleep(time_sleep)
		
		# Check error
		if 'pos_x' not in locals():
			pass
			# consola('pos_x not in locals()')
			# print(scene_name, item_name, scene_item, item_info, item_id, code,
			# 	init_time, duration, delay, ease_type,
			# 	from_pos_x, from_pos_y, from_scl_x, from_scl_y, from_rot,
			# 	to_pos_x, to_pos_y, to_scl_x, to_scl_y, to_rot,
			# 	alignment, visible, fps, extra, eval_)

		# Si hay modificaciones, las hace y guarda info del objeto
		if 'pos_x' in locals() and pos_x != None:
			item_info.pos.x                               = int(pos_x)
			globalDict.tween_sceneitems[item_id]['pos_x'] = int(pos_x)
		if 'pos_y' in locals() and pos_y != None:
			item_info.pos.y                               = int(pos_y)
			globalDict.tween_sceneitems[item_id]['pos_y'] = int(pos_y)
		if 'scl_x' in locals() and scl_x != None:
			item_info.scale.x                             = scl_x
			globalDict.tween_sceneitems[item_id]['scl_x'] = scl_x
		if 'scl_y' in locals() and scl_y != None:
			item_info.scale.y                             = scl_y
			globalDict.tween_sceneitems[item_id]['scl_y'] = scl_y
		if 'rot'   in locals() and rot   != None:
			item_info.rot                                 = rot
			globalDict.tween_sceneitems[item_id]['rot']   = rot
		if 'alignment' in locals() and alignment != None:
			item_info.alignment                               = alignment
			globalDict.tween_sceneitems[item_id]['alignment'] = alignment
		obs.obs_sceneitem_set_info(scene_item, item_info)

		# Ningunea elementos propios del tween que termina
		globalDict.tween_sceneitems[item_id]['init_time'] = None
		globalDict.tween_sceneitems[item_id]['code']      = None
		# globalDict.tween_sceneitems[item_id]['extra']     = None
		globalDict.tween_sceneitems[item_id]['eval_']     = None
		
		# Para ejecutar algo al final
		# NOT COMPLETED
		if eval_ != None:
			eval(eval_)

		c3(f'Terminó tween "{scene_name}" "{item_name}"')

# TWEEN - Ecuaciones
def tween_eq(ease_type, t, b, c, d):
	#~ if t >= 0:
	if ease_type == 'linear':
		return c * t / d + b
	elif ease_type == 'inQuad':
		t /= d
		return c * t * t + b
	elif ease_type == 'outQuad':
		t /= d
		return - c * t * (t - 2) + b
	elif ease_type == 'inOutQuad':
		t /= d / 2
		if (t < 1):
			return c / 2 * t * t + b
		t -= 1
		return -c / 2 * ((t) * (t - 2) - 1) + b
	elif ease_type == 'inCubic':
		t /= d
		return c * t * t * t + b
	elif ease_type == 'outCubic':
		t /= d
		t -= 1
		return c * (t * t * t + 1) + b
	elif ease_type == 'inOutCubic':
		t /= d / 2
		if (t < 1):
			return c / 2 * t * t * t + b
		t -= 2
		return c / 2 * (t * t * t + 2) + b


def pre_cuanto_falta(momento):
	t1 = datetime.datetime.now().replace(hour=int(momento.split(':')[0]), minute=int(momento.split(':')[1]), second=0, microsecond=0)
	t2 = datetime.datetime.now()
	_time = str(t1 - t2)
	c3(_time)
	if not _time.startswith('-1 day'):
		try:
			h, m, s, _ = _time.replace('.', ':').split(':')
			if h == m == '0':
				if s == '1':                new_time = 'Falta '  + str(int(s)) + ' segundo'
				else:                       new_time = 'Faltan ' + str(int(s)) + ' segundos'
			elif h == '0' and m != '0':
				if m == '1':                new_time = 'Faltan ' + str(int(m)) + ' minuto y '
				else:                       new_time = 'Faltan ' + str(int(m)) + ' minutos y '
				if s == '1':                new_time = new_time  + str(int(s)) + ' segundo'
				else:                       new_time = new_time  + str(int(s)) + ' segundos'	
			elif h != '0':                  new_time = '>1hora'
				
			if new_time == '>1hora':        _time = 'Falta mas de una hora para que empiece.'
			elif new_time != '':            _time = new_time + ' para que empiece...'

		except:
			print('Revisa bien el horario de comienzo...')
			return
	else:                                   _time = '¡Ya comenzamos!'
	_time =  ' ' * int((51 - len(_time)) / 1.5) + _time
	source_set_text(None, 'pre-countdown', _time)

def write_tween_sceneitems():
	while True:
		with open("/home/mario/meytv/obs-scripts/tween_sceneitems.watch", "w") as outfile:
			new_dict = dict()
			for v in globalDict.tween_sceneitems.values():
				if 'player' in v['item_name']:
					new_dict[v['item_name']] = {
						'extra'  : v['extra'].author.name,
						'pos_x' : v['pos_x'],
						'pos_y' : v['pos_y']   }
			json.dump(new_dict, outfile, default=str, sort_keys=True, indent=2, ensure_ascii=False)
		# time.sleep(0.0625) # 16fps
		time.sleep(1)        # 1fps
th(write_tween_sceneitems)

[upgradeQ]

Yes, you can also write stack.enter_context(source_list_auto_release(scenes_list))
ExitStack is more programmable than bare with statement. Sure you can, preferably in the form of module like

from module_name import auto_release
auto_release(val, source_list=True)

Here is the example without with statement, what do you think ?

Code

import obspython as obs
from contextlib import contextmanager, ExitStack
from itertools import cycle

datacycle = cycle([1, 2, 3, 4, 5])


class Example_leak:
    def __init__(self, source_name=None):
        self.source_name = source_name

    def update_text(self):
        source = obs.obs_get_source_by_name(self.source_name)
        if source is not None:
            data = str(next(datacycle))
            settings = obs.obs_data_create()
            obs.obs_data_set_string(settings, "text", data)
            obs.obs_source_update(source, settings)
            # 16:36:24.325: Number of memory leaks: 1543
            # obs.obs_data_release(settings)
            # obs.obs_source_release(source)


@contextmanager
def source_auto_release(source_name):
    source = obs.obs_get_source_by_name(source_name)
    try:
        yield source
    finally:
        obs.obs_source_release(source)


@contextmanager
def data_auto_release():
    settings = obs.obs_data_create()
    try:
        yield settings
    finally:
        obs.obs_data_release(settings)


class Example_with:
    def __init__(self, source_name=None):
        self.source_name = source_name

    def update_text00(self):
        with source_auto_release(self.source_name) as source:
            if source is not None:
                data = str(next(datacycle))
                with data_auto_release() as settings:
                    obs.obs_data_set_string(settings, "text", data)
                    obs.obs_source_update(source, settings)
        # 16:49:11.270: Number of memory leaks: 0

    def update_text(self):
        s = ExitStack()
        source = s.enter_context(source_auto_release(self.source_name))
        if source is not None:
            data = str(next(datacycle))
            settings = s.enter_context(data_auto_release())
            obs.obs_data_set_string(settings, "text", data)
            obs.obs_source_update(source, settings)


eg = Example_with()  # class created ,obs part starts


def refresh_pressed(props, prop):
    print("refresh pressed")
    eg.update_text()


def script_description():
    return "with statement example"


def script_update(settings):
    eg.source_name = obs.obs_data_get_string(settings, "source")
    obs.timer_remove(eg.update_text)
    if eg.source_name != "":
        obs.timer_add(eg.update_text, 16) # 16 ms


def script_properties():  # ui
    props = obs.obs_properties_create()
    p = obs.obs_properties_add_list(
        props,
        "source",
        "Text Source",
        obs.OBS_COMBO_TYPE_EDITABLE,
        obs.OBS_COMBO_FORMAT_STRING,
    )
    sources = obs.obs_enum_sources()
    if sources is not None:
        for source in sources:
            source_id = obs.obs_source_get_unversioned_id(source)
            if source_id == "text_gdiplus" or source_id == "text_ft2_source":
                name = obs.obs_source_get_name(source)
                obs.obs_property_list_add_string(p, name, name)

        obs.source_list_release(sources)
    obs.obs_properties_add_button(props, "button", "Refresh", refresh_pressed)
    return props