def fetch(self, country_code=values.unset, type=values.unset,
add_ons=values.unset, add_ons_data=values.unset):
"""
Fetch a PhoneNumberInstance
:param unicode country_code: Optional ISO country code of the phone number.
:param unicode type: Indicates the type of information you would like returned with your request.
:param unicode add_ons: Indicates the particular Add-on you would like to use to get more information.
:param dict add_ons_data: The add_ons_data
:returns: Fetched PhoneNumberInstance
:rtype: twilio.rest.lookups.v1.phone_number.PhoneNumberInstance
"""
params = values.of({
'CountryCode': country_code,
'Type': serialize.map(type, lambda e: e),
'AddOns': serialize.map(add_ons, lambda e: e),
})
params.update(serialize.prefixed_collapsible_map(add_ons_data, 'AddOns'))
payload = self._version.fetch(
'GET',
self._uri,
params=params,
)
return PhoneNumberInstance(self._version, payload, phone_number=self._solution['phone_number'], )
def fetch(self, country_code=values.unset, type=values.unset,
add_ons=values.unset, add_ons_data=values.unset):
"""
Fetch a PhoneNumberInstance
:param unicode country_code: The ISO country code of the phone number
:param unicode type: The type of information to return
:param unicode add_ons: The unique_name of an Add-on you would like to invoke
:param dict add_ons_data: Data specific to the add-on you would like to invoke
:returns: Fetched PhoneNumberInstance
:rtype: twilio.rest.lookups.v1.phone_number.PhoneNumberInstance
"""
params = values.of({
'CountryCode': country_code,
'Type': serialize.map(type, lambda e: e),
'AddOns': serialize.map(add_ons, lambda e: e),
})
params.update(serialize.prefixed_collapsible_map(add_ons_data, 'AddOns'))
payload = self._version.fetch(
'GET',
self._uri,
params=params,
)
return PhoneNumberInstance(self._version, payload, phone_number=self._solution['phone_number'], )
def update(self, hosted_number_order_sids=values.unset,
address_sid=values.unset, email=values.unset, cc_emails=values.unset,
status=values.unset):
"""
Update the AuthorizationDocumentInstance
:param unicode hosted_number_order_sids: A list of HostedNumberOrder sids.
:param unicode address_sid: Address sid.
:param unicode email: Email.
:param unicode cc_emails: A list of emails.
:param AuthorizationDocumentInstance.Status status: The Status of this AuthorizationDocument.
:returns: Updated AuthorizationDocumentInstance
:rtype: twilio.rest.preview.hosted_numbers.authorization_document.AuthorizationDocumentInstance
"""
data = values.of({
'HostedNumberOrderSids': serialize.map(hosted_number_order_sids, lambda e: e),
'AddressSid': address_sid,
'Email': email,
'CcEmails': serialize.map(cc_emails, lambda e: e),
'Status': status,
})
payload = self._version.update(
'POST',
self._uri,
data=data,
)
return AuthorizationDocumentInstance(self._version, payload, sid=self._solution['sid'], )
def create(self, hosted_number_order_sids, address_sid, email,
cc_emails=values.unset):
"""
Create a new AuthorizationDocumentInstance
:param unicode hosted_number_order_sids: A list of HostedNumberOrder sids.
:param unicode address_sid: Address sid.
:param unicode email: Email.
:param unicode cc_emails: A list of emails.
:returns: Newly created AuthorizationDocumentInstance
:rtype: twilio.rest.preview.hosted_numbers.authorization_document.AuthorizationDocumentInstance
"""
data = values.of({
'HostedNumberOrderSids': serialize.map(hosted_number_order_sids, lambda e: e),
'AddressSid': address_sid,
'Email': email,
'CcEmails': serialize.map(cc_emails, lambda e: e),
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return AuthorizationDocumentInstance(self._version, payload, )
def page(self, binding_type=values.unset, identity=values.unset,
page_token=values.unset, page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of BindingInstance records from the API.
Request is executed immediately
:param BindingInstance.BindingType binding_type: The push technology used for the bindings returned.
:param unicode identity: The identity
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of BindingInstance
:rtype: twilio.rest.chat.v2.service.binding.BindingPage
"""
params = values.of({
'BindingType': serialize.map(binding_type, lambda e: e),
'Identity': serialize.map(identity, lambda e: e),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return BindingPage(self._version, response, self._solution)
def page(self, start_date=values.unset, end_date=values.unset,
identity=values.unset, tag=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of BindingInstance records from the API.
Request is executed immediately
:param date start_date: Only list Bindings created on or after the given date.
:param date end_date: Only list Bindings created on or before the given date.
:param unicode identity: Only list Bindings that have any of the specified Identities.
:param unicode tag: Only list Bindings that have all of the specified Tags.
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of BindingInstance
:rtype: twilio.rest.notify.v1.service.binding.BindingPage
"""
params = values.of({
'StartDate': serialize.iso8601_date(start_date),
'EndDate': serialize.iso8601_date(end_date),
'Identity': serialize.map(identity, lambda e: e),
'Tag': serialize.map(tag, lambda e: e),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return BindingPage(self._version, response, self._solution)
def test_does_not_change_other_types(self):
actual = serialize.map("abc", lambda e: e * 2)
self.assertEqual("abc", actual)
actual = serialize.map(123, lambda e: e * 2)
self.assertEqual(123, actual)
actual = serialize.map({'some': 'val'}, lambda e: e * 2)
self.assertEqual({'some': 'val'}, actual)
def create(self, body=values.unset, priority=values.unset, ttl=values.unset,
title=values.unset, sound=values.unset, action=values.unset,
data=values.unset, apn=values.unset, gcm=values.unset,
sms=values.unset, facebook_messenger=values.unset, fcm=values.unset,
segment=values.unset, alexa=values.unset, to_binding=values.unset,
identity=values.unset, tag=values.unset):
"""
Create a new NotificationInstance
:param unicode body: The notification body text
:param NotificationInstance.Priority priority: The priority of the notification
:param unicode ttl: How long, in seconds, the notification is valid
:param unicode title: The notification title
:param unicode sound: The name of the sound to be played for the notification
:param unicode action: The actions to display for the notification
:param dict data: The custom key-value pairs of the notification's payload
:param dict apn: The APNS-specific payload that overrides corresponding attributes in a generic payload for APNS Bindings
:param dict gcm: The GCM-specific payload that overrides corresponding attributes in generic payload for GCM Bindings
:param dict sms: The SMS-specific payload that overrides corresponding attributes in generic payload for SMS Bindings
:param dict facebook_messenger: Deprecated
:param dict fcm: The FCM-specific payload that overrides corresponding attributes in generic payload for FCM Bindings
:param unicode segment: A Segment to notify
:param dict alexa: Deprecated
:param unicode to_binding: The destination address specified as a JSON string
:param unicode identity: The `identity` value that identifies the new resource's User
:param unicode tag: A tag that selects the Bindings to notify
:returns: Newly created NotificationInstance
:rtype: twilio.rest.notify.v1.service.notification.NotificationInstance
"""
data = values.of({
'Identity': serialize.map(identity, lambda e: e),
'Tag': serialize.map(tag, lambda e: e),
'Body': body,
'Priority': priority,
'Ttl': ttl,
'Title': title,
'Sound': sound,
'Action': action,
'Data': serialize.object(data),
'Apn': serialize.object(apn),
'Gcm': serialize.object(gcm),
'Sms': serialize.object(sms),
'FacebookMessenger': serialize.object(facebook_messenger),
'Fcm': serialize.object(fcm),
'Segment': serialize.map(segment, lambda e: e),
'Alexa': serialize.object(alexa),
'ToBinding': serialize.map(to_binding, lambda e: e),
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return NotificationInstance(self._version, payload, service_sid=self._solution['service_sid'], )
def create(self, body=values.unset, priority=values.unset, ttl=values.unset,
title=values.unset, sound=values.unset, action=values.unset,
data=values.unset, apn=values.unset, gcm=values.unset,
sms=values.unset, facebook_messenger=values.unset, fcm=values.unset,
segment=values.unset, alexa=values.unset, to_binding=values.unset,
identity=values.unset, tag=values.unset):
"""
Create a new NotificationInstance
:param unicode body: Indicates the notification body text.
:param NotificationInstance.Priority priority: Two priorities defined: low and high.
:param unicode ttl: This parameter specifies how long the notification is valid.
:param unicode title: Indicates the notification title.
:param unicode sound: Indicates a sound to be played.
:param unicode action: Specifies the actions to be displayed for the notification.
:param dict data: This parameter specifies the custom key-value pairs of the notification's payload.
:param dict apn: APNS specific payload that overrides corresponding attributes in a generic payload for Bindings with the apn BindingType.
:param dict gcm: GCM specific payload that overrides corresponding attributes in generic payload for Bindings with gcm BindingType.
:param dict sms: SMS specific payload that overrides corresponding attributes in generic payload for Bindings with sms BindingType.
:param dict facebook_messenger: Messenger specific payload that overrides corresponding attributes in generic payload for Bindings with facebook-messenger BindingType.
:param dict fcm: FCM specific payload that overrides corresponding attributes in generic payload for Bindings with fcm BindingType.
:param unicode segment: The segment
:param dict alexa: The alexa
:param unicode to_binding: The destination address in a JSON object.
:param unicode identity: Delivery will be attempted only to Bindings with an Identity in this list.
:param unicode tag: Delivery will be attempted only to Bindings that have all of the Tags in this list.
:returns: Newly created NotificationInstance
:rtype: twilio.rest.notify.v1.service.notification.NotificationInstance
"""
data = values.of({
'Identity': serialize.map(identity, lambda e: e),
'Tag': serialize.map(tag, lambda e: e),
'Body': body,
'Priority': priority,
'Ttl': ttl,
'Title': title,
'Sound': sound,
'Action': action,
'Data': serialize.object(data),
'Apn': serialize.object(apn),
'Gcm': serialize.object(gcm),
'Sms': serialize.object(sms),
'FacebookMessenger': serialize.object(facebook_messenger),
'Fcm': serialize.object(fcm),
'Segment': serialize.map(segment, lambda e: e),
'Alexa': serialize.object(alexa),
'ToBinding': serialize.map(to_binding, lambda e: e),
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return NotificationInstance(self._version, payload, service_sid=self._solution['service_sid'], )
def update(self, unique_name=values.unset, ttl=values.unset,
status=values.unset, participants=values.unset):
"""
Update the SessionInstance
:param unicode unique_name: A unique, developer assigned name of this Session.
:param unicode ttl: How long will this session stay open, in seconds.
:param SessionInstance.Status status: The Status of this Session
:param unicode participants: The participants
:returns: Updated SessionInstance
:rtype: twilio.rest.preview.proxy.service.session.SessionInstance
"""
data = values.of({
'UniqueName': unique_name,
'Ttl': ttl,
'Status': status,
'Participants': serialize.map(participants, lambda e: e),
})
payload = self._version.update(
'POST',
self._uri,
data=data,
)
return SessionInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
sid=self._solution['sid'],
)
def create(self, unique_name=values.unset, date_expiry=values.unset,
ttl=values.unset, mode=values.unset, status=values.unset,
participants=values.unset):
"""
Create a new SessionInstance
:param unicode unique_name: An application-defined string that uniquely identifies the resource
:param datetime date_expiry: The ISO 8601 date when the Session should expire
:param unicode ttl: When the session will expire
:param SessionInstance.Mode mode: The Mode of the Session
:param SessionInstance.Status status: Session status
:param dict participants: The Participant objects to include in the new session
:returns: Newly created SessionInstance
:rtype: twilio.rest.proxy.v1.service.session.SessionInstance
"""
data = values.of({
'UniqueName': unique_name,
'DateExpiry': serialize.iso8601_datetime(date_expiry),
'Ttl': ttl,
'Mode': mode,
'Status': status,
'Participants': serialize.map(participants, lambda e: serialize.object(e)),
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return SessionInstance(self._version, payload, service_sid=self._solution['service_sid'], )
def page(self, identity=values.unset, segment=values.unset,
page_token=values.unset, page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of UserInstance records from the API.
Request is executed immediately
:param unicode identity: The identity
:param unicode segment: The segment
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of UserInstance
:rtype: twilio.rest.notify.v1.service.user.UserPage
"""
params = values.of({
'Identity': serialize.map(identity, lambda e: e),
'Segment': segment,
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return UserPage(self._version, response, self._solution)
def page(self, identity=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of InviteInstance records from the API.
Request is executed immediately
:param unicode identity: A unique string identifier for this User in this Service.
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of InviteInstance
:rtype: twilio.rest.chat.v1.service.channel.invite.InvitePage
"""
params = values.of({
'Identity': serialize.map(identity, lambda e: e),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return InvitePage(self._version, response, self._solution)
def create(self, identity, binding_type, address, tag=values.unset,
notification_protocol_version=values.unset,
credential_sid=values.unset, endpoint=values.unset):
"""
Create a new BindingInstance
:param unicode identity: The Identity to which this Binding belongs to.
:param BindingInstance.BindingType binding_type: The type of the Binding.
:param unicode address: The address specific to the channel.
:param unicode tag: The list of tags associated with this Binding.
:param unicode notification_protocol_version: The version of the protocol used to send the notification.
:param unicode credential_sid: The unique identifier of the Credential resource to be used to send notifications to this Binding.
:param unicode endpoint: DEPRECATED*
:returns: Newly created BindingInstance
:rtype: twilio.rest.notify.v1.service.binding.BindingInstance
"""
data = values.of({
'Identity': identity,
'BindingType': binding_type,
'Address': address,
'Tag': serialize.map(tag, lambda e: e),
'NotificationProtocolVersion': notification_protocol_version,
'CredentialSid': credential_sid,
'Endpoint': endpoint,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return BindingInstance(self._version, payload, service_sid=self._solution['service_sid'], )
def page(self, start_date=values.unset, end_date=values.unset, tag=values.unset,
page_token=values.unset, page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of UserBindingInstance records from the API.
Request is executed immediately
:param date start_date: The start_date
:param date end_date: The end_date
:param unicode tag: The tag
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of UserBindingInstance
:rtype: twilio.rest.notify.v1.service.user.user_binding.UserBindingPage
"""
params = values.of({
'StartDate': serialize.iso8601_date(start_date),
'EndDate': serialize.iso8601_date(end_date),
'Tag': serialize.map(tag, lambda e: e),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return UserBindingPage(self._version, response, self._solution)
def page(self, type=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of ChannelInstance records from the API.
Request is executed immediately
:param ChannelInstance.ChannelType type: The type
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of ChannelInstance
:rtype: twilio.rest.chat.v2.service.channel.ChannelPage
"""
params = values.of({
'Type': serialize.map(type, lambda e: e),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return ChannelPage(self._version, response, self._solution)
def create(self, phone_number, sms_capability, account_sid=values.unset,
friendly_name=values.unset, unique_name=values.unset,
cc_emails=values.unset, sms_url=values.unset,
sms_method=values.unset, sms_fallback_url=values.unset,
sms_fallback_method=values.unset, status_callback_url=values.unset,
status_callback_method=values.unset,
sms_application_sid=values.unset, address_sid=values.unset,
email=values.unset, verification_type=values.unset,
verification_document_sid=values.unset):
"""
Create a new HostedNumberOrderInstance
:param unicode phone_number: An E164 formatted phone number.
:param bool sms_capability: Specify SMS capability to host.
:param unicode account_sid: Account Sid.
:param unicode friendly_name: A human readable description of this resource.
:param unicode unique_name: A unique, developer assigned name of this HostedNumberOrder.
:param unicode cc_emails: A list of emails.
:param unicode sms_url: SMS URL.
:param unicode sms_method: SMS Method.
:param unicode sms_fallback_url: SMS Fallback URL.
:param unicode sms_fallback_method: SMS Fallback Method.
:param unicode status_callback_url: Status Callback URL.
:param unicode status_callback_method: Status Callback Method.
:param unicode sms_application_sid: SMS Application Sid.
:param unicode address_sid: Address sid.
:param unicode email: Email.
:param HostedNumberOrderInstance.VerificationType verification_type: Verification Type.
:param unicode verification_document_sid: Verification Document Sid
:returns: Newly created HostedNumberOrderInstance
:rtype: twilio.rest.preview.hosted_numbers.hosted_number_order.HostedNumberOrderInstance
"""
data = values.of({
'PhoneNumber': phone_number,
'SmsCapability': sms_capability,
'AccountSid': account_sid,
'FriendlyName': friendly_name,
'UniqueName': unique_name,
'CcEmails': serialize.map(cc_emails, lambda e: e),
'SmsUrl': sms_url,
'SmsMethod': sms_method,
'SmsFallbackUrl': sms_fallback_url,
'SmsFallbackMethod': sms_fallback_method,
'StatusCallbackUrl': status_callback_url,
'StatusCallbackMethod': status_callback_method,
'SmsApplicationSid': sms_application_sid,
'AddressSid': address_sid,
'Email': email,
'VerificationType': verification_type,
'VerificationDocumentSid': verification_document_sid,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return HostedNumberOrderInstance(self._version, payload, )
def create(self, body=values.unset, media_url=values.unset):
"""
Create a new MessageInteractionInstance
:param unicode body: Message body
:param unicode media_url: Reserved
:returns: Newly created MessageInteractionInstance
:rtype: twilio.rest.proxy.v1.service.session.participant.message_interaction.MessageInteractionInstance
"""
data = values.of({'Body': body, 'MediaUrl': serialize.map(media_url, lambda e: e), })
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return MessageInteractionInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
session_sid=self._solution['session_sid'],
participant_sid=self._solution['participant_sid'],
)
def update(self, date_expiry=values.unset, ttl=values.unset, mode=values.unset,
status=values.unset, participants=values.unset):
"""
Update the SessionInstance
:param datetime date_expiry: The ISO 8601 date when the Session should expire
:param unicode ttl: When the session will expire
:param SessionInstance.Mode mode: The Mode of the Session
:param SessionInstance.Status status: The new status of the resource
:param dict participants: The Participant objects to include in the session
:returns: Updated SessionInstance
:rtype: twilio.rest.proxy.v1.service.session.SessionInstance
"""
data = values.of({
'DateExpiry': serialize.iso8601_datetime(date_expiry),
'Ttl': ttl,
'Mode': mode,
'Status': status,
'Participants': serialize.map(participants, lambda e: serialize.object(e)),
})
payload = self._version.update(
'POST',
self._uri,
data=data,
)
return SessionInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
sid=self._solution['sid'],
)
def update(self, webhook_method=values.unset, webhook_filters=values.unset,
pre_webhook_url=values.unset, post_webhook_url=values.unset,
pre_webhook_retry_count=values.unset,
post_webhook_retry_count=values.unset, target=values.unset):
"""
Update the WebhookInstance
:param unicode webhook_method: The HTTP method to be used when sending a webhook request.
:param unicode webhook_filters: The list of webhook event triggers that are enabled for this Service.
:param unicode pre_webhook_url: The absolute url the pre-event webhook request should be sent to.
:param unicode post_webhook_url: The absolute url the post-event webhook request should be sent to.
:param unicode pre_webhook_retry_count: The number of retries in case of pre-event webhook request failures.
:param unicode post_webhook_retry_count: The number of retries in case of post-event webhook request failures.
:param WebhookInstance.Target target: The routing target of the webhook.
:returns: Updated WebhookInstance
:rtype: twilio.rest.messaging.v1.webhook.WebhookInstance
"""
data = values.of({
'WebhookMethod': webhook_method,
'WebhookFilters': serialize.map(webhook_filters, lambda e: e),
'PreWebhookUrl': pre_webhook_url,
'PostWebhookUrl': post_webhook_url,
'PreWebhookRetryCount': pre_webhook_retry_count,
'PostWebhookRetryCount': post_webhook_retry_count,
'Target': target,
})
payload = self._version.update(
'POST',
self._uri,
data=data,
)
return WebhookInstance(self._version, payload, )
def create(self, unique_name=values.unset, date_expiry=values.unset,
ttl=values.unset, mode=values.unset, status=values.unset,
participants=values.unset):
"""
Create a new SessionInstance
:param unicode unique_name: A unique, developer assigned name of this Session.
:param datetime date_expiry: The date this Session should expire
:param unicode ttl: TTL for a Session, in seconds.
:param SessionInstance.Mode mode: The Mode of this Session
:param SessionInstance.Status status: Session status
:param dict participants: The participants
:returns: Newly created SessionInstance
:rtype: twilio.rest.proxy.v1.service.session.SessionInstance
"""
data = values.of({
'UniqueName': unique_name,
'DateExpiry': serialize.iso8601_datetime(date_expiry),
'Ttl': ttl,
'Mode': mode,
'Status': status,
'Participants': serialize.map(participants, lambda e: serialize.object(e)),
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return SessionInstance(self._version, payload, service_sid=self._solution['service_sid'], )
def create(self, identity, binding_type, address, tag=values.unset,
notification_protocol_version=values.unset,
credential_sid=values.unset, endpoint=values.unset):
"""
Create a new BindingInstance
:param unicode identity: The `identity` value that identifies the new resource's User
:param BindingInstance.BindingType binding_type: The type of the Binding
:param unicode address: The channel-specific address
:param unicode tag: A tag that can be used to select the Bindings to notify
:param unicode notification_protocol_version: The protocol version to use to send the notification
:param unicode credential_sid: The SID of the Credential resource to be used to send notifications to this Binding
:param unicode endpoint: Deprecated
:returns: Newly created BindingInstance
:rtype: twilio.rest.notify.v1.service.binding.BindingInstance
"""
data = values.of({
'Identity': identity,
'BindingType': binding_type,
'Address': address,
'Tag': serialize.map(tag, lambda e: e),
'NotificationProtocolVersion': notification_protocol_version,
'CredentialSid': credential_sid,
'Endpoint': endpoint,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return BindingInstance(self._version, payload, service_sid=self._solution['service_sid'], )
def update(self, configuration_url=values.unset,
configuration_method=values.unset,
configuration_filters=values.unset,
configuration_triggers=values.unset,
configuration_flow_sid=values.unset,
configuration_retry_count=values.unset,
configuration_buffer_messages=values.unset,
configuration_buffer_window=values.unset):
"""
Update the WebhookInstance
:param unicode configuration_url: The absolute url the webhook request should be sent to.
:param WebhookInstance.Method configuration_method: The HTTP method to be used when sending a webhook request.
:param unicode configuration_filters: The list of events, firing webhook event for this Session.
:param unicode configuration_triggers: The list of keywords, firing webhook event for this Session.
:param unicode configuration_flow_sid: The studio flow sid, where the webhook should be sent to.
:param unicode configuration_retry_count: The number of retries in case of webhook request failures.
:param bool configuration_buffer_messages: The flag whether buffering should be applied to messages.
:param unicode configuration_buffer_window: The period of buffering messages.
:returns: Updated WebhookInstance
:rtype: twilio.rest.messaging.v1.session.webhook.WebhookInstance
"""
data = values.of({
'Configuration.Url': configuration_url,
'Configuration.Method': configuration_method,
'Configuration.Filters': serialize.map(configuration_filters, lambda e: e),
'Configuration.Triggers': serialize.map(configuration_triggers, lambda e: e),
'Configuration.FlowSid': configuration_flow_sid,
'Configuration.RetryCount': configuration_retry_count,
'Configuration.BufferMessages': configuration_buffer_messages,
'Configuration.BufferWindow': configuration_buffer_window,
})
payload = self._version.update(
'POST',
self._uri,
data=data,
)
return WebhookInstance(
self._version,
payload,
session_sid=self._solution['session_sid'],
sid=self._solution['sid'],
)
def create(self, to, status_callback=values.unset, application_sid=values.unset,
max_price=values.unset, provide_feedback=values.unset,
validity_period=values.unset, max_rate=values.unset,
force_delivery=values.unset, provider_sid=values.unset,
content_retention=values.unset, address_retention=values.unset,
smart_encoded=values.unset, from_=values.unset,
messaging_service_sid=values.unset, body=values.unset,
media_url=values.unset):
"""
Create a new MessageInstance
:param unicode to: The phone number to receive the message
:param unicode status_callback: URL Twilio will request when the status changes
:param unicode application_sid: The application to use for callbacks
:param unicode max_price: The total maximum price up to the fourth decimal in US dollars acceptable for the message to be delivered.
:param bool provide_feedback: Set this value to true if you are sending messages that have a trackable user action and you intend to confirm delivery of the message using the Message Feedback API.
:param unicode validity_period: The number of seconds that the message can remain in a Twilio queue.
:param unicode max_rate: The max_rate
:param bool force_delivery: The force_delivery
:param unicode provider_sid: The provider_sid
:param MessageInstance.ContentRetention content_retention: The content_retention
:param MessageInstance.AddressRetention address_retention: The address_retention
:param bool smart_encoded: The smart_encoded
:param unicode from_: The phone number that initiated the message
:param unicode messaging_service_sid: The 34 character unique id of the Messaging Service you want to associate with this Message.
:param unicode body: The text of the message you want to send, limited to 1600 characters.
:param unicode media_url: The URL of the media you wish to send out with the message.
:returns: Newly created MessageInstance
:rtype: twilio.rest.api.v2010.account.message.MessageInstance
"""
data = values.of({
'To': to,
'From': from_,
'MessagingServiceSid': messaging_service_sid,
'Body': body,
'MediaUrl': serialize.map(media_url, lambda e: e),
'StatusCallback': status_callback,
'ApplicationSid': application_sid,
'MaxPrice': max_price,
'ProvideFeedback': provide_feedback,
'ValidityPeriod': validity_period,
'MaxRate': max_rate,
'ForceDelivery': force_delivery,
'ProviderSid': provider_sid,
'ContentRetention': content_retention,
'AddressRetention': address_retention,
'SmartEncoded': smart_encoded,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return MessageInstance(self._version, payload, account_sid=self._solution['account_sid'], )
def create(self, type, configuration_url=values.unset,
configuration_method=values.unset,
configuration_filters=values.unset,
configuration_triggers=values.unset,
configuration_flow_sid=values.unset,
configuration_retry_count=values.unset):
"""
Create a new WebhookInstance
:param WebhookInstance.Type type: The type of webhook
:param unicode configuration_url: The URL of the webhook to call
:param WebhookInstance.Method configuration_method: The HTTP method used to call `configuration.url`
:param unicode configuration_filters: The events that cause us to call the Channel Webhook
:param unicode configuration_triggers: A string that will cause us to call the webhook when it is found in a message body
:param unicode configuration_flow_sid: The SID of the Studio Flow to call when an event occurs
:param unicode configuration_retry_count: The number of times to retry the webhook if the first attempt fails
:returns: Newly created WebhookInstance
:rtype: twilio.rest.chat.v2.service.channel.webhook.WebhookInstance
"""
data = values.of({
'Type': type,
'Configuration.Url': configuration_url,
'Configuration.Method': configuration_method,
'Configuration.Filters': serialize.map(configuration_filters, lambda e: e),
'Configuration.Triggers': serialize.map(configuration_triggers, lambda e: e),
'Configuration.FlowSid': configuration_flow_sid,
'Configuration.RetryCount': configuration_retry_count,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return WebhookInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
channel_sid=self._solution['channel_sid'],
)
def create(self, type, configuration_url=values.unset,
configuration_method=values.unset,
configuration_filters=values.unset,
configuration_triggers=values.unset,
configuration_flow_sid=values.unset,
configuration_retry_count=values.unset):
"""
Create a new WebhookInstance
:param WebhookInstance.Type type: The type
:param unicode configuration_url: The configuration.url
:param WebhookInstance.Method configuration_method: The configuration.method
:param unicode configuration_filters: The configuration.filters
:param unicode configuration_triggers: The configuration.triggers
:param unicode configuration_flow_sid: The configuration.flow_sid
:param unicode configuration_retry_count: The configuration.retry_count
:returns: Newly created WebhookInstance
:rtype: twilio.rest.chat.v2.service.channel.webhook.WebhookInstance
"""
data = values.of({
'Type': type,
'Configuration.Url': configuration_url,
'Configuration.Method': configuration_method,
'Configuration.Filters': serialize.map(configuration_filters, lambda e: e),
'Configuration.Triggers': serialize.map(configuration_triggers, lambda e: e),
'Configuration.FlowSid': configuration_flow_sid,
'Configuration.RetryCount': configuration_retry_count,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return WebhookInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
channel_sid=self._solution['channel_sid'],
)
def create(self, friendly_name, enabled=values.unset, video_layout=values.unset,
audio_sources=values.unset, audio_sources_excluded=values.unset,
resolution=values.unset, format=values.unset,
status_callback=values.unset, status_callback_method=values.unset,
trim=values.unset):
"""
Create a new CompositionHookInstance
:param unicode friendly_name: Friendly name of the Composition Hook to be shown in the console.
:param bool enabled: Boolean flag indicating if the Composition Hook is active.
:param dict video_layout: The JSON video layout description.
:param unicode audio_sources: A list of audio sources related to this Composition Hook.
:param unicode audio_sources_excluded: A list of audio sources excluded related to this Composition Hook.
:param unicode resolution: Pixel resolution of the composed video.
:param CompositionHookInstance.Format format: Container format of the Composition Hook media file. Any of the following: `mp4`, `webm`.
:param unicode status_callback: A URL that Twilio sends asynchronous webhook requests to on every composition event.
:param unicode status_callback_method: HTTP method Twilio should use when requesting the above URL.
:param bool trim: Boolean flag for clipping intervals that have no media.
:returns: Newly created CompositionHookInstance
:rtype: twilio.rest.video.v1.composition_hook.CompositionHookInstance
"""
data = values.of({
'FriendlyName': friendly_name,
'Enabled': enabled,
'VideoLayout': serialize.object(video_layout),
'AudioSources': serialize.map(audio_sources, lambda e: e),
'AudioSourcesExcluded': serialize.map(audio_sources_excluded, lambda e: e),
'Resolution': resolution,
'Format': format,
'StatusCallback': status_callback,
'StatusCallbackMethod': status_callback_method,
'Trim': trim,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return CompositionHookInstance(self._version, payload, )
def page(self,
start_date=values.unset,
end_date=values.unset,
identity=values.unset,
tag=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of BindingInstance records from the API.
Request is executed immediately
:param date start_date: The start_date
:param date end_date: The end_date
:param unicode identity: The identity
:param unicode tag: The tag
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of BindingInstance
:rtype: twilio.rest.notify.v1.service.binding.BindingPage
"""
params = values.of({
'StartDate': serialize.iso8601_date(start_date),
'EndDate': serialize.iso8601_date(end_date),
'Identity': serialize.map(identity, lambda e: e),
'Tag': serialize.map(tag, lambda e: e),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return BindingPage(self._version, response, self._solution)
def create(self, audio_sources=values.unset, video_sources=values.unset,
video_layout=values.unset, resolution=values.unset,
format=values.unset, desired_bitrate=values.unset,
desired_max_duration=values.unset, status_callback=values.unset,
status_callback_method=values.unset):
"""
Create a new CompositionInstance
:param unicode audio_sources: The audio_sources
:param unicode video_sources: The video_sources
:param CompositionInstance.VideoLayout video_layout: The video_layout
:param unicode resolution: The resolution
:param CompositionInstance.Format format: The format
:param unicode desired_bitrate: The desired_bitrate
:param unicode desired_max_duration: The desired_max_duration
:param unicode status_callback: The status_callback
:param unicode status_callback_method: The status_callback_method
:returns: Newly created CompositionInstance
:rtype: twilio.rest.video.v1.composition.CompositionInstance
"""
data = values.of({
'AudioSources': serialize.map(audio_sources, lambda e: e),
'VideoSources': serialize.map(video_sources, lambda e: e),
'VideoLayout': video_layout,
'Resolution': resolution,
'Format': format,
'DesiredBitrate': desired_bitrate,
'DesiredMaxDuration': desired_max_duration,
'StatusCallback': status_callback,
'StatusCallbackMethod': status_callback_method,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return CompositionInstance(self._version, payload, )
def page(self,
start_date=values.unset,
end_date=values.unset,
identity=values.unset,
tag=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of BindingInstance records from the API.
Request is executed immediately
:param date start_date: Only include usage that has occurred on or after this date
:param date end_date: Only include usage that occurred on or before this date
:param unicode identity: The `identity` value of the resources to read
:param unicode tag: Only list Bindings that have all of the specified Tags
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of BindingInstance
:rtype: twilio.rest.notify.v1.service.binding.BindingPage
"""
data = values.of({
'StartDate': serialize.iso8601_date(start_date),
'EndDate': serialize.iso8601_date(end_date),
'Identity': serialize.map(identity, lambda e: e),
'Tag': serialize.map(tag, lambda e: e),
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
method='GET',
uri=self._uri,
params=data,
)
return BindingPage(self._version, response, self._solution)
def create(self, room_sid=values.unset, video_layout=values.unset,
audio_sources=values.unset, audio_sources_excluded=values.unset,
resolution=values.unset, format=values.unset,
status_callback=values.unset, status_callback_method=values.unset,
trim=values.unset):
"""
Create a new CompositionInstance
:param unicode room_sid: The room_sid
:param dict video_layout: The video_layout
:param unicode audio_sources: The audio_sources
:param unicode audio_sources_excluded: The audio_sources_excluded
:param unicode resolution: The resolution
:param CompositionInstance.Format format: The format
:param unicode status_callback: The status_callback
:param unicode status_callback_method: The status_callback_method
:param bool trim: The trim
:returns: Newly created CompositionInstance
:rtype: twilio.rest.video.v1.composition.CompositionInstance
"""
data = values.of({
'RoomSid': room_sid,
'VideoLayout': serialize.object(video_layout),
'AudioSources': serialize.map(audio_sources, lambda e: e),
'AudioSourcesExcluded': serialize.map(audio_sources_excluded, lambda e: e),
'Resolution': resolution,
'Format': format,
'StatusCallback': status_callback,
'StatusCallbackMethod': status_callback_method,
'Trim': trim,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return CompositionInstance(self._version, payload, )
def create(self, room_sid, video_layout=values.unset,
audio_sources=values.unset, audio_sources_excluded=values.unset,
resolution=values.unset, format=values.unset,
status_callback=values.unset, status_callback_method=values.unset,
trim=values.unset):
"""
Create a new CompositionInstance
:param unicode room_sid: The SID of the Group Room with the media tracks to be used as composition sources
:param dict video_layout: An object that describes the video layout of the composition
:param unicode audio_sources: An array of track names from the same group room to merge
:param unicode audio_sources_excluded: An array of track names to exclude
:param unicode resolution: A string that describes the columns (width) and rows (height) of the generated composed video in pixels
:param CompositionInstance.Format format: The container format of the composition's media files
:param unicode status_callback: The URL we should call to send status information to your application
:param unicode status_callback_method: The HTTP method we should use to call status_callback
:param bool trim: Whether to clip the intervals where there is no active media in the composition
:returns: Newly created CompositionInstance
:rtype: twilio.rest.video.v1.composition.CompositionInstance
"""
data = values.of({
'RoomSid': room_sid,
'VideoLayout': serialize.object(video_layout),
'AudioSources': serialize.map(audio_sources, lambda e: e),
'AudioSourcesExcluded': serialize.map(audio_sources_excluded, lambda e: e),
'Resolution': resolution,
'Format': format,
'StatusCallback': status_callback,
'StatusCallbackMethod': status_callback_method,
'Trim': trim,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return CompositionInstance(self._version, payload, )
def create(self, room_sid=values.unset, video_layout=values.unset,
audio_sources=values.unset, audio_sources_excluded=values.unset,
resolution=values.unset, format=values.unset,
status_callback=values.unset, status_callback_method=values.unset,
trim=values.unset):
"""
Create a new CompositionInstance
:param unicode room_sid: Twilio Room SID.
:param dict video_layout: The JSON video layout description.
:param unicode audio_sources: A list of audio sources related to this Composition.
:param unicode audio_sources_excluded: A list of audio sources excluded related to this Composition.
:param unicode resolution: Pixel resolution of the composed video.
:param CompositionInstance.Format format: ontainer format of the Composition media file. Any of the following: `mp4`, `webm`.
:param unicode status_callback: A URL that Twilio sends asynchronous webhook requests to on every composition event.
:param unicode status_callback_method: HTTP method Twilio should use when requesting the above URL.
:param bool trim: Boolean flag for clipping intervals that have no media.
:returns: Newly created CompositionInstance
:rtype: twilio.rest.video.v1.composition.CompositionInstance
"""
data = values.of({
'RoomSid': room_sid,
'VideoLayout': serialize.object(video_layout),
'AudioSources': serialize.map(audio_sources, lambda e: e),
'AudioSourcesExcluded': serialize.map(audio_sources_excluded, lambda e: e),
'Resolution': resolution,
'Format': format,
'StatusCallback': status_callback,
'StatusCallbackMethod': status_callback_method,
'Trim': trim,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return CompositionInstance(self._version, payload, )
def update(self,
friendly_name=values.unset,
unique_name=values.unset,
email=values.unset,
cc_emails=values.unset,
status=values.unset,
verification_code=values.unset,
verification_type=values.unset,
verification_document_sid=values.unset,
extension=values.unset,
call_delay=values.unset):
"""
Update the HostedNumberOrderInstance
:param unicode friendly_name: A human readable description of this resource.
:param unicode unique_name: A unique, developer assigned name of this HostedNumberOrder.
:param unicode email: Email.
:param unicode cc_emails: A list of emails.
:param HostedNumberOrderInstance.Status status: The Status of this HostedNumberOrder.
:param unicode verification_code: A verification code.
:param HostedNumberOrderInstance.VerificationType verification_type: Verification Type.
:param unicode verification_document_sid: Verification Document Sid
:param unicode extension: Digits to dial after connecting the verification call.
:param unicode call_delay: The number of seconds, between 0 and 60, to delay before initiating the verification call.
:returns: The updated HostedNumberOrderInstance
:rtype: twilio.rest.preview.hosted_numbers.hosted_number_order.HostedNumberOrderInstance
"""
data = values.of({
'FriendlyName': friendly_name,
'UniqueName': unique_name,
'Email': email,
'CcEmails': serialize.map(cc_emails, lambda e: e),
'Status': status,
'VerificationCode': verification_code,
'VerificationType': verification_type,
'VerificationDocumentSid': verification_document_sid,
'Extension': extension,
'CallDelay': call_delay,
})
payload = self._version.update(
method='POST',
uri=self._uri,
data=data,
)
return HostedNumberOrderInstance(
self._version,
payload,
sid=self._solution['sid'],
)
def create(self, to, status_callback=values.unset, application_sid=values.unset,
max_price=values.unset, provide_feedback=values.unset,
validity_period=values.unset, force_delivery=values.unset,
smart_encoded=values.unset, interactive_data=values.unset,
force_opt_in=values.unset, from_=values.unset,
messaging_service_sid=values.unset, body=values.unset,
media_url=values.unset):
"""
Create a new MessageInstance
:param unicode to: The destination phone number
:param unicode status_callback: The URL we should call to send status information to your application
:param unicode application_sid: The application to use for callbacks
:param unicode max_price: The total maximum price up to 4 decimal places in US dollars acceptable for the message to be delivered.
:param bool provide_feedback: Whether to confirm delivery of the message
:param unicode validity_period: The number of seconds that the message can remain in our outgoing queue.
:param bool force_delivery: Reserved
:param bool smart_encoded: Whether to detect Unicode characters that have a similar GSM-7 character and replace them
:param unicode interactive_data: A JSON string that represents an interactive message
:param bool force_opt_in: Whether to forcefully whitelist a from:to pair
:param unicode from_: The phone number that initiated the message
:param unicode messaging_service_sid: The SID of the Messaging Service you want to associate with the message.
:param unicode body: The text of the message you want to send. Can be up to 1,600 characters in length.
:param unicode media_url: The URL of the media to send with the message
:returns: Newly created MessageInstance
:rtype: twilio.rest.api.v2010.account.message.MessageInstance
"""
data = values.of({
'To': to,
'From': from_,
'MessagingServiceSid': messaging_service_sid,
'Body': body,
'MediaUrl': serialize.map(media_url, lambda e: e),
'StatusCallback': status_callback,
'ApplicationSid': application_sid,
'MaxPrice': max_price,
'ProvideFeedback': provide_feedback,
'ValidityPeriod': validity_period,
'ForceDelivery': force_delivery,
'SmartEncoded': smart_encoded,
'InteractiveData': interactive_data,
'ForceOptIn': force_opt_in,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return MessageInstance(self._version, payload, account_sid=self._solution['account_sid'], )
def create(self, to, status_callback=values.unset, application_sid=values.unset,
max_price=values.unset, provide_feedback=values.unset,
validity_period=values.unset, force_delivery=values.unset,
smart_encoded=values.unset, interactive_data=values.unset,
force_opt_in=values.unset, from_=values.unset,
messaging_service_sid=values.unset, body=values.unset,
media_url=values.unset):
"""
Create a new MessageInstance
:param unicode to: The destination phone number
:param unicode status_callback: The URL we should call to send status information to your application
:param unicode application_sid: The application to use for callbacks
:param unicode max_price: The total maximum price up to 4 decimal places in US dollars acceptable for the message to be delivered.
:param bool provide_feedback: Whether to confirm delivery of the message
:param unicode validity_period: The number of seconds that the message can remain in our outgoing queue.
:param bool force_delivery: Reserved
:param bool smart_encoded: Whether to detect Unicode characters that have a similar GSM-7 character and replace them
:param unicode interactive_data: A JSON string that represents an interactive message
:param bool force_opt_in: Whether to forcefully whitelist a from:to pair
:param unicode from_: The phone number that initiated the message
:param unicode messaging_service_sid: The SID of the Messaging Service you want to associate with the message.
:param unicode body: The text of the message you want to send. Can be up to 1,600 characters in length.
:param unicode media_url: The URL of the media to send with the message
:returns: Newly created MessageInstance
:rtype: twilio.rest.api.v2010.account.message.MessageInstance
"""
data = values.of({
'To': to,
'From': from_,
'MessagingServiceSid': messaging_service_sid,
'Body': body,
'MediaUrl': serialize.map(media_url, lambda e: e),
'StatusCallback': status_callback,
'ApplicationSid': application_sid,
'MaxPrice': max_price,
'ProvideFeedback': provide_feedback,
'ValidityPeriod': validity_period,
'ForceDelivery': force_delivery,
'SmartEncoded': smart_encoded,
'InteractiveData': interactive_data,
'ForceOptIn': force_opt_in,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return MessageInstance(self._version, payload, account_sid=self._solution['account_sid'], )
def page(self,
binding_type=values.unset,
identity=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of BindingInstance records from the API.
Request is executed immediately
:param list[BindingInstance.BindingType] binding_type: The push technology used by the Binding resources to read.
:param list[unicode] identity: The identity of Conversation User associated with this binding.
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of BindingInstance
:rtype: twilio.rest.conversations.v1.service.binding.BindingPage
"""
data = values.of({
'BindingType':
serialize.map(binding_type, lambda e: e),
'Identity':
serialize.map(identity, lambda e: e),
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
method='GET',
uri=self._uri,
params=data,
)
return BindingPage(self._version, response, self._solution)
def page(self,
binding_type=values.unset,
identity=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of BindingInstance records from the API.
Request is executed immediately
:param BindingInstance.BindingType binding_type: The push technology used by the Binding resources to read
:param unicode identity: The `identity` value of the resources to read
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of BindingInstance
:rtype: twilio.rest.chat.v2.service.binding.BindingPage
"""
params = values.of({
'BindingType':
serialize.map(binding_type, lambda e: e),
'Identity':
serialize.map(identity, lambda e: e),
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return BindingPage(self._version, response, self._solution)
def page(self,
status=values.unset,
source_sid=values.unset,
grouping_sid=values.unset,
date_created_after=values.unset,
date_created_before=values.unset,
page_token=values.unset,
page_number=values.unset,
page_size=values.unset):
"""
Retrieve a single page of RecordingInstance records from the API.
Request is executed immediately
:param RecordingInstance.Status status: Only show Recordings with the given status.
:param unicode source_sid: Only show the Recordings with the given source Sid.
:param unicode grouping_sid: Only show Recordings that have this GroupingSid.
:param datetime date_created_after: Only show Recordings that started on or after this ISO8601 date-time.
:param datetime date_created_before: Only show Recordings that started before this this ISO8601 date-time.
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of RecordingInstance
:rtype: twilio.rest.video.v1.recording.RecordingPage
"""
params = values.of({
'Status':
status,
'SourceSid':
source_sid,
'GroupingSid':
serialize.map(grouping_sid, lambda e: e),
'DateCreatedAfter':
serialize.iso8601_datetime(date_created_after),
'DateCreatedBefore':
serialize.iso8601_datetime(date_created_before),
'PageToken':
page_token,
'Page':
page_number,
'PageSize':
page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return RecordingPage(self._version, response, self._solution)
def create(self, target, configuration_url=values.unset,
configuration_method=values.unset,
configuration_filters=values.unset,
configuration_triggers=values.unset,
configuration_flow_sid=values.unset,
configuration_replay_after=values.unset):
"""
Create the WebhookInstance
:param WebhookInstance.Target target: The target of this webhook.
:param unicode configuration_url: The absolute url the webhook request should be sent to.
:param WebhookInstance.Method configuration_method: The HTTP method to be used when sending a webhook request.
:param list[unicode] configuration_filters: The list of events, firing webhook event for this Conversation.
:param list[unicode] configuration_triggers: The list of keywords, firing webhook event for this Conversation.
:param unicode configuration_flow_sid: The studio flow SID, where the webhook should be sent to.
:param unicode configuration_replay_after: The message index for which and it's successors the webhook will be replayed.
:returns: The created WebhookInstance
:rtype: twilio.rest.conversations.v1.service.conversation.webhook.WebhookInstance
"""
data = values.of({
'Target': target,
'Configuration.Url': configuration_url,
'Configuration.Method': configuration_method,
'Configuration.Filters': serialize.map(configuration_filters, lambda e: e),
'Configuration.Triggers': serialize.map(configuration_triggers, lambda e: e),
'Configuration.FlowSid': configuration_flow_sid,
'Configuration.ReplayAfter': configuration_replay_after,
})
payload = self._version.create(method='POST', uri=self._uri, data=data, )
return WebhookInstance(
self._version,
payload,
chat_service_sid=self._solution['chat_service_sid'],
conversation_sid=self._solution['conversation_sid'],
)
def create(self,
asset_versions=values.unset,
function_versions=values.unset,
dependencies=values.unset,
runtime=values.unset):
"""
Create the BuildInstance
:param list[unicode] asset_versions: The list of Asset Version resource SIDs to include in the Build
:param list[unicode] function_versions: The list of the Function Version resource SIDs to include in the Build
:param unicode dependencies: A list of objects that describe the Dependencies included in the Build
:param unicode runtime: The Runtime version that will be used to run the Build.
:returns: The created BuildInstance
:rtype: twilio.rest.serverless.v1.service.build.BuildInstance
"""
data = values.of({
'AssetVersions':
serialize.map(asset_versions, lambda e: e),
'FunctionVersions':
serialize.map(function_versions, lambda e: e),
'Dependencies':
dependencies,
'Runtime':
runtime,
})
payload = self._version.create(
method='POST',
uri=self._uri,
data=data,
)
return BuildInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
)
def create(self, type, configuration_url=values.unset,
configuration_method=values.unset,
configuration_filters=values.unset,
configuration_triggers=values.unset,
configuration_flow_sid=values.unset,
configuration_retry_count=values.unset):
"""
Create the WebhookInstance
:param WebhookInstance.Type type: The type
:param unicode configuration_url: The configuration.url
:param WebhookInstance.Method configuration_method: The configuration.method
:param list[unicode] configuration_filters: The configuration.filters
:param list[unicode] configuration_triggers: The configuration.triggers
:param unicode configuration_flow_sid: The configuration.flow_sid
:param unicode configuration_retry_count: The configuration.retry_count
:returns: The created WebhookInstance
:rtype: twilio.rest.ip_messaging.v2.service.channel.webhook.WebhookInstance
"""
data = values.of({
'Type': type,
'Configuration.Url': configuration_url,
'Configuration.Method': configuration_method,
'Configuration.Filters': serialize.map(configuration_filters, lambda e: e),
'Configuration.Triggers': serialize.map(configuration_triggers, lambda e: e),
'Configuration.FlowSid': configuration_flow_sid,
'Configuration.RetryCount': configuration_retry_count,
})
payload = self._version.create(method='POST', uri=self._uri, data=data, )
return WebhookInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
channel_sid=self._solution['channel_sid'],
)
def create(self, friendly_name, enabled=values.unset, video_layout=values.unset,
audio_sources=values.unset, audio_sources_excluded=values.unset,
resolution=values.unset, format=values.unset,
status_callback=values.unset, status_callback_method=values.unset,
trim=values.unset):
"""
Create the CompositionHookInstance
:param unicode friendly_name: A unique string to describe the resource
:param bool enabled: Whether the composition hook is active
:param dict video_layout: An object that describes the video layout of the composition hook
:param list[unicode] audio_sources: An array of track names from the same group room to merge
:param list[unicode] audio_sources_excluded: An array of track names to exclude
:param unicode resolution: A string that describes the rows (width) and columns (height) of the generated composed video in pixels
:param CompositionHookInstance.Format format: The container format of the media files used by the compositions created by the composition hook
:param unicode status_callback: The URL we should call to send status information to your application
:param unicode status_callback_method: The HTTP method we should use to call status_callback
:param bool trim: Whether to clip the intervals where there is no active media in the Compositions triggered by the composition hook
:returns: The created CompositionHookInstance
:rtype: twilio.rest.video.v1.composition_hook.CompositionHookInstance
"""
data = values.of({
'FriendlyName': friendly_name,
'Enabled': enabled,
'VideoLayout': serialize.object(video_layout),
'AudioSources': serialize.map(audio_sources, lambda e: e),
'AudioSourcesExcluded': serialize.map(audio_sources_excluded, lambda e: e),
'Resolution': resolution,
'Format': format,
'StatusCallback': status_callback,
'StatusCallbackMethod': status_callback_method,
'Trim': trim,
})
payload = self._version.create(method='POST', uri=self._uri, data=data, )
return CompositionHookInstance(self._version, payload, )
def create(self, type, configuration_url=values.unset,
configuration_method=values.unset,
configuration_filters=values.unset,
configuration_triggers=values.unset,
configuration_flow_sid=values.unset,
configuration_retry_count=values.unset):
"""
Create the WebhookInstance
:param WebhookInstance.Type type: The type of webhook
:param unicode configuration_url: The URL of the webhook to call
:param WebhookInstance.Method configuration_method: The HTTP method used to call `configuration.url`
:param list[unicode] configuration_filters: The events that cause us to call the Channel Webhook
:param list[unicode] configuration_triggers: A string that will cause us to call the webhook when it is found in a message body
:param unicode configuration_flow_sid: The SID of the Studio Flow to call when an event occurs
:param unicode configuration_retry_count: The number of times to retry the webhook if the first attempt fails
:returns: The created WebhookInstance
:rtype: twilio.rest.chat.v2.service.channel.webhook.WebhookInstance
"""
data = values.of({
'Type': type,
'Configuration.Url': configuration_url,
'Configuration.Method': configuration_method,
'Configuration.Filters': serialize.map(configuration_filters, lambda e: e),
'Configuration.Triggers': serialize.map(configuration_triggers, lambda e: e),
'Configuration.FlowSid': configuration_flow_sid,
'Configuration.RetryCount': configuration_retry_count,
})
payload = self._version.create(method='POST', uri=self._uri, data=data, )
return WebhookInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
channel_sid=self._solution['channel_sid'],
)
def test_update_request(self):
self.holodeck.mock(Response(500, ''))
with self.assertRaises(TwilioException):
self.client.ip_messaging.v2.services(sid="ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") \
.roles(sid="RLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").update(permission=['permission'])
values = {'Permission': serialize.map(['permission'], lambda e: e), }
self.holodeck.assert_has_request(Request(
'post',
'https://ip-messaging.twilio.com/v2/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Roles/RLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
data=values,
))
def update(self, test_users):
"""
Update the FlowTestUserInstance
:param list[unicode] test_users: List of test user identities that can test draft versions of the flow.
:returns: The updated FlowTestUserInstance
:rtype: twilio.rest.studio.v2.flow.test_user.FlowTestUserInstance
"""
data = values.of({'TestUsers': serialize.map(test_users, lambda e: e), })
payload = self._version.update(method='POST', uri=self._uri, data=data, )
return FlowTestUserInstance(self._version, payload, sid=self._solution['sid'], )
def fetch(self, country_code=values.unset, type=values.unset,
add_ons=values.unset, add_ons_data=values.unset):
"""
Fetch the PhoneNumberInstance
:param unicode country_code: The ISO country code of the phone number
:param unicode type: The type of information to return
:param unicode add_ons: The unique_name of an Add-on you would like to invoke
:param dict add_ons_data: Data specific to the add-on you would like to invoke
:returns: The fetched PhoneNumberInstance
:rtype: twilio.rest.lookups.v1.phone_number.PhoneNumberInstance
"""
data = values.of({
'CountryCode': country_code,
'Type': serialize.map(type, lambda e: e),
'AddOns': serialize.map(add_ons, lambda e: e),
})
data.update(serialize.prefixed_collapsible_map(add_ons_data, 'AddOns'))
payload = self._version.fetch(method='GET', uri=self._uri, params=data, )
return PhoneNumberInstance(self._version, payload, phone_number=self._solution['phone_number'], )
def update(self, permission):
"""
Update the RoleInstance
:param unicode permission: A permission the role should have
:returns: The updated RoleInstance
:rtype: twilio.rest.conversations.v1.role.RoleInstance
"""
data = values.of({'Permission': serialize.map(permission, lambda e: e), })
payload = self._version.update(method='POST', uri=self._uri, data=data, )
return RoleInstance(self._version, payload, sid=self._solution['sid'], )
def create(self,
unique_name=values.unset,
date_expiry=values.unset,
ttl=values.unset,
mode=values.unset,
status=values.unset,
participants=values.unset,
fail_on_participant_conflict=values.unset):
"""
Create the SessionInstance
:param unicode unique_name: An application-defined string that uniquely identifies the resource
:param datetime date_expiry: The ISO 8601 date when the Session should expire
:param unicode ttl: When the session will expire
:param SessionInstance.Mode mode: The Mode of the Session
:param SessionInstance.Status status: Session status
:param dict participants: The Participant objects to include in the new session
:param bool fail_on_participant_conflict: An experimental parameter to override the ProxyAllowParticipantConflict account flag on a per-request basis.
:returns: The created SessionInstance
:rtype: twilio.rest.proxy.v1.service.session.SessionInstance
"""
data = values.of({
'UniqueName':
unique_name,
'DateExpiry':
serialize.iso8601_datetime(date_expiry),
'Ttl':
ttl,
'Mode':
mode,
'Status':
status,
'Participants':
serialize.map(participants, lambda e: serialize.object(e)),
'FailOnParticipantConflict':
fail_on_participant_conflict,
})
payload = self._version.create(
method='POST',
uri=self._uri,
data=data,
)
return SessionInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
)
def test_update_request(self):
self.holodeck.mock(Response(500, ''))
with self.assertRaises(TwilioException):
self.client.chat.v1.services(sid="ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
.roles(sid="RLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").update(permission=['permission'])
values = {'Permission': serialize.map(['permission'], lambda e: e), }
self.holodeck.assert_has_request(Request(
'post',
'https://chat.twilio.com/v1/Services/ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Roles/RLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
data=values,
))
def create(self,
hosted_number_order_sids,
address_sid,
email,
cc_emails=values.unset):
"""
Create a new AuthorizationDocumentInstance
:param unicode hosted_number_order_sids: A list of HostedNumberOrder sids.
:param unicode address_sid: Address sid.
:param unicode email: Email.
:param unicode cc_emails: A list of emails.
:returns: Newly created AuthorizationDocumentInstance
:rtype: twilio.rest.preview.hosted_numbers.authorization_document.AuthorizationDocumentInstance
"""
data = values.of({
'HostedNumberOrderSids':
serialize.map(hosted_number_order_sids, lambda e: e),
'AddressSid':
address_sid,
'Email':
email,
'CcEmails':
serialize.map(cc_emails, lambda e: e),
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return AuthorizationDocumentInstance(
self._version,
payload,
)
def create(self,
factor_sid,
expiration_date=values.unset,
details_message=values.unset,
details_fields=values.unset,
hidden_details=values.unset,
twilio_sandbox_mode=values.unset):
"""
Create the ChallengeInstance
:param unicode factor_sid: Factor Sid.
:param datetime expiration_date: The future date in which this Challenge will expire
:param unicode details_message: Shown to the user when the push notification arrives
:param dict details_fields: A list of objects that describe the Fields included in the Challenge
:param dict hidden_details: Hidden details provided to contextualize the Challenge
:param unicode twilio_sandbox_mode: The Twilio-Sandbox-Mode HTTP request header
:returns: The created ChallengeInstance
:rtype: twilio.rest.verify.v2.service.entity.challenge.ChallengeInstance
"""
data = values.of({
'FactorSid':
factor_sid,
'ExpirationDate':
serialize.iso8601_datetime(expiration_date),
'Details.Message':
details_message,
'Details.Fields':
serialize.map(details_fields, lambda e: serialize.object(e)),
'HiddenDetails':
serialize.object(hidden_details),
})
headers = values.of({
'Twilio-Sandbox-Mode': twilio_sandbox_mode,
})
payload = self._version.create(
method='POST',
uri=self._uri,
data=data,
headers=headers,
)
return ChallengeInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
identity=self._solution['identity'],
)
def update(self,
webhook_method=values.unset,
webhook_filters=values.unset,
pre_webhook_url=values.unset,
post_webhook_url=values.unset,
pre_webhook_retry_count=values.unset,
post_webhook_retry_count=values.unset,
target=values.unset):
"""
Update the WebhookInstance
:param unicode webhook_method: The HTTP method to use when sending a webhook request
:param unicode webhook_filters: The list of webhook event triggers that are enabled for the Service
:param unicode pre_webhook_url: The absolute URL of the pre-event webhook
:param unicode post_webhook_url: The absolute URL of the post-event webhook
:param unicode pre_webhook_retry_count: The number of times to try the pre-event webhook request if the first attempt fails
:param unicode post_webhook_retry_count: The number of times to try the post-event webhook request if the first attempt fails
:param WebhookInstance.Target target: The routing target of the webhook
:returns: Updated WebhookInstance
:rtype: twilio.rest.messaging.v1.webhook.WebhookInstance
"""
data = values.of({
'WebhookMethod':
webhook_method,
'WebhookFilters':
serialize.map(webhook_filters, lambda e: e),
'PreWebhookUrl':
pre_webhook_url,
'PostWebhookUrl':
post_webhook_url,
'PreWebhookRetryCount':
pre_webhook_retry_count,
'PostWebhookRetryCount':
post_webhook_retry_count,
'Target':
target,
})
payload = self._version.update(
'POST',
self._uri,
data=data,
)
return WebhookInstance(
self._version,
payload,
)
def page(self, priority=values.unset, assignment_status=values.unset,
workflow_sid=values.unset, workflow_name=values.unset,
task_queue_sid=values.unset, task_queue_name=values.unset,
evaluate_task_attributes=values.unset, ordering=values.unset,
has_addons=values.unset, page_token=values.unset,
page_number=values.unset, page_size=values.unset):
"""
Retrieve a single page of TaskInstance records from the API.
Request is executed immediately
:param unicode priority: Retrieve the list of all Tasks in the workspace with the specified priority.
:param unicode assignment_status: Returns the list of all Tasks in the workspace with the specified AssignmentStatus.
:param unicode workflow_sid: Returns the list of Tasks that are being controlled by the Workflow with the specified Sid value.
:param unicode workflow_name: Returns the list of Tasks that are being controlled by the Workflow with the specified FriendlyName value.
:param unicode task_queue_sid: Returns the list of Tasks that are currently waiting in the TaskQueue identified by the Sid specified.
:param unicode task_queue_name: Returns the list of Tasks that are currently waiting in the TaskQueue identified by the FriendlyName specified.
:param unicode evaluate_task_attributes: Provide a task attributes expression, and this will return tasks which match the attributes.
:param unicode ordering: Use this parameter to control the order of the Tasks returned.
:param bool has_addons: The has_addons
:param str page_token: PageToken provided by the API
:param int page_number: Page Number, this value is simply for client state
:param int page_size: Number of records to return, defaults to 50
:returns: Page of TaskInstance
:rtype: twilio.rest.taskrouter.v1.workspace.task.TaskPage
"""
params = values.of({
'Priority': priority,
'AssignmentStatus': serialize.map(assignment_status, lambda e: e),
'WorkflowSid': workflow_sid,
'WorkflowName': workflow_name,
'TaskQueueSid': task_queue_sid,
'TaskQueueName': task_queue_name,
'EvaluateTaskAttributes': evaluate_task_attributes,
'Ordering': ordering,
'HasAddons': has_addons,
'PageToken': page_token,
'Page': page_number,
'PageSize': page_size,
})
response = self._version.page(
'GET',
self._uri,
params=params,
)
return TaskPage(self._version, response, self._solution)
def create(self,
recording_status_callback_event=values.unset,
recording_status_callback=values.unset,
recording_status_callback_method=values.unset,
trim=values.unset,
recording_channels=values.unset,
play_beep=values.unset):
"""
Create a new RecordingInstance
:param unicode recording_status_callback_event: The recording_status_callback_event
:param unicode recording_status_callback: The recording_status_callback
:param unicode recording_status_callback_method: The recording_status_callback_method
:param unicode trim: Whether to trim the silence in the recording
:param unicode recording_channels: The recording_channels
:param bool play_beep: Whether to play beeps for recording status changes
:returns: Newly created RecordingInstance
:rtype: twilio.rest.api.v2010.account.call.recording.RecordingInstance
"""
data = values.of({
'RecordingStatusCallbackEvent':
serialize.map(recording_status_callback_event, lambda e: e),
'RecordingStatusCallback':
recording_status_callback,
'RecordingStatusCallbackMethod':
recording_status_callback_method,
'Trim':
trim,
'RecordingChannels':
recording_channels,
'PlayBeep':
play_beep,
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return RecordingInstance(
self._version,
payload,
account_sid=self._solution['account_sid'],
call_sid=self._solution['call_sid'],
)
def update(self,
unique_name=values.unset,
date_expiry=values.unset,
ttl=values.unset,
mode=values.unset,
status=values.unset,
participants=values.unset):
"""
Update the SessionInstance
:param unicode unique_name: A unique, developer assigned name of this Session.
:param datetime date_expiry: The date this Session was expiry
:param unicode ttl: TTL for a Session, in seconds.
:param SessionInstance.Mode mode: The Mode of this Session
:param SessionInstance.Status status: The Status of this Session
:param dict participants: A list of phone numbers to add to this Session.
:returns: Updated SessionInstance
:rtype: twilio.rest.proxy.v1.service.session.SessionInstance
"""
data = values.of({
'UniqueName':
unique_name,
'DateExpiry':
serialize.iso8601_datetime(date_expiry),
'Ttl':
ttl,
'Mode':
mode,
'Status':
status,
'Participants':
serialize.map(participants, lambda e: serialize.object(e)),
})
payload = self._version.update(
'POST',
self._uri,
data=data,
)
return SessionInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
sid=self._solution['sid'],
)
def create(self,
recording_status_callback_event=values.unset,
recording_status_callback=values.unset,
recording_status_callback_method=values.unset,
trim=values.unset,
recording_channels=values.unset,
recording_track=values.unset):
"""
Create the RecordingInstance
:param list[unicode] recording_status_callback_event: The recording status changes that should generate a callback
:param unicode recording_status_callback: The callback URL on each selected recording event
:param unicode recording_status_callback_method: The HTTP method we should use to call `recording_status_callback`
:param unicode trim: Whether to trim the silence in the recording
:param unicode recording_channels: The number of channels that the output recording will be configured with
:param unicode recording_track: Which track(s) to record
:returns: The created RecordingInstance
:rtype: twilio.rest.api.v2010.account.call.recording.RecordingInstance
"""
data = values.of({
'RecordingStatusCallbackEvent':
serialize.map(recording_status_callback_event, lambda e: e),
'RecordingStatusCallback':
recording_status_callback,
'RecordingStatusCallbackMethod':
recording_status_callback_method,
'Trim':
trim,
'RecordingChannels':
recording_channels,
'RecordingTrack':
recording_track,
})
payload = self._version.create(
method='POST',
uri=self._uri,
data=data,
)
return RecordingInstance(
self._version,
payload,
account_sid=self._solution['account_sid'],
call_sid=self._solution['call_sid'],
)
def test_create_request(self):
self.holodeck.mock(Response(500, ''))
with self.assertRaises(TwilioException):
self.client.events.v1.subscriptions.create(description="description", sink_sid="DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", types=[{}])
values = {
'Description': "description",
'SinkSid': "DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
'Types': serialize.map([{}], lambda e: serialize.object(e)),
}
self.holodeck.assert_has_request(Request(
'post',
'https://events.twilio.com/v1/Subscriptions',
data=values,
))
def create(self,
unique_name=values.unset,
date_expiry=values.unset,
ttl=values.unset,
mode=values.unset,
status=values.unset,
participants=values.unset):
"""
Create a new SessionInstance
:param unicode unique_name: An application-defined string that uniquely identifies the resource
:param datetime date_expiry: The ISO 8601 date when the Session should expire
:param unicode ttl: When the session will expire
:param SessionInstance.Mode mode: The Mode of the Session
:param SessionInstance.Status status: Session status
:param dict participants: The Participant objects to include in the new session
:returns: Newly created SessionInstance
:rtype: twilio.rest.proxy.v1.service.session.SessionInstance
"""
data = values.of({
'UniqueName':
unique_name,
'DateExpiry':
serialize.iso8601_datetime(date_expiry),
'Ttl':
ttl,
'Mode':
mode,
'Status':
status,
'Participants':
serialize.map(participants, lambda e: serialize.object(e)),
})
payload = self._version.create(
'POST',
self._uri,
data=data,
)
return SessionInstance(
self._version,
payload,
service_sid=self._solution['service_sid'],
)
