FilesExpand file tree

 master

/

example_basic_asyncio.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

154 lines (117 loc) · 5.12 KB

 master

/

example_basic_asyncio.py

Copy path

Top

File metadata and controls

• Code
• Blame

154 lines (117 loc) · 5.12 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

#!/usr/bin/env python3

# Python Stream Deck Library

# Released under the MIT license

#

# dean [at] fourwalledcubicle [dot] com

# www.fourwalledcubicle.com

#

# Example script showing basic library usage, using Python's asyncio coroutines

# library - updating key images with new tiles generated at runtime, and

# responding to button state change events.

import asyncio

import os

import threading

from PIL import Image, ImageDraw, ImageFont

from StreamDeck.DeviceManager import DeviceManager

from StreamDeck.ImageHelpers import PILHelper

from StreamDeck.Transport.Transport import TransportError

# Folder location of image assets used by this example.

ASSETS_PATH = os.path.join(os.path.dirname(__file__), "Assets")

# Generates a custom tile with run-time generated text and custom image via the

# PIL module.

def render_key_image(deck, icon_filename, font_filename, label_text):

# Resize the source image asset to best-fit the dimensions of a single key,

# leaving a margin at the bottom so that we can draw the key title

# afterwards.

icon = Image.open(icon_filename)

image = PILHelper.create_scaled_key_image(deck, icon, margins=[0, 0, 20, 0])

# Load a custom TrueType font and use it to overlay the key index, draw key

# label onto the image a few pixels from the bottom of the key.

draw = ImageDraw.Draw(image)

font = ImageFont.truetype(font_filename, 14)

draw.text((image.width / 2, image.height - 5), text=label_text, font=font, anchor="ms", fill="white")

return PILHelper.to_native_key_format(deck, image)

# Returns styling information for a key based on its position and state.

def get_key_style(deck, key, state):

# Last button in the example application is the exit button.

exit_key_index = deck.key_count() - 1

if key == exit_key_index:

name = "exit"

icon = "{}.png".format("Exit")

font = "Roboto-Regular.ttf"

label = "Bye" if state else "Exit"

else:

name = "emoji"

icon = "{}.png".format("Pressed" if state else "Released")

font = "Roboto-Regular.ttf"

label = "Pressed!" if state else "Key {}".format(key)

return {

"name": name,

"icon": os.path.join(ASSETS_PATH, icon),

"font": os.path.join(ASSETS_PATH, font),

"label": label

}

# Creates a new key image based on the key index, style and current key state

# and updates the image on the StreamDeck.

def update_key_image(deck, key, state):

# Determine what icon and label to use on the generated key.

key_style = get_key_style(deck, key, state)

# Generate the custom key with the requested image and label.

image = render_key_image(deck, key_style["icon"], key_style["font"], key_style["label"])

# Use a scoped-with on the deck to ensure we're the only thread using it

# right now.

with deck:

# Update requested key with the generated image.

deck.set_key_image(key, image)

# Prints key state change information, updates the key image and performs any

# associated actions when a key is pressed.

async def key_change_callback(deck, key, state):

# Print new key state

print("Deck {} Key {} = {}".format(deck.id(), key, state), flush=True)

# Don't try to draw an image on a touch button

if key >= deck.key_count():

return

# Update the key image based on the new key state.

update_key_image(deck, key, state)

# Check if the key is changing to the pressed state.

if state:

key_style = get_key_style(deck, key, state)

# When an exit button is pressed, close the application.

if key_style["name"] == "exit":

# Use a scoped-with on the deck to ensure we're the only thread

# using it right now.

with deck:

# Reset deck, clearing all button images.

deck.reset()

# Close deck handle, terminating internal worker threads.

deck.close()

async def main(loop):

print("Found {} Stream Deck(s).\n".format(len(streamdecks)))

for index, deck in enumerate(streamdecks):

# This example only works with devices that have screens.

if not deck.is_visual():

continue

deck.open()

deck.reset()

print("Opened '{}' device (serial number: '{}', fw: '{}')".format(

deck.deck_type(), deck.get_serial_number(), deck.get_firmware_version()

))

# Set initial screen brightness to 30%.

deck.set_brightness(30)

# Set initial key images.

for key in range(deck.key_count()):

update_key_image(deck, key, False)

# Register callback function for when a key state changes.

deck.set_key_callback_async(key_change_callback)

if __name__ == "__main__":

streamdecks = DeviceManager().enumerate()

loop = asyncio.get_event_loop()

loop.run_until_complete(main(loop))

loop.run_forever()

# Wait until all application threads have terminated (for this example,

# this is when all deck handles are closed).

for t in threading.enumerate():

try:

t.join()

except (TransportError, RuntimeError):

pass