def add_params(self, params):
for key, value in six.iteritems(params):
if value is None:
continue
self._write(self.param_header())
self._write(self.line_break)
if hasattr(value, "read"):
filename = "blob"
if hasattr(value, "name"):
# Convert the filename to string, just in case it's not
# already one. E.g. `tempfile.TemporaryFile` has a `name`
# attribute but it's an `int`.
filename = str(value.name)
self._write('Content-Disposition: form-data; name="')
self._write(key)
self._write('"; filename="')
self._write(filename)
self._write('"')
self._write(self.line_break)
self._write("Content-Type: application/octet-stream")
self._write(self.line_break)
self._write(self.line_break)
self._write_file(value)
else:
self._write('Content-Disposition: form-data; name="')
self._write(key)
self._write('"')
self._write(self.line_break)
self._write(self.line_break)
self._write(value)
self._write(self.line_break)
def refresh_from(self,
values,
api_key=None,
partial=False,
last_response=None):
self.api_key = api_key or getattr(values, "api_key", None)
self._last_response = last_response or getattr(values,
"_last_response", None)
# Wipe old state before setting new.
if partial:
self._unsaved_values = self._unsaved_values - set(values)
else:
removed = set(self.keys()) - set(values)
self._transient_values = self._transient_values | removed
self._unsaved_values = set()
self.clear()
self._transient_values = self._transient_values - set(values)
for k, v in six.iteritems(values):
super(TelnyxObject,
self).__setitem__(k,
util.convert_to_telnyx_object(v, api_key))
self._previous = values
def request(self, method, url, headers, post_data=None):
if six.PY3 and isinstance(post_data, six.string_types):
post_data = post_data.encode("utf-8")
req = urllib.request.Request(url, post_data, headers)
if method not in ("get", "post"):
req.get_method = lambda: method.upper()
try:
# use the custom proxy tied opener, if any.
# otherwise, fall to the default urllib opener.
response = (
self._opener.open(req) if self._opener else urllib.request.urlopen(req)
)
rbody = response.read()
rcode = response.code
headers = dict(response.info())
except urllib.error.HTTPError as e:
rcode = e.code
rbody = e.read()
headers = dict(e.info())
except (urllib.error.URLError, ValueError) as e:
self._handle_request_error(e)
lh = dict((k.lower(), v) for k, v in six.iteritems(dict(headers)))
return rbody, rcode, lh
def prepare_raw_request(self,
method,
url,
params=None,
supplied_headers=None):
if self.api_key:
my_api_key = self.api_key
else:
from telnyx import api_key
my_api_key = api_key
if supplied_headers is None:
supplied_headers = {}
if my_api_key is None:
raise error.AuthenticationError(
"No API key provided. (HINT: set your API key using "
'"telnyx.api_key = <API-KEY>"). You can generate API keys '
"from the Telnyx web interface. See https://developers.telnyx.com/docs/v2/development/authentication "
"for details, or email [email protected] if you have any "
"questions.")
abs_url = "%s%s" % (self.api_base, url)
if method == "get" or method == "head" or method == "delete":
encoded_params = self.build_query_params(params)
if params:
abs_url = self.build_api_url(abs_url, encoded_params)
post_data = None
elif method == "post" or method == "patch":
if (supplied_headers.get(
"Content-Type", "application/json") == "application/json"):
encoded_params = json.dumps(params or {})
post_data = encoded_params
elif supplied_headers.get("Content-Type",
None) == "multipart/form-data":
generator = MultipartDataGenerator()
generator.add_params(params or {})
post_data = generator.get_post_data()
encoded_params = params
supplied_headers[
"Content-Type"] = "multipart/form-data; boundary=%s" % (
generator.boundary, )
else:
raise error.APIConnectionError(
"Unrecognized HTTP method %r. This may indicate a bug in the "
"Telnyx bindings. Please contact [email protected] for "
"assistance." % (method, ))
headers = self.request_headers(my_api_key, method)
if supplied_headers is not None:
for key, value in six.iteritems(supplied_headers):
headers[key] = value
util.log_info("Request to Telnyx api", method=method, path=abs_url)
util.log_debug("Post details", post_data=encoded_params)
return abs_url, headers, post_data, my_api_key
def request(self, method, url, headers, post_data=None):
b = util.io.BytesIO()
rheaders = util.io.BytesIO()
# Pycurl's design is a little weird: although we set per-request
# options on this object, it's also capable of maintaining established
# connections. Here we call reset() between uses to make sure it's in a
# pristine state, but notably reset() doesn't reset connections, so we
# still get to take advantage of those by virtue of re-using the same
# object.
self._curl.reset()
proxy = self._get_proxy(url)
if proxy:
if proxy.hostname:
self._curl.setopt(pycurl.PROXY, proxy.hostname)
if proxy.port:
self._curl.setopt(pycurl.PROXYPORT, proxy.port)
if proxy.username or proxy.password:
self._curl.setopt(
pycurl.PROXYUSERPWD, "%s:%s" % (proxy.username, proxy.password)
)
if method == "get":
self._curl.setopt(pycurl.HTTPGET, 1)
elif method == "post":
self._curl.setopt(pycurl.POST, 1)
self._curl.setopt(pycurl.POSTFIELDS, post_data)
else:
self._curl.setopt(pycurl.CUSTOMREQUEST, method.upper())
# pycurl doesn't like unicode URLs
self._curl.setopt(pycurl.URL, util.utf8(url))
self._curl.setopt(pycurl.WRITEFUNCTION, b.write)
self._curl.setopt(pycurl.HEADERFUNCTION, rheaders.write)
self._curl.setopt(pycurl.NOSIGNAL, 1)
self._curl.setopt(pycurl.CONNECTTIMEOUT, 30)
self._curl.setopt(pycurl.TIMEOUT, 80)
self._curl.setopt(
pycurl.HTTPHEADER,
["%s: %s" % (k, v) for k, v in six.iteritems(dict(headers))],
)
if self._verify_ssl_certs:
self._curl.setopt(pycurl.SSL_VERIFYHOST, True)
else:
self._curl.setopt(pycurl.SSL_VERIFYHOST, False)
try:
self._curl.perform()
except pycurl.error as e:
self._handle_request_error(e)
rbody = b.getvalue().decode("utf-8")
rcode = self._curl.getinfo(pycurl.RESPONSE_CODE)
headers = self.parse_headers(rheaders.getvalue().decode("utf-8"))
return rbody, rcode, headers
def __deepcopy__(self, memo):
copied = self.__copy__()
memo[id(self)] = copied
for k, v in six.iteritems(self):
# Call parent's __setitem__ to avoid checks that we've added in the
# overridden version that can throw exceptions.
super(TelnyxObject, copied).__setitem__(k, deepcopy(v, memo))
return copied
def test_param_encoding(self, requestor, mock_response, check_call):
mock_response("{}", 200)
requestor.request("get", "", self.ENCODE_INPUTS)
expectation = []
for type_, values in six.iteritems(self.ENCODE_EXPECTATIONS):
expectation.extend([(k % (type_,), str(v)) for k, v in values])
check_call("get", QueryMatcher(expectation))
def __copy__(self):
copied = TelnyxObject(self.get("id"), self.api_key)
copied._retrieve_params = self._retrieve_params
for k, v in six.iteritems(self):
# Call parent's __setitem__ to avoid checks that we've added in the
# overridden version that can throw exceptions.
super(TelnyxObject, copied).__setitem__(k, v)
return copied
def serialize(self, previous):
params = {}
unsaved_keys = self._unsaved_values or set()
previous = previous or self._previous or {}
for k, v in six.iteritems(self):
if k == "id" or (isinstance(k, str) and k.startswith("_")):
continue
elif isinstance(v, telnyx.api_resources.abstract.APIResource):
continue
elif hasattr(v, "serialize"):
child = v.serialize(previous.get(k, None))
if child != {}:
params[k] = child
elif k in unsaved_keys:
params[k] = _compute_diff(v, previous.get(k, None))
elif k == "additional_owners" and v is not None:
params[k] = _serialize_list(v, previous.get(k, None))
return params
def _api_encode(data):
for key, value in six.iteritems(data):
key = util.utf8(key)
if value is None:
continue
elif isinstance(value, list) or isinstance(value, tuple):
for sv in value:
if isinstance(sv, dict):
subdict = _encode_nested_dict("%s[]" % key, sv)
for k, v in _api_encode(subdict):
yield (k, v)
else:
yield ("%s[]" % key, util.utf8(sv))
elif isinstance(value, dict):
subdict = _encode_nested_dict(key, value)
for subkey, subvalue in _api_encode(subdict):
yield (subkey, subvalue)
elif isinstance(value, datetime.datetime):
yield (key, _encode_datetime(value))
else:
yield (key, util.utf8(value))
def _encode_nested_dict(key, data, fmt="%s[%s]"):
d = {}
for subkey, subvalue in six.iteritems(data):
d[fmt % (key, subkey)] = subvalue
return d
def to_dict_recursive(self):
d = dict(self)
for k, v in six.iteritems(d):
if isinstance(v, TelnyxObject):
d[k] = v.to_dict_recursive()
return d
def parse_headers(self, data):
if "\r\n" not in data:
return {}
raw_headers = data.split("\r\n", 1)[1]
headers = email.message_from_string(raw_headers)
return dict((k.lower(), v) for k, v in six.iteritems(dict(headers)))
def _extra_match(self, other):
for k, v in six.iteritems(self.extra):
if other[k] != v:
return False
return True