def getScenes(self):
ret = self.ws.call(requests.GetCurrentScene())
#print("current scene : ",ret.getName())
ret = self.ws.call(requests.GetSceneList())
self.data = ret.datain
self.scenes = self.data["scenes"]
self.keyScenes = getKeyScenes(self.scenes)
return
def main():
ws = obsws(host, port, password)
ws.connect()
ret = ws.call(requests.GetCurrentScene())
print("current scene : ", ret.getName())
sources = ret.getSources()
print("current sources : ", sources)
for source in sources:
properties = ws.call(requests.GetSceneItemProperties(source["name"]))
print("properties : ", properties.datain)
s1 = PROPERTIES(properties.datain)
w = WINDOW_EASER(1280, 720)
w.setWindow("f1")
w.setWindow("f2")
w.setKeyFrame("f1", 10 * 2, [0, 0, 1, 1])
w.setKeyFrame("f2", 10 * 2, [1, 0, 1, 1])
w.setKeyFrame("f1", 20 * 2, [0.1, 0.1, 0.4, 0.4])
w.setKeyFrame("f2", 20 * 2, [0.9, 0.5, 0.4, 0.4])
w.setKeyFrame("f1", 30 * 2, [0.1, 0.1, 0.4, 0.4])
w.setKeyFrame("f2", 30 * 2, [0.9, 0.5, 0.4, 0.4])
w.setKeyFrame("f1", 40 * 2, [0.5, 0.1, 0.4, 0.4])
w.setKeyFrame("f2", 40 * 2, [0.5, 0.5, 0.4, 0.4])
w.setKeyFrame("f1", 50 * 2, [0.5, 0.1, 0.4, 0.4])
w.setKeyFrame("f2", 50 * 2, [0.5, 0.5, 0.4, 0.4])
w.setKeyFrame("f1", 80 * 2, [0, 0, 1, 1])
w.setKeyFrame("f2", 80 * 2, [1, 0, 1, 1])
w.setupKeyFrame()
while 1:
for i in range(80 * 2):
#print "=====================",i
ret = w.update()
#frame = w.draw()
for source in sources:
scale = s1.getScale(ret[source["name"]][3])
if "f2" == source["name"]:
data = requests.SetSceneItemTransform(
source["name"], -scale, scale, 0).data()
else:
data = requests.SetSceneItemTransform(
source["name"], scale, scale, 0).data()
data["message-id"] = 100
ws.ws.send(json.dumps(data))
time.sleep(0.01)
data = requests.SetSceneItemPosition(
source["name"], ret[source["name"]][0],
ret[source["name"]][1]).data()
data["message-id"] = 100
ws.ws.send(json.dumps(data))
time.sleep(0.01)
#cv2.imshow("window",frame)
#cv2.waitKey(1)
w.initKeyFrame()
ws.disconnect()
def update_mute_status(self, sources=None):
if sources is None:
sources = self.client.call(requests.GetCurrentScene()).getSources()
webcam_found = False
for source in sources:
if source['name'] in ['Webcam', 'Overlay: Webcam']:
webcam_found = True
self._send_osc('/cam', 1.0 if source['render'] else 0.0)
if not webcam_found:
self._send_osc('/cam', 0.0)
def SalvarEstadoActual(self):
"""Salta estado inicial de OBS para StreamDeck."""
DataEscenaActual = self.OBS.call(requests.GetCurrentScene()).datain
EstadoActual = self.OBS.call(requests.GetStreamingStatus()).datain
SalvarValor("data/obs.json", "obs_conectar", self.Conectado)
SalvarValor("data/obs.json", "obs_escena", DataEscenaActual["name"])
SalvarValor("data/obs.json", "obs_grabar", EstadoActual["recording"])
SalvarValor("data/obs.json", "obs_envivo", EstadoActual["streaming"])
self.SalvarFuente()
def follow_alert(name):
print("New follower:", name)
ws.connect()
current_scene = ws.call(requests.GetCurrentScene()).getName()
if current_scene == "game scene":
ws.call(requests.SetCurrentScene("abonnement"))
minylpg.follower_alert(name)
ws.call(requests.SetCurrentScene(current_scene))
else:
minylpg.follower_alert(name)
ws.disconnect()
def main():
ws = obsws(host, port, password)
ws.connect()
PNFactoryX = perlin.PerlinNoiseFactory(1)
PNFactoryY = perlin.PerlinNoiseFactory(1)
ret = ws.call(requests.GetCurrentScene())
print("current scene : ", ret.getName())
sources = ret.getSources()
print("current sources : ", sources)
for source in sources:
properties = ws.call(requests.GetSceneItemProperties(source["name"]))
print("properties : ", properties.datain)
s1 = PROPERTIES(properties.datain)
w = WINDOW_EASER(1280, 720)
w.setWindow("f1")
w.setKeyFrame("f1", 10 * 2, [-0.05, -0.05, 1.1, 1.1])
w.setKeyFrame("f1", 20 * 2, [-0.05, -0.05, 1.1, 1.1])
w.setKeyFrame("f1", 40 * 2, [-0.2, -0.2, 1.4, 1.4])
w.setKeyFrame("f1", 50 * 2, [-0.2, -0.2, 1.4, 1.4])
w.setKeyFrame("f1", 70 * 2, [-0.05, -0.05, 1.1, 1.1])
w.setKeyFrame("f1", 80 * 2, [-0.05, -0.05, 1.1, 1.1])
w.setupKeyFrame()
while 1:
for i in range(80 * 2):
#print "=====================",i
ret = w.update()
#frame = w.draw()
for source in sources:
scale = s1.getScale(ret["f1"][3])
data = requests.SetSceneItemTransform(source["name"], scale,
scale, 0).data()
data["message-id"] = 100
ws.ws.send(json.dumps(data))
data = requests.SetSceneItemPosition(
source["name"],
ret["f1"][0] + PNFactoryX(i / 30.0) * 20 - 20,
ret["f1"][1] + PNFactoryY(i / 30.0) * 20 - 20).data()
data["message-id"] = 100
ws.ws.send(json.dumps(data))
time.sleep(0.02)
#cv2.imshow("window",frame)
#cv2.waitKey(1)
w.initKeyFrame()
ws.disconnect()
def requestCurrentSceneName():
global currentSceneName, lastCommunicationTime
message = ""
signal.signal(signal.SIGALRM, signal_handler)
signal.alarm(2)
print("Requesting current scene name - ", end="")
try:
message = ws.call(requests.GetCurrentScene())
currentSceneName = getSceneName(message)
print("Response: " + currentSceneName)
logging.debug("Current scene name: " + currentSceneName)
lastCommunicationTime = time.time()
except:
print("NO RESPONSE!")
logging.debug("NO RESPONSE to current scene name request!")
signal.signal(signal.SIGALRM, signal.SIG_IGN)
signal.alarm(0)
def updateScene(self, sceneName, sceneId, speed=20):
self.speed = speed
currentScene = self.ws.call(requests.GetCurrentScene())
currentSceneName = currentScene.getName()
self.currentSceneName = currentSceneName
currentSceneData = currentScene.datain
print(currentSceneName)
if currentSceneName in self.keyScenes and sceneName == currentSceneName:
destSceneName = getSceneName(currentSceneName, sceneId)
destScene = getSceneFromName(self.scenes, destSceneName)
#print(destScene)
if destScene is not None:
self.setDest(currentSceneData, destScene, speed)
#self.updateToEnd()
return
def run(self, event: obs.ObsEvent) -> None:
if isinstance(event, ObsConnected):
scene = self.obsws.call(requests.GetCurrentScene())
try:
sources = scene.getSources()
except KeyError:
sources = []
for s in sources:
if s['name'] in self.mutable_scene_items:
self.mutable_items_visible[s['name']] = s['render']
# Any item not in the current scene, we'll consider not visible.
for i in self.mutable_scene_items:
self.mutable_items_visible.setdefault(i, False)
mute_status = self.obsws.call(requests.GetMute(self.mic_source))
self.muted = mute_status.getMuted()
logger.info(
f'Starting: {self.muted}, {self.mutable_items_visible}')
return
if isinstance(event, obs.ObsDisconnected):
self.cancel_timer()
return
event = cast(ObsMessage, event)
msg = event.obs_message
if isinstance(msg, events.SourceMuteStateChanged):
self.muted = msg.getMuted()
if self.accidentally_muted():
self.start_timer()
else:
self.cancel_timer()
self.has_announced = False
elif isinstance(msg, events.SceneItemVisibilityChanged):
self.mutable_items_visible[
msg.getItemName()] = msg.getItemVisible()
if self.accidentally_muted():
self.start_timer()
else:
self.cancel_timer()
elif isinstance(msg, events.StreamStopping):
self.cancel_timer()
def HiloFuenteArchivo(self):
DataEscenaActual = self.OBS.call(requests.GetCurrentScene()).datain
Refrescar = False
for Fuente in DataEscenaActual["sources"]:
NombreFuente = Fuente["name"]
EstadoFuente = ObtenerValor("data/obs_fuente.json", NombreFuente, Depurar=False)
EstadoFuenteActual = self.OBS.call(requests.GetSceneItemProperties(NombreFuente)).datain
if "visible" in EstadoFuenteActual:
EstadoFuenteActual = EstadoFuenteActual["visible"]
if EstadoFuente is not None:
if EstadoFuente != EstadoFuenteActual:
self.CambiarFuente(Fuente=NombreFuente)
Refrescar = True
else:
SalvarValor("data/obs_fuente.json", NombreFuente, EstadoFuenteActual)
Refrescar = True
self.SalvarFiltroFuente(NombreFuente)
if Refrescar:
self.actualizarDeck()
def switch(bh, msg, scene):
"""Switch OBS scenes"""
print(scene)
# Help text
help = '\n'.join([
'available scenes: ' + ' '.join('`' + x + '`'
for x in sorted(SCENES.keys())),
'switch with `switch $NAME`',
])
if not scene or scene not in SCENES:
return help
ws.connect()
# Set the scene
ws.call(requests.SetCurrentScene(SCENES[scene]))
# Get current scene and verify it is as expected
ret = ws.call(requests.GetCurrentScene())
ws.disconnect()
# React if it works
if ret.getName() == SCENES[scene]:
bh.react(msg, 'check_mark')
def current_scene(self):
scene = self.ws.call(requests.GetCurrentScene()).getName()
return scene
def handle(socket, scene: beatoraja.Scene):
name = config.OBS_SCENES.get(scene, None)
if name is None or socket.call(obsrequests.GetCurrentScene()).getName() == name:
return
socket.call(obsrequests.SetCurrentScene(name))
def current_scene(self):
logging.debug(f"OBS property: current_scene.")
return self.ws_call(requests.GetCurrentScene()).getName()
cam_num_str = cam_num_str_base.upper() + set_cam_num(
) #Read the GPIO inputs to set the cam num - 3 bits, Num_Sel1 is LSB, Set to upper case so that it's case insensitive
if debug_level >= 1: print("Cam Num: ", cam_num_str)
try:
while 1:
addr = find_open_socket()
if addr != "":
ws = obsws(addr, port, password)
ws.register(on_event)
ws.register(on_prog_switch,
events.SwitchScenes) #Event for Scene going to Program
ws.register(on_prev_switch, events.PreviewSceneChanged
) #Event for Scene selected in Preview
ws.connect()
message = ws.call(
requests.GetCurrentScene()
) #Get the Name of the Scene currently in Program (chk connection and set initial Prog LED state)
sn = str(message)[str(message).find("name"):]
sn = sn[:sn.find(",")]
usn = sn.upper()
connected = True
if debug_level >= 1:
print("Connected! Current Scene in Program: ", sn)
ipAddressHistory = open(
"obsAddr.log",
"w") #Store the connected IP address in the log file
ipAddressHistory.write(addr)
ipAddressHistory.close()
if usn.find(
cam_num_str
) > -1: #Set initial Program LED states (since changes are based on events) - No way to determine current Preview scene?
def current_scene(ws, args):
response = ws.call(requests.GetCurrentScene())
print(response.getName())
def get_scenes():
global current_scene
current_scene = ws.call(requests.GetCurrentScene()).getName()
current_scene = str(current_scene)
start = time.time()
os.chdir(sys.path[0])
print("os.getcwd", os.getcwd())
sys.path.append('../')
logging.basicConfig(level=logging.ERROR)
from obswebsocket import obsws, requests, events
ws = obsws(host, port, password)
ws.connect()
def sendpacket(packet):
ws.send(packet)
try:
scene_to_screenshot = ws.call(requests.GetCurrentScene()).getName()
scene_to_screenshot = str(scene_to_screenshot)
if freeze_scene != scene_to_screenshot:
packet01 = {
"request-type": "TakeSourceScreenshot",
"sourceName": scene_to_screenshot,
"width": 1280,
"height": 720,
"saveToFilePath": file_path
}
packet02 = {
"request-type": "SetCurrentScene",
"scene-name": freeze_scene
}
sendpacket(packet01)
def main(scr):
# Setup curses
curses.noecho()
curses.cbreak()
scr.nodelay(True)
while scr.getch() != curses.ERR:
pass
screen_width = 0
screen_height = 0
win = None
curses_logger = None
def handle_resize():
nonlocal curses_logger
nonlocal screen_width, screen_height
nonlocal win
nonlocal curses_logger
screen_height, screen_width = scr.getmaxyx()
win = curses.newwin(screen_height, screen_width, 0, 0)
win.scrollok(True)
win.idlok(True)
win.leaveok(True)
root_logger = logging.getLogger()
if curses_logger != None:
root_logger.removeHandler(curses_logger)
curses_logger = CursesLoggingHandler(win)
curses_logger.setFormatter(
logging.Formatter(
'%(asctime)-8s|%(name)-12s|%(levelname)-6s|%(message)-s',
'%H:%M:%S'))
root_logger.addHandler(curses_logger)
handle_resize()
selected_computer = 1
streaming_computers = []
task_queue = queue.Queue()
def handle_switch_scenes(message):
def handler():
nonlocal selected_computer, streaming_computers, ws
streaming_computers = get_currently_streaming_computers(ws)
logger.info('Currently streaming computers: %r' %
streaming_computers)
if selected_computer in streaming_computers:
selected_computer = -1
task_queue.put(handler)
# Read user data
remote_computers = []
with open('users.csv', 'r') as user_file:
user_reader = csv.reader(user_file)
# Skip header
next(user_reader, None)
for user_line in user_reader:
host, user = user_line
remote_computers.append(RemoteComputer(host, user))
command = [
'ssh', '-o', 'UserKnownHostsFile=/dev/null', '-o',
'StrictHostKeyChecking=no', '{user}@{host}', 'bash', '-s', '--',
'{user}', 'udp://{master_host}:{local_port}'
]
with open('remote-script.sh', 'r') as script_file:
script = bytearray(script_file.read(), 'utf-8')
remote_manager = RemoteComputerManager(remote_computers, command, script)
ws = obsws("127.0.0.1", 4444, "")
ws.register(on_event)
ws.register(handle_switch_scenes, events.SwitchScenes)
ws.connect()
# Initialize currently selected scenes
handle_switch_scenes(ws.call(requests.GetCurrentScene()))
# TODO: Handle SceneItemAdded
# TODO: Handle recursive scenes
try:
while True:
while True:
try:
task = task_queue.get_nowait()
task()
except queue.Empty:
# No more tasks to handle
break
key = scr.getch()
if key == curses.KEY_RESIZE:
handle_resize()
if ord('0') <= key <= ord('9'):
new_selection = key - ord('0')
while new_selection < 1:
new_selection += 10
if new_selection in streaming_computers:
logger.warning(
'Cannot change the source of currently streaming computer'
)
selected_computer = 0
else:
logger.info('Selected computer: %d' % new_selection)
selected_computer = new_selection
# TODO: A more intuitive way to connect to remote computers
else:
char = key - ord('A')
if char >= 26:
char = key - ord('a')
if 0 <= char < len(remote_computers):
if selected_computer == 0:
logger.warning('No computer selected')
else:
remote_machine = char
logger.info('Starting streaming %d to preview %d',
remote_machine, selected_computer)
remote_manager.connect(selected_computer,
remote_machine)
#ws.call(requests.SetPreviewScene(random.choice(scenes)['name']))
#time.sleep(.5)
#ws.call(requests.TransitionToProgram('fade'))
#time.sleep(.5)
except KeyboardInterrupt:
pass
ws.disconnect()
def GetCurrentScene(self):
try:
return self.ws.call(requests.GetCurrentScene()).__dict__["datain"]
except Exception as e:
print(e)
def get(self, scene_name):
scene = ws.call(requests.GetCurrentScene())
name = scene.getName()
if name != scene_name:
ws.call(requests.SetCurrentScene(scene_name))
import numpy as np
from obswebsocket import obsws, requests
#document
# https://github.com/Elektordi/obs-websocket-py/blob/master/obswebsocket/requests.py
#original document
# https://github.com/Palakis/obs-websocket/blob/4.x-current/docs/generated/protocol.md
host = "localhost"
port = 4444
password = "******"
ws = obsws(host, port, password)
ws.connect()
ret = ws.call(requests.GetCurrentScene())
print("current scene : ", ret.getName())
sources = ret.getSources()
print("current sources : ", sources)
for source in sources:
properties = ws.call(requests.GetSceneItemProperties(source["name"]))
print("properties : ", properties.datain)
t0 = time.time()
for i in range(50):
for source in sources:
properties = ws.call(
requests.SetSceneItemPosition(source["name"],
np.sin(i / 20.0) * 100 + 100, 0))
t1 = time.time()
def current_scene(self):
"""
Get the current Scene.
:return: Str. Scene name
"""
return self.socket.call(requests.GetCurrentScene()).datain['name']
