Relay SDK for Python

Getting Started

The Relay SDK for Python enables developers to connect and use SignalWire's Relay APIs within their own Python code. Our Relay SDK allows developers to build or add robust and innovative communication services to their applications.

The Relay SDK for Python is easy to use and only takes a few minute to setup and get running.

Latest Version:

Source Code: signalwire/signalwire-python

Support: SignalWire Community Slack Channel

Installation

Install the package using either pip or pipenv:

Using pip

pip install signalwire

Using pipenv

pipenv install signalwire

Minimum Requirements

The Python SDK is build on top of asyncio and requires at least Python 3.6 to be run.
We suggest to use Python 3.7 or above.

Using the SDK

The Python SDK can be used to get up and running with Relay quickly and easily. In order to use the SDK, you must get your project and token from your SignalWire dashboard.

There are a few ways to get started, depending on your needs: Relay.Consumer, Relay.Task and Relay.Client.

Relay Consumer

A Relay.Consumer creates a long running process, allowing you to respond to incoming requests and events in realtime. Relay Consumers abstract all the setup of connecting to Relay and automatically dispatches workers to handle requests; so you can concentrate on writing your code without having to worry about multi-threading or blocking, everything just works. Think of Relay Consumers like a background worker system for all your calling and messaging needs.

Relay Consumers can scale easily, simply by running multiple instances of your Relay.Consumer process. Each event will only be delivered to a single consumer, so as your volume increases, just scale up! This process works well whether you are using Docker Swarm, a Procfile on Heroku, your own webserver, and most other environments.

Setting up a new consumer is the easiest way to get up and running.

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['home', 'office']

  async def ready(self):
    # Consumer is successfully connected with Relay.
    # You can make calls or send messages here..

  async def on_incoming_call(self, call):
    result = await call.answer()
    if result.successful:
      print('Call answered..')

# Run your consumer..
consumer = CustomConsumer()
consumer.run()

Learn more about Relay Consumers

Relay Task

A Relay.Task is simple way to send jobs to your Relay.Consumers from a short lived process, like a web framework. Relay Tasks allow you to pass commands down to your Consumers without blocking your short lived request. Think of a Relay Task as a way to queue a job for your background workers to processes asynchronously.

For example, if you wanted to make an outbound call and play a message when your user clicks a button on your web application, since Relay is a realtime protocol and relies on you to tell it what to do in realtime, if you did this within your web application, your web server would block until the call was finished... this may take a long time! Instead, simply create a new Relay Task. This task will be handled by a running Relay Consumer process and your web application can respond back to your user immediately.

Send a task in the office context with custom data.

# create-task.py
from signalwire.relay.task import Task

project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
task = Task(project=project, token=token)
success = task.deliver('office', {
  'uuid': 'unique id',
  'data': 'data for your job'
})
if success:
  print('Task delivered')
else:
  print('Error delivering task..')

Handle the task in a Consumer.

# consumer-task.py
from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['office']

  async def on_task(self, message):
    print('Handle inbound task')
    print(message['uuid']) # => 'unique id'
    print(message['data']) # => 'data for your job'

consumer = CustomConsumer()
consumer.run()

Learn more about Relay Tasks

Relay Client

Relay.Client is a lower level object, giving you a basic connection to Relay but that is all. It is best used when you are creating a script only concerned with sending outbound requests or you want complete control over the Relay connection yourself.

Setting up a new client and make an outbound call.

from signalwire.relay.client import Client

async def ready(client):
  call = client.calling.new_call(from_number='+1XXXXXXXXXX', to_number='+1YYYYYYYYYY')
  result = await call.dial()
  if result.successful:
    print('Your call has been answered..')

project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
client = Client(project=project, token=token)
client.on('ready', ready)
client.connect()

Learn more about Relay Clients

Contexts

Relay uses Contexts as a simple way to separate events to specific consumers, allowing you to write consumers for specific types of calls or messages or scale them independently. A Context is simply a named string, that allows you to categorize requests. When creating outbound requests, or configuring phone numbers for inbound requests, you can specify the context; Relay will then deliver that call or event to Consumers that are configured to listen for that context.

For example, you could have a customer support phone number configured to send to Relay with the support context, and a personal number configured with personal context. Relay would deliver these events to any Consumer listening for those contexts. This gives you a lot of control in how messages are delivered to your Consumers, allowing you to write Consumer classes specific to the context, scale them independently, or separate traffic based on your own business rules.

API Reference

Relay.Client

Relay.Client is the basic connection to Relay, allowing you send commands to Relay and setup handlers for inbound events.

Constructor

Constructs a client object to interact with Relay.

Parameters

Examples

Create a Client to interact with the Relay API.

from signalwire.relay.client import Client

client = Client(project='<project-id>', token='<project-token>')

Properties

Methods

connect

Activates the connection to the Relay API. The connection to Relay does not happen automatically so that you can setup handlers to events that might occur before the connection is successfully established.

Available In:

Returns

None

Examples

# Make sure you have attached the listeners you need before connecting the client, or you might miss some events.
client.connect()

disconnect

Coroutine that close the Relay connection, cancel the pending tasks and stop the event loop.

Available In:

Returns

awaitable - A coroutine object.

Examples

Within an async function

import asyncio

# with a 'client' variable already created..
async def sleep_and_disconnect():
  await asyncio.sleep(5)
  await client.disconnect()
  print('Client disconnected!')

asyncio.run(sleep_and_disconnect())

Scheduling a new asyncio task.

import asyncio

# schedule a task to disconnect the client..
asyncio.create_task(client.disconnect())

on

Attach an event handler for a specific type of event. The handler could be a coroutine or a normal function.

Available In:

Parameters

Returns

Relay.Client - The client object itself.

Examples

Subscribe to the ready event.

def do_something(client):
  pass

client.on('ready', do_something)

off

Remove an event handler that were attached with .on(). If no handler parameter is passed, all listeners for that event will be removed.

Parameters

Returns

Relay.Client - The client object itself.

Examples

Subscribe to the ready event and then, remove the handler.

def do_something(client):
  pass

client.on('ready', do_something)

# .. later
client.off('ready', do_something)

Events

All available events you can attach a listener on.

Relay.Calling

This represents the API interface for the Calling Relay Service. This object is used to make requests related to managing end to end calls.

Methods

dial

Make an outbound Call and waits until it has been answered or hung up.

Available In:

Parameters

Returns

coroutine - Coroutine object that will be fulfilled with a Relay.Calling.DialResult object.

Examples

Make an outbound Call and print the call object if it was answered.

async def ready(client):
  result = await client.calling.dial(from_number='+1XXXXXXXXXX', to_number='+1YYYYYYYYYY')
  if result.successful:
    # Call has been answered and is now active. Use 'result.call' to access the Call object.
    print(result.call)
  else:
    print('Call failed or not answered.')

newCall

Create a new Call object. The call has not started yet allowing you to attach event listeners on it.

Available In:

Parameters

See Relay.Calling.Dial for the parameter list.

Returns

Call - A new Relay.Calling.Call object.

Examples

Create a new Call object.

call = client.calling.new_call(from_number='+1XXXXXXXXXX', to_number='+1YYYYYYYYYY', timeout=30)
# Use the call object..

Relay.Calling.AnswerResult

This object is returned by the answer method.

Properties

Relay.Calling.Call

All calls in SignalWire have a common generic interface, Call. A Call is a connection between SignalWire and another device.

Properties

Methods

amd

Alias for detect_answering_machine.

amd_async

Alias for detect_answering_machine_async.

answer

Answer an inbound call.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.AnswerResult object.

Examples

Answer an inbound call and check if it was successful.

result = await call.answer()
if result.successful:
  print('Call answered..')
else:
  print('Call failed or not answered.'

connect

Attempt to connect an existing call to a new outbound call and waits until one of the remote party picks the call or the connect fails.
This method involves complex nested parameters. You can connect to multiple devices in series, parallel, or any combination of both with creative use of the parameters. Series implies one device at a time, while parallel implies multiple devices at the same time.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.ConnectResult object.

Examples

Trying to connect a call by calling in series +18991114444 and +18991114445.

devices = [
  { 'to_number': '+18991114444', 'timeout': 10 },
  { 'to_number': '+18991114445', 'timeout': 20 }
]
result = await call.connect(device_list=devices)
if result.successful:
  # result.call is the remote leg connected with yours
  remote_call = result.call

Combine serial and parallel calling. Call +18991114443 first and - if it doesn't answer - try calling in parallel +18991114444 and +18991114445. If none of the devices answer, continue the same process with +18991114446 and +18991114447.

devices = [
  { 'to_number': '+18991114443', 'timeout': 30 },
  [
    { 'to_number': '+18991114444', 'timeout': 30 },
    { 'to_number': '+18991114445', 'timeout': 20 }
  ],
  [
    { 'to_number': '+18991114446', 'timeout': 30 },
    { 'to_number': '+18991114447', 'timeout': 20 }
  ]
]
result = await call.connect(device_list=devices)

if result.successful:
  # result.call is the remote leg connected with yours.
  remote_call = result.call

connect_async

Asynchronous version of connect. It does not wait the connect to completes or fails but returns a Relay.Calling.ConnectAction you can interact with.

Available In:

Parameters

See connect for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.ConnectAction object.

Examples

Trying to connect a call by calling in series +18991114444 and +18991114445.

devices = [
  { 'to_number': '+18991114444', 'timeout': 10 },
  { 'to_number': '+18991114445', 'timeout': 20 }
]
action = await call.connect_async(device_list=devices)
# .. do other important things while Relay try to connect your call..

# .. check whether the action has completed
if action.completed:
  # Your call is now connected with a remote peer

detect

Start a detector on the call and waits until it has finished or failed.

The detect method is a generic method for all types of detecting, see detect_answering_machine, detect_digit or detect_fax for more specific usage.

Available In:

Parameters

• To detect an answering machine:

• To detect digits:

• To detect a fax:

Returns

coroutine - Coroutine that will return a Relay.Calling.DetectResult object.

Examples

Detect a machine with custom parameters and timeout.

result = await call.detect(detect_type='machine', timeout=45, initial_timeout=3)
if result.successful:
  print(f'Detector Result: {result.result}')

Detect a Fax setting timeout only.

result = await call.detect(detect_type='fax', timeout=45)
if result.successful:
  print(f'Detector Result: {result.result}')

detect_async

Asynchronous version of detect. It does not wait the detector ends but returns a Relay.Calling.DetectAction you can interact with.

Available In:

Parameters

See detect for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.DetectAction object.

Examples

Detect all the digits using default parameters. Stop the action after 5 seconds.

import asyncio # to use sleep

action = await call.detect_async(detect_type='digit')
# For demonstration purposes only..
await asyncio.sleep(5)
await action.stop()

detect_answering_machine

This is a helper function that refines the use of detect. The coroutine will return a Relay.Calling.DetectResult object as soon as the detector decided who answered the call: MACHINE, HUMAN or UNKNOWN.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.DetectResult object.

Examples

Perform an AMD and wait until the machine is ready.

result = await call.detect_answering_machine(wait_for_beep=True)
if result.successful:
  print(f'AMD result: {result.result}') # MACHINE || HUMAN || UNKNOWN

detect_answering_machine_async

Asynchronous version of detect_answering_machine. It does not wait the detector ends but returns a Relay.Calling.DetectAction you can interact with.

Available In:

Parameters

See detect_answering_machine for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.DetectAction object.

Examples

Perform an asynchronous AMD on the call. Then stop the action if not completed yet.

action = await call.detect_answering_machine_async()
# Do other things while detector runs and then stop it...
if action.completed:
  detect_result = action.result.result # MACHINE || HUMAN || UNKNOWN
  await action.stop()

detect_digit

This is a helper function that refines the use of detect. This simplifies detecting digits on a call.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.DetectResult object.

Examples

Detect digits and then write a log with the result.

result = await call.detect_digit()
if result.successful:
  print(f'Digits detected: {result.result}')

detect_digit_async

Asynchronous version of detect_digit. It does not wait the detector ends but returns a Relay.Calling.DetectAction you can interact with.

Available In:

Parameters

See detect_digit for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.DetectAction object.

Examples

Detect only 1-3 digits. Stop the action after 5 seconds.

import asyncio # to use sleep

action = await call.detect_digit_async(digits='123')
await asyncio.sleep(5)
await action.stop()

detect_fax

This is a helper function that refines the use of detect. This simplifies detecting a fax.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.DetectResult object.

Examples

Detect fax on the current call.

result = await call.detect_fax()
if result.successful:
  # A fax has been detected!

detect_fax_async

Asynchronous version of detect_fax. It does not wait the detector ends but returns a Relay.Calling.DetectAction you can interact with.

Available In:

Parameters

See detect_fax for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.DetectAction object.

Examples

Detect fax on the current call. Stop the action after 5 seconds.

import asyncio # to use sleep

action = await call.detect_fax_async()
await asyncio.sleep(5)
await action.stop()

dial

This will start a call that was created with new_call and waits until the Call has been answered or hung up.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.DialResult object.

Examples

call = client.calling.new_call(from_number='+1XXXXXXXXXX', to_number='+1YYYYYYYYYY')
result = await call.dial()
if result.successful:
  print('Call answered..')
else:
  print('Call failed or not answered.')

fax_receive

Prepare the call to receive an inbound fax. It waits until the fax has been received or failed.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.FaxResult object.

Examples

Receiving a fax on the call and grab URL and number of received pages from the FaxResult object

result = await call.fax_receive()
if result.successful:
  url = result.document # URL location of the document
  num_pages = result.pages

fax_receive_async

Asynchronous version of fax_receive. It does not wait the fax to be received but returns a Relay.Calling.FaxAction you can interact with.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.FaxAction object.

Examples

Trying to receive a fax. Stop the attempt after 5 seconds.

import asyncio # to use sleep

action = await call.fax_receive_async()
# For demonstration purposes only..
await asyncio.sleep(5)
await action.stop()

fax_send

Send a Fax through the call. It waits until the fax has been sent or failed.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.FaxResult object.

Examples

Sending a fax on the call and grab URL and number of received pages from the FaxResult object

result = await call.fax_send(url='https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf', header='Custom Header')
if result.successful:
  url = result.document # URL location of the document
  num_pages = result.pages

fax_send_async

Asynchronous version of fax_send. It does not wait the fax to be sent but returns a Relay.Calling.FaxAction you can interact with.

Available In:

Parameters

See fax_send for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.FaxAction object.

Examples

Trying to send a fax. Stop sending it after 5 seconds.

import asyncio # to use sleep

action = await call.fax_send_async(url='https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf', header='Custom Header')
# For demonstration purposes only..
await asyncio.sleep(5)
await action.stop()

hangup

Hangup the call.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.HangupResult object.

Examples

Hangup a call and check if it was successful.

result = await call.hangup()
if result.successful:
  print('Call hanged up..')

on

Attach an event handler for the event.

Available In:

Parameters

Returns

Relay.Calling.Call - The call object itself.

Examples

Subscribe to the answered events for a given call.

def on_answered():
  # Call has been answered from the remote party!

call.on('answered', on_answered)

off

Remove an event handler that were attached with .on(). If you don't pass a callback, all listeners for that event will be removed.

Available In:

Parameters

Returns

Relay.Calling.Call - The call object itself.

Examples

Subscribe to the call ended state change and then, remove the event handler.

def on_ended():
  pass

call.on('ended', on_ended)

# .. later
call.off('ended', on_ended)

play

Play one or multiple media in a Call and waits until the playing has ended.
The play method is a generic method for all types of playing, see play_audio, play_silence or play_tts for more specific usage.

Available In:

Parameters

• To play an audio file:

• To play a text to speech string:

• To play silence:

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayResult object.

Examples

Play multiple media elements in the call.

media_list = [
  { 'type': 'tts', 'text': 'Listen this awesome file!' },
  { 'type': 'audio', 'url': 'https://cdn.signalwire.com/default-music/welcome.mp3' },
  { 'type': 'silence', 'duration': 5 },
  { 'type': 'tts', 'text': 'Did you like it?' }
]
result = await call.play(media_list)

play_async

Asynchronous version of play. It does not wait the playing to completes but returns a Relay.Calling.PlayAction you can interact with.

Available In:

Parameters

See play for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayAction object.

Examples

Play multiple media elements in the call and stop them after 5 seconds.

import asyncio # to use sleep

media_list = [
  { 'type': 'tts', 'text': 'Listen this awesome file!' },
  { 'type': 'audio', 'url': 'https://cdn.signalwire.com/default-music/welcome.mp3' },
  { 'type': 'silence', 'duration': 5 },
  { 'type': 'tts', 'text': 'Did you like it?' }
]
action = await call.play_async(media_list)
await asyncio.sleep(5)
await action.stop()

play_audio

This is a helper function that refines the use of play. This simplifies playing an audio file.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayResult object.

Examples

Play an Mp3 file.

result = await call.play_audio('https://cdn.signalwire.com/default-music/welcome.mp3')

play_audio_async

Asynchronous version of play_audio. It does not wait the playing to completes but returns a Relay.Calling.PlayAction you can interact with.

Available In:

Parameters

See play_audio for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayAction object.

Examples

Play an Mp3 file and stop it after 5 seconds.

import asyncio # to use sleep

action = await call.play_audio_async('https://cdn.signalwire.com/default-music/welcome.mp3')
await asyncio.sleep(5)
await action.stop()

play_silence

This is a helper function that refines the use of play. This simplifies playing silence.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayResult object.

Examples

Play silence for 10 seconds.

result = await call.play_silence(10)

play_silence_async

Asynchronous version of play_silence. It does not wait the playing to completes but returns a Relay.Calling.PlayAction you can interact with.

Available In:

Parameters

See play_silence for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayAction object.

Examples

Play silence for 60 seconds then stop it after 5 seconds.

import asyncio # to use sleep

action = await call.play_silence_async(60)
await asyncio.sleep(5)
await action.stop()

play_ringtone

This is a helper function that refines the use of play. This simplifies playing TTS.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayResult object.

Examples

Play a single US ringtone.

result = await call.play_ringtone(name='us')

play_ringtone_async

Asynchronous version of play_ringtone. It does not wait the playing to completes but returns a Relay.Calling.PlayAction you can interact with.

Available In:

Parameters

See play_ringtone for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayAction object.

Examples

Play the US ringtone for 30 seconds but stop it after 5 seconds.

import asyncio # to use sleep

action = await call.play_ringtone_async(name='us', duration=30)
# For demonstration purposes only..
await asyncio.sleep(5)
await action.stop()

play_tts

This is a helper function that refines the use of play. This simplifies playing TTS.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayResult object.

Examples

Play TTS.

result = await call.play_tts(text='Welcome to SignalWire!', gender='male')

play_tts_async

Asynchronous version of play_tts. It does not wait the playing to completes but returns a Relay.Calling.PlayAction you can interact with.

Available In:

Parameters

See play_tts for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayAction object.

Examples

Play TTS and stop it after 5 seconds.

import asyncio # to use sleep

action = await call.play_tts_async(text='Welcome to SignalWire!', gender='male')
await asyncio.sleep(5)
await action.stop()

prompt

Play one or multiple media while collecting user's input from the call at the same time, such as digits and speech.
It waits until the collection succeed or timeout is reached.
The prompt method is a generic method, see prompt_audio, prompt_tts or prompt_ringtone for more specific usage.

Available In:

Parameters

• To collect digits:

• To collect speech:

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptResult object.

Examples

Ask user to enter their PIN and collect the digits.

media_list = [
  { 'type': 'tts', 'text': 'Welcome at SignalWire. Please, enter your PIN and then # to proceed' }
]
result = await call.prompt(prompt_type='digits', media_list=media_list, digits_max=4, digits_terminators='#')
if result.successful:
  pin = result.result # pin entered by the user

prompt_async

Asynchronous version of prompt. It does not wait the collection to completes but returns a Relay.Calling.PromptAction you can interact with.

Available In:

Parameters

See prompt for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptAction object.

Examples

Ask user to enter their PIN and collect the digits.

media_list = [
  { 'type': 'tts', 'text': 'Welcome at SignalWire. Please, enter your PIN and then # to proceed' }
  { 'type': 'audio', 'url': 'https://cdn.signalwire.com/default-music/welcome.mp3' }
]
action = await call.prompt_async(prompt_type='digits', media_list=media_list, digits_max=4, digits_terminators='#')
# .. do other important things while collecting user digits..

if action.completed:
  result = action.result # => PromptResult object

prompt_audio

This is a helper function that refines the use of prompt.
This function simplifies playing an audio file while collecting user's input from the call, such as digits and speech.

Available In:

Parameters

You can set all the properties that prompt accepts replacing media_list with:

The SDK will build the media_list for you.

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptResult object.

Examples

Collect user's digits while playing an Mp3 file.

result = await call.prompt_audio(prompt_type='digits', url='https://cdn.signalwire.com/default-music/welcome.mp3', digits_max=4)
if result.successful:
  digits = result.result # digits entered by the user

prompt_audio_async

Asynchronous version of prompt_audio. It does not wait the collection to completes but returns a Relay.Calling.PromptAction you can interact with.

Available In:

Parameters

See prompt_audio for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptAction object.

Examples

Ask user to enter their PIN and collect the digits.

action = await call.prompt_audio_async(prompt_type='digits', url='https://cdn.signalwire.com/default-music/welcome.mp3', digits_max=4)
# .. do other important things while collecting user digits..
if action.completed:
  result = action.result # => PromptResult object

prompt_ringtone

This is a helper function that refines the use of prompt.
This function simplifies playing TTS while collecting user's input from the call, such as digits and speech.

Available In:

Parameters

You can set all the properties that prompt accepts replacing media_list with:

The SDK will build the media_list for you.

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptResult object.

Examples

Play US ringtone for 30 seconds while collect digits.

result = await call.prompt_ringtone(prompt_type='digits', name='us', duration=30, digits_max=4)
if result.successful:
  digits = result.result # digits entered by the user

prompt_ringtone_async

Asynchronous version of prompt_ringtone. It does not wait the collection to completes but returns a Relay.Calling.PromptAction you can interact with.

Available In:

Parameters

See prompt_ringtone for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptAction object.

Examples

Play US ringtone for 30 seconds while collect digits in asynchronous.

action = await call.prompt_ringtone_async(prompt_type='digits', name='us', duration=30, digits_max=4)
# .. do other important things while collecting user digits..
if action.completed:
  result = action.result # => PromptResult object

prompt_tts

This is a helper function that refines the use of prompt.
This function simplifies playing TTS while collecting user's input from the call, such as digits and speech.

Available In:

Parameters

You can set all the properties that prompt accepts replacing media_list with:

The SDK will build the media_list for you.

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptResult object.

Examples

Ask user to enter their PIN and collect the digits.

result = await call.prompt_tts(prompt_type='digits', text='Please, enter your 3 digit PIN', digits_max=3)
if result.successful:
  pin = result.result # PIN entered by the user

prompt_tts_async

Asynchronous version of prompt_tts. It does not wait the collection to completes but returns a Relay.Calling.PromptAction you can interact with.

Available In:

Parameters

See prompt_tts for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptAction object.

Examples

Ask user to enter their PIN and collect the digits.

action = await call.prompt_tts_async(prompt_type='digits', text='Please, enter your 3 digit PIN', gender='male', digits_max=3)
# .. do other important things while collecting user digits..
if action.completed:
  result = action.result # => PromptResult object

record

Start recording the call and waits until the recording ends or fails.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.RecordResult object.

Examples

Start recording audio in the call for both direction in stereo mode, if successful, grab url, duration and size from the RecordResult object.

result = await call.record(stereo=True, direction='both')
if result.successful:
  print(f'Url: {result.url}')
  print(f'Duration: {result.duration}')
  print(f'Size: {result.size}')

record_async

Asynchronous version of record. It does not wait the end of recording but returns a Relay.Calling.RecordAction you can interact with.

Available In:

Parameters

See record for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.RecordAction object.

Examples

Start recording audio in the call for both direction in stereo mode and stop it after 5 seconds.

import asyncio # to use sleep

action = await call.record_async(stereo=True, direction='both')
await asyncio.sleep(5)
await action.stop()

send_digits

This method sends DTMF digits to the other party on the call.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.SendDigitsResult object.

Examples

Send some digits.

result = await call.send_digits('123')

send_digits_async

Asynchronous version of send_digits. It does not wait for the sending event to complete, and immediately returns a Relay.Calling.SendDigitsAction object you can interact with.

Available In:

Parameters

See send_digits for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.SendDigitsAction

Examples

Send some digits and stop the operation after 3 seconds.

import asyncio # to use sleep

action = await call.send_digits_async('1W2W3W4w5w6W7W8W9')

await asyncio.sleep(3)
await action.stop()

tap

Intercept call media and stream it to the specify endpoint. It waits until the end of the call.

Available In:

Parameters

• To tap through RTP:

Returns

coroutine - Coroutine that will return a Relay.Calling.TapResult object.

Examples

Tapping audio from the call, if successful, print both source and destination devices from the TapResult object.

result = await call.tap(audio_direction='listen', target_type='rtp', target_addr='192.168.1.1', target_port=1234)
if result.successful:
  # Print source and destination devices..
  print(result.source_device)
  print(result.destination_device)

tap_async

Asynchronous version of tap. It does not wait the end of tapping but returns a Relay.Calling.TapAction you can interact with.

Available In:

Parameters

See tap for the parameter list.

Returns

coroutine - Coroutine that will return a Relay.Calling.TapAction object.

Examples

Tapping audio from the call and then stop it using the TapAction object.

import asyncio # to use sleep

action = await call.tap_async(audio_direction='listen', target_type='rtp', target_addr='192.168.1.1', target_port=1234)
# Do other things while tapping the media and then stop it..
await asyncio.sleep(3)
await action.stop()

wait_for

Wait for specific events on the Call or returns false if the Call ends without getting them.

Available In:

Parameters

Returns

coroutine - Coroutine object that will be resolved with true or false.

Examples

Wait for ending or ended events.

success = await call.waitFor('ending', 'ended')

wait_for_answered

This is a helper function that refines the use of wait_for. This simplifies waiting for the answered state.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return true or false.

Examples

Wait for the answered event.

success = await call.wait_for_answered()

wait_for_ended

This is a helper function that refines the use of wait_for. This simplifies waiting for the ended state.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return true or false.

Examples

Wait for the ended event.

success = await call.wait_for_ended()

wait_for_ending

This is a helper function that refines the use of wait_for. This simplifies waiting for the ending state.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return true or false.

Examples

Wait for the ending event.

success = await call.waitForEnding()

wait_for_ringing

This is a helper function that refines the use of wait_for. This simplifies waiting for the ringing state.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return true or false.

Examples

Wait for ending or ended events.

success = await call.wait_for_ringing()

Events

All these events can be used to track the calls lifecycle and instruct SignalWire on what to do for each different state.

State Events

To track the state of a call.

Connect Events

To track the connect state of a call.

Play Events

To track a playback state.

Record Events

To track a recording state.

Prompt Events

To track a prompt state.

Fax Events

To track a fax state.

Detect Events

To track a detector state.

Tap Events

To track a tapping state.

Digits Events

To track a send digits action state.

Ringtones

Here you can find all the accepted values for the ringtone to play, based on short country codes:

Relay.Calling.ConnectAction

This object returned from connect_async method that represents a connecting attempt that is currently active on a call.

Properties

Relay.Calling.ConnectResult

This object returned from connect method that represents the final result of a connection between your call and a remote one.

Properties

Relay.Calling.DetectAction

This object returned from one of the asynchronous detect methods that represents a running detector on the call.

Properties

Methods

stop

Stop the action immediately.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.StopResult object.

Examples

Trying to detect a machine and stop the action after 5 seconds.

import asyncio # to use sleep

action = await call.detect_answering_machine_async()
# For demonstration purposes only..
await asyncio.sleep(5)
await action.stop()

Relay.Calling.DetectResult

This object returned from one of the synchronous detect methods that represents the final result of a detector.

Properties

Relay.Calling.DialResult

This object is returned by the dial method.

Properties

Relay.Calling.FaxAction

This object returned from faxReceiveAsync and faxSendAsync methods represents a receiving or sending Fax on the call.

Properties

Methods

stop

Stop the action immediately.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.StopResult object.

Examples

Start sending fax and stop it after 5 seconds.

import asyncio # to use sleep

action = await call.fax_send_async('https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf')
# For demonstration purposes only..
await asyncio.sleep(5)
await action.stop()

Relay.Calling.FaxResult

This object returned from faxReceive and faxSend methods that represents the final result of a sent or received Fax.

Properties

Relay.Calling.HangupResult

This object is returned by the hangup method.

Properties

Relay.Calling.PlayAction

This object returned from one of asynchronous play methods that represents a playing currently active on a call.

Properties

Methods

pause

Pause the playback immediately.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayPauseResult object.

Examples

Start playing an audio file and pause it after 5 seconds.

import asyncio # to use sleep

action = await call.play_audio_async('https://cdn.signalwire.com/default-music/welcome.mp3')
await asyncio.sleep(5)
pause_result = await action.pause()

resume

Resume the playback immediately.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayResumeResult object.

Examples

Start playing an audio file, stop it and then resume it after 5 seconds.

import asyncio # to use sleep

action = await call.play_audio_async('https://cdn.signalwire.com/default-music/welcome.mp3')
await asyncio.sleep(5)
pause_result = await action.pause()
await asyncio.sleep(5)
resume_result = await action.resume()

stop

Stop the action immediately.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.StopResult object.

Examples

Play an Mp3 file and stop it after 5 seconds.

import asyncio # to use sleep

action = await call.play_audio_async('https://cdn.signalwire.com/default-music/welcome.mp3')
await asyncio.sleep(5)
await action.stop()

volume

Control the volume of the playback.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.PlayVolumeResult object.

Examples

Start playing an audio file and increase the playback volume.

action = await call.play_audio_async('https://cdn.signalwire.com/default-music/welcome.mp3')
result = await action.volume(5.0)

Relay.Calling.PlayPauseResult

This object is returned by pause method and represents the final result of a play pause operation.

Properties

Relay.Calling.PlayResult

This object returned from one of the synchronous play methods that represents the final result of a playing.

Properties

Relay.Calling.PlayResumeResult

This object is returned by resume method and represents the final result of a play resume operation.

Properties

Relay.Calling.PlayVolumeResult

This object is returned by volume method and represents the final result of a volume control operation.

Properties

Relay.Calling.PromptAction

This object returned from one of asynchronous prompt methods that represents a prompt attempt that is currently active on a call.

Properties

Methods

stop

Stop the action immediately.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.StopResult object.

Examples

Ask user to enter a PIN and force-stop the action after 5 seconds.

import asyncio # to use sleep

action = await call.play_tts_async(text='Welcome to SignalWire!', gender='male')
await asyncio.sleep(5)
await action.stop()

volume

Control the volume of the playback.

Available In:

Parameters

Returns

coroutine - Coroutine that will return a Relay.Calling.PromptVolumeResult object.

Examples

Start the prompt and increase the playback volume.

action = await call.play_tts_async(text='Please, enter your 3 digit PIN.', gender='male')
volume_result = await action.volume(5.0)

Relay.Calling.PromptResult

This object returned from one of the synchronous prompt methods that represents the final result of a prompting attempt.

Properties

Relay.Calling.PromptVolumeResult

This object is returned by volume method and represents the final result of a volume control operation.

Properties

Relay.Calling.RecordAction

This object returned from record_async method that represents a recording currently active on a call.

Properties

Methods

stop

Stop the action immediately.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.StopResult object.

Examples

Start recording the call and stop it after 10 seconds.

import asyncio # to use sleep

action = await call.record_async(stereo=True)
await asyncio.sleep(10)
await action.stop()

Relay.Calling.RecordResult

This object returned from record method that represents the final result of a recording.

Properties

Relay.Calling.SendDigitsAction

This object is returned by the sendDigitsAsync method and represents a send digits action currently active on a call.

Properties

Relay.Calling.SendDigitsResult

This object is returned by the sendDigits method and represents the final result of the action.

Properties

Relay.Calling.TapAction

This object returned from tapAsync method that represents the running media tapping active on a call.

Properties

Methods

stop

Stop the action immediately.

Available In:

Parameters

None

Returns

coroutine - Coroutine that will return a Relay.Calling.StopResult object.

Examples

Start tapping using RTP and stop it after 5 seconds.

import asyncio # to use sleep

action = await call.tap_async(audio_direction='listen', target_type='rtp', target_addr='192.168.1.1', target_port=1234)
# Do other things while tapping the media and then stop it..
await asyncio.sleep(5)
await action.stop()

Relay.Calling.TapResult

This object returned from tap method that represents the final result of a tapping.

Properties

Relay.Consumer

A Relay Consumer is a simple object that runs in its own process along side your application to handle calling and messaging events in realtime. Relay Consumers abstract all the setup of connecting to Relay and automatically dispatch workers to handle requests. Consumers will receive requests and delegate them to their own worker thread, allowing you to focus on your business logic without having to worry about multi-threading or blocking, everything just works. Think of Relay Consumers like a background worker system for all your calling and messaging needs.

Creating Consumers

A Relay Consumer is a simple object, customized by specifying contexts and event handlers to respond to incoming events.

A consumer has 2 required properties: project, token, and usually requires at least one contexts for incoming events. Project and Token are used to authenticate your Consumer to your SignalWire account. Contexts are a list of contexts you want this Consumer to listen for. Learn more about Contexts.

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['default']

  async def ready(self):
    print('Your consumer is ready!')

  async def on_incoming_call(self, call):
    result = await call.answer()
    if result.successful:
      print('Call answered..')

# Run your consumer..
consumer = CustomConsumer()
consumer.run()

Initializing Consumers

Within setup method you set the project, token and contexts. You can also do any initialization work before processing messages. This is useful to do any one-off work that you wouldn't want to do for each and every event, such as setting up logging or connecting to a datastore.

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['support', 'office']

  async def on_incoming_call(self, call):
    pass

# Run your consumer..
consumer = CustomConsumer()
consumer.run()

Properties

Event Handlers

Event handlers are where you will write most of your code. They are executed when your consumer receives a matching event for the contexts specified by your Consumer.

ready

Executed once your Consumer is connected to Relay and the session has been established.

Available In:

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['default']

  async def ready(self):
    result = await self.client.calling.dial(from_number='+1XXXXXXXXXX', to_number='+1YYYYYYYYYY')
    if result.successful:
      # Call has been answered and is now active. Use 'result.call' to access the Call object.
      print(result.call)

# Run your consumer..
consumer = CustomConsumer()
consumer.run()

on_incoming_call

Executed when you receive an inbound call, passes in the inbound Call object.

Available In:

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['default']

  async def on_incoming_call(self, call):
    result = await call.answer()
    if result.successful:
      print('Call answered..')

# Run your consumer..
consumer = CustomConsumer()
consumer.run()

on_task

Executed with your message sent through a Relay.Task.

Available In:

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['office']

  async def on_task(self, message):
    print('Handle inbound task in the office context')
    print(message)

consumer = CustomConsumer()
consumer.run()

on_incoming_message

Executed when you receive an inbound SMS or MMS, passes in the inbound Message object.

Available In:

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['office']

  async def on_incoming_message(self, message):
    print('Handle inbound message')
    print(message)

consumer = CustomConsumer()
consumer.run()

on_message_state_change

Executed when a message state changes, passes in the inbound Message object.

Available In:

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['office']

  async def on_message_state_change(self, message):
    print('A message state changed')
    print(message)

consumer = CustomConsumer()
consumer.run()

Cleaning Up on Exit

When a Relay Consumer shuts down, you have the opportunity to clean up any resources held by the consumer. For example, you could close any open files, network connections, or send a notification to your monitoring service.

Just implement a teardown method in your consumer and it will be called during the shutdown procedure.

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['office']

  def teardown(self):
    print('Consumer teardown..')

  async def on_task(self, message):
    pass

  async def on_incoming_call(self, call):
    pass

consumer = CustomConsumer()
consumer.run()

Running Consumers

Running a consumer is just like running any Python script, simply execute the script as a separate process and ensure you have .run() at the end of your script. The process will stay up until you shut it down.

Shutting Down Consumers

In order to gracefully shut down a Relay consumer process, send it the SIGTERM signal. Most process supervisors such as Runit, Docker and Kubernetes send this signal when shutting down a process, so using those systems will make things easier.

Relay.Event

This object represents the last Relay event that completed an operation on the Call.

Properties

Relay.Messaging

This represents the API interface for the Messaging Relay Service. This object is used to make requests related to managing SMS and MMS messages.

Methods

send

Send an outbound SMS or MMS message.

Available In:

Parameters

Returns

coroutine - Coroutine that will be fulfilled with a Relay.Messaging.SendResult object.

Examples

Send a message in the context office.

result = await client.messaging.send(context='office', from_number='+1XXXXXXXXXX', to_number='+1YYYYYYYYYY', body='Welcome at SignalWire!')
if result.successful:
  print(f'Message ID: {result.message_id}')

Relay.Messaging.Message

An object representing an SMS or MMS message. It is the parameter of both onIncomingMessage and onMessageStateChange Consumer handlers.

Properties

Events

State Events

To track the state of a message.

Relay.Messaging.SendResult

This object returned from send method that represents the result of a send operation.

Properties

Relay.Task

A Relay.Task is simple way to send jobs to your Relay.Consumers from a short lived process, like a web framework. Relay Tasks allow you to pass commands down to your Consumers without blocking your short lived request. Think of a Relay Task as a way to queue a job for your background workers to processes asynchronously.

Creating Tasks

A Task is a simple object with 2 required arguments: project and token. Project and Token are used to send the Task to your Consumers. Once created, the Task has only one method deliver to send jobs to your Consumer.

from signalwire.relay.task import Task

task = Task(project='<my-project>', token='<my-token>')
success = task.deliver('context-here', { 'key': 'random data' })

Methods

deliver

Send a job to your Consumer in a specific context.

Available In:

Parameters

Returns

coroutine - Coroutine that will be fulfilled with a boolean value.

Examples

Deliver a task to your Consumer with a message to then make an outbound Call.

from signalwire.relay.task import Task

project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
task = Task(project=project, token=token)
data = {
  'action': 'call',
  'from': '+18881112222'
  'to': '+18881113333'
}
success = task.deliver('office', data)
if success:
  print('Task delivered')
else:
  print('Task not delivered')

Examples

Follow the examples to see how's easy to use the Relay SDK to interact with inbound or outbound calls.

Outbound Calls

Using a Relay Consumer to make an outbound call and say "Welcome to SignalWire!", then hangup.

import logging
from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['office']

  async def ready(self):
    logging.info('CustomConsumer is ready!')
    # Replace numbers with yours!
    dial_result = await self.client.calling.dial(to_number='+18991114443', from_number='+18991114444')
    if dial_result.successful is False:
      logging.info('Outbound call not answered or failed')
      return
    # Take the Call object from "dial_result"
    call = dial_result.call
    await call.play_tts(text='Welcome to SignalWire!')
    logging.info('Hanging up..')
    await call.hangup()

consumer = CustomConsumer()
consumer.run()

Connect inbound calls with a series of devices

Using a Relay Consumer to manage inbound calls from the office context. Answer the call, try to connect it with 3 devices and wait until the remote call will be hanged up.

from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['office']
    self.devices = [
      { 'to_number': '+18991114443' },
      { 'to_number': '+18991114444' },
      { 'to_number': '+18991114445' }
    ]

  async def on_incoming_call(self, call):
    result = await call.answer()
    if result.successful is False:
      print('Error answering the call')
      return
    result = await call.connect(device_list=self.devices)
    if result.successful:
      remote_call = result.call
      # Wait until the remote leg is ended..
      await remote_call.wait_for_ended()
    await call.hangup()

consumer = CustomConsumer()
consumer.run()

Send an SMS

Using a Relay Consumer to send SMS.

import logging
from signalwire.relay.consumer import Consumer

class CustomConsumer(Consumer):
  def setup(self):
    self.project = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
    self.token = 'PTXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    self.contexts = ['office']

  async def ready(self):
    logging.info('CustomConsumer is ready!')
    # Replace numbers with yours!
    result = await self.client.messaging.send(context='office', to_number='+18991114443', from_number='+18991114444', body='Welcome to SignalWire!')
    if result.successful:
      logging.info(f'Message sent. ID: {result.message_id}')

consumer = CustomConsumer()
consumer.run()