repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
tornadoweb/tornado
|
tornado/iostream.py
|
_StreamBuffer.peek
|
def peek(self, size: int) -> memoryview:
"""
Get a view over at most ``size`` bytes (possibly fewer) at the
current buffer position.
"""
assert size > 0
try:
is_memview, b = self._buffers[0]
except IndexError:
return memoryview(b"")
pos = self._first_pos
if is_memview:
return typing.cast(memoryview, b[pos : pos + size])
else:
return memoryview(b)[pos : pos + size]
|
python
|
def peek(self, size: int) -> memoryview:
"""
Get a view over at most ``size`` bytes (possibly fewer) at the
current buffer position.
"""
assert size > 0
try:
is_memview, b = self._buffers[0]
except IndexError:
return memoryview(b"")
pos = self._first_pos
if is_memview:
return typing.cast(memoryview, b[pos : pos + size])
else:
return memoryview(b)[pos : pos + size]
|
[
"def",
"peek",
"(",
"self",
",",
"size",
":",
"int",
")",
"->",
"memoryview",
":",
"assert",
"size",
">",
"0",
"try",
":",
"is_memview",
",",
"b",
"=",
"self",
".",
"_buffers",
"[",
"0",
"]",
"except",
"IndexError",
":",
"return",
"memoryview",
"(",
"b\"\"",
")",
"pos",
"=",
"self",
".",
"_first_pos",
"if",
"is_memview",
":",
"return",
"typing",
".",
"cast",
"(",
"memoryview",
",",
"b",
"[",
"pos",
":",
"pos",
"+",
"size",
"]",
")",
"else",
":",
"return",
"memoryview",
"(",
"b",
")",
"[",
"pos",
":",
"pos",
"+",
"size",
"]"
] |
Get a view over at most ``size`` bytes (possibly fewer) at the
current buffer position.
|
[
"Get",
"a",
"view",
"over",
"at",
"most",
"size",
"bytes",
"(",
"possibly",
"fewer",
")",
"at",
"the",
"current",
"buffer",
"position",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L181-L196
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
_StreamBuffer.advance
|
def advance(self, size: int) -> None:
"""
Advance the current buffer position by ``size`` bytes.
"""
assert 0 < size <= self._size
self._size -= size
pos = self._first_pos
buffers = self._buffers
while buffers and size > 0:
is_large, b = buffers[0]
b_remain = len(b) - size - pos
if b_remain <= 0:
buffers.popleft()
size -= len(b) - pos
pos = 0
elif is_large:
pos += size
size = 0
else:
# Amortized O(1) shrink for Python 2
pos += size
if len(b) <= 2 * pos:
del typing.cast(bytearray, b)[:pos]
pos = 0
size = 0
assert size == 0
self._first_pos = pos
|
python
|
def advance(self, size: int) -> None:
"""
Advance the current buffer position by ``size`` bytes.
"""
assert 0 < size <= self._size
self._size -= size
pos = self._first_pos
buffers = self._buffers
while buffers and size > 0:
is_large, b = buffers[0]
b_remain = len(b) - size - pos
if b_remain <= 0:
buffers.popleft()
size -= len(b) - pos
pos = 0
elif is_large:
pos += size
size = 0
else:
# Amortized O(1) shrink for Python 2
pos += size
if len(b) <= 2 * pos:
del typing.cast(bytearray, b)[:pos]
pos = 0
size = 0
assert size == 0
self._first_pos = pos
|
[
"def",
"advance",
"(",
"self",
",",
"size",
":",
"int",
")",
"->",
"None",
":",
"assert",
"0",
"<",
"size",
"<=",
"self",
".",
"_size",
"self",
".",
"_size",
"-=",
"size",
"pos",
"=",
"self",
".",
"_first_pos",
"buffers",
"=",
"self",
".",
"_buffers",
"while",
"buffers",
"and",
"size",
">",
"0",
":",
"is_large",
",",
"b",
"=",
"buffers",
"[",
"0",
"]",
"b_remain",
"=",
"len",
"(",
"b",
")",
"-",
"size",
"-",
"pos",
"if",
"b_remain",
"<=",
"0",
":",
"buffers",
".",
"popleft",
"(",
")",
"size",
"-=",
"len",
"(",
"b",
")",
"-",
"pos",
"pos",
"=",
"0",
"elif",
"is_large",
":",
"pos",
"+=",
"size",
"size",
"=",
"0",
"else",
":",
"# Amortized O(1) shrink for Python 2",
"pos",
"+=",
"size",
"if",
"len",
"(",
"b",
")",
"<=",
"2",
"*",
"pos",
":",
"del",
"typing",
".",
"cast",
"(",
"bytearray",
",",
"b",
")",
"[",
":",
"pos",
"]",
"pos",
"=",
"0",
"size",
"=",
"0",
"assert",
"size",
"==",
"0",
"self",
".",
"_first_pos",
"=",
"pos"
] |
Advance the current buffer position by ``size`` bytes.
|
[
"Advance",
"the",
"current",
"buffer",
"position",
"by",
"size",
"bytes",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L198-L226
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream.read_until_regex
|
def read_until_regex(self, regex: bytes, max_bytes: int = None) -> Awaitable[bytes]:
"""Asynchronously read until we have matched the given regex.
The result includes the data that matches the regex and anything
that came before it.
If ``max_bytes`` is not None, the connection will be closed
if more than ``max_bytes`` bytes have been read and the regex is
not satisfied.
.. versionchanged:: 4.0
Added the ``max_bytes`` argument. The ``callback`` argument is
now optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
self._read_regex = re.compile(regex)
self._read_max_bytes = max_bytes
try:
self._try_inline_read()
except UnsatisfiableReadError as e:
# Handle this the same way as in _handle_events.
gen_log.info("Unsatisfiable read, closing connection: %s" % e)
self.close(exc_info=e)
return future
except:
# Ensure that the future doesn't log an error because its
# failure was never examined.
future.add_done_callback(lambda f: f.exception())
raise
return future
|
python
|
def read_until_regex(self, regex: bytes, max_bytes: int = None) -> Awaitable[bytes]:
"""Asynchronously read until we have matched the given regex.
The result includes the data that matches the regex and anything
that came before it.
If ``max_bytes`` is not None, the connection will be closed
if more than ``max_bytes`` bytes have been read and the regex is
not satisfied.
.. versionchanged:: 4.0
Added the ``max_bytes`` argument. The ``callback`` argument is
now optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
self._read_regex = re.compile(regex)
self._read_max_bytes = max_bytes
try:
self._try_inline_read()
except UnsatisfiableReadError as e:
# Handle this the same way as in _handle_events.
gen_log.info("Unsatisfiable read, closing connection: %s" % e)
self.close(exc_info=e)
return future
except:
# Ensure that the future doesn't log an error because its
# failure was never examined.
future.add_done_callback(lambda f: f.exception())
raise
return future
|
[
"def",
"read_until_regex",
"(",
"self",
",",
"regex",
":",
"bytes",
",",
"max_bytes",
":",
"int",
"=",
"None",
")",
"->",
"Awaitable",
"[",
"bytes",
"]",
":",
"future",
"=",
"self",
".",
"_start_read",
"(",
")",
"self",
".",
"_read_regex",
"=",
"re",
".",
"compile",
"(",
"regex",
")",
"self",
".",
"_read_max_bytes",
"=",
"max_bytes",
"try",
":",
"self",
".",
"_try_inline_read",
"(",
")",
"except",
"UnsatisfiableReadError",
"as",
"e",
":",
"# Handle this the same way as in _handle_events.",
"gen_log",
".",
"info",
"(",
"\"Unsatisfiable read, closing connection: %s\"",
"%",
"e",
")",
"self",
".",
"close",
"(",
"exc_info",
"=",
"e",
")",
"return",
"future",
"except",
":",
"# Ensure that the future doesn't log an error because its",
"# failure was never examined.",
"future",
".",
"add_done_callback",
"(",
"lambda",
"f",
":",
"f",
".",
"exception",
"(",
")",
")",
"raise",
"return",
"future"
] |
Asynchronously read until we have matched the given regex.
The result includes the data that matches the regex and anything
that came before it.
If ``max_bytes`` is not None, the connection will be closed
if more than ``max_bytes`` bytes have been read and the regex is
not satisfied.
.. versionchanged:: 4.0
Added the ``max_bytes`` argument. The ``callback`` argument is
now optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
|
[
"Asynchronously",
"read",
"until",
"we",
"have",
"matched",
"the",
"given",
"regex",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L349-L384
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream.read_until
|
def read_until(self, delimiter: bytes, max_bytes: int = None) -> Awaitable[bytes]:
"""Asynchronously read until we have found the given delimiter.
The result includes all the data read including the delimiter.
If ``max_bytes`` is not None, the connection will be closed
if more than ``max_bytes`` bytes have been read and the delimiter
is not found.
.. versionchanged:: 4.0
Added the ``max_bytes`` argument. The ``callback`` argument is
now optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
self._read_delimiter = delimiter
self._read_max_bytes = max_bytes
try:
self._try_inline_read()
except UnsatisfiableReadError as e:
# Handle this the same way as in _handle_events.
gen_log.info("Unsatisfiable read, closing connection: %s" % e)
self.close(exc_info=e)
return future
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
|
python
|
def read_until(self, delimiter: bytes, max_bytes: int = None) -> Awaitable[bytes]:
"""Asynchronously read until we have found the given delimiter.
The result includes all the data read including the delimiter.
If ``max_bytes`` is not None, the connection will be closed
if more than ``max_bytes`` bytes have been read and the delimiter
is not found.
.. versionchanged:: 4.0
Added the ``max_bytes`` argument. The ``callback`` argument is
now optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
self._read_delimiter = delimiter
self._read_max_bytes = max_bytes
try:
self._try_inline_read()
except UnsatisfiableReadError as e:
# Handle this the same way as in _handle_events.
gen_log.info("Unsatisfiable read, closing connection: %s" % e)
self.close(exc_info=e)
return future
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
|
[
"def",
"read_until",
"(",
"self",
",",
"delimiter",
":",
"bytes",
",",
"max_bytes",
":",
"int",
"=",
"None",
")",
"->",
"Awaitable",
"[",
"bytes",
"]",
":",
"future",
"=",
"self",
".",
"_start_read",
"(",
")",
"self",
".",
"_read_delimiter",
"=",
"delimiter",
"self",
".",
"_read_max_bytes",
"=",
"max_bytes",
"try",
":",
"self",
".",
"_try_inline_read",
"(",
")",
"except",
"UnsatisfiableReadError",
"as",
"e",
":",
"# Handle this the same way as in _handle_events.",
"gen_log",
".",
"info",
"(",
"\"Unsatisfiable read, closing connection: %s\"",
"%",
"e",
")",
"self",
".",
"close",
"(",
"exc_info",
"=",
"e",
")",
"return",
"future",
"except",
":",
"future",
".",
"add_done_callback",
"(",
"lambda",
"f",
":",
"f",
".",
"exception",
"(",
")",
")",
"raise",
"return",
"future"
] |
Asynchronously read until we have found the given delimiter.
The result includes all the data read including the delimiter.
If ``max_bytes`` is not None, the connection will be closed
if more than ``max_bytes`` bytes have been read and the delimiter
is not found.
.. versionchanged:: 4.0
Added the ``max_bytes`` argument. The ``callback`` argument is
now optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
|
[
"Asynchronously",
"read",
"until",
"we",
"have",
"found",
"the",
"given",
"delimiter",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L386-L417
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream.read_bytes
|
def read_bytes(self, num_bytes: int, partial: bool = False) -> Awaitable[bytes]:
"""Asynchronously read a number of bytes.
If ``partial`` is true, data is returned as soon as we have
any bytes to return (but never more than ``num_bytes``)
.. versionchanged:: 4.0
Added the ``partial`` argument. The callback argument is now
optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` and ``streaming_callback`` arguments have
been removed. Use the returned `.Future` (and
``partial=True`` for ``streaming_callback``) instead.
"""
future = self._start_read()
assert isinstance(num_bytes, numbers.Integral)
self._read_bytes = num_bytes
self._read_partial = partial
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
|
python
|
def read_bytes(self, num_bytes: int, partial: bool = False) -> Awaitable[bytes]:
"""Asynchronously read a number of bytes.
If ``partial`` is true, data is returned as soon as we have
any bytes to return (but never more than ``num_bytes``)
.. versionchanged:: 4.0
Added the ``partial`` argument. The callback argument is now
optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` and ``streaming_callback`` arguments have
been removed. Use the returned `.Future` (and
``partial=True`` for ``streaming_callback``) instead.
"""
future = self._start_read()
assert isinstance(num_bytes, numbers.Integral)
self._read_bytes = num_bytes
self._read_partial = partial
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
|
[
"def",
"read_bytes",
"(",
"self",
",",
"num_bytes",
":",
"int",
",",
"partial",
":",
"bool",
"=",
"False",
")",
"->",
"Awaitable",
"[",
"bytes",
"]",
":",
"future",
"=",
"self",
".",
"_start_read",
"(",
")",
"assert",
"isinstance",
"(",
"num_bytes",
",",
"numbers",
".",
"Integral",
")",
"self",
".",
"_read_bytes",
"=",
"num_bytes",
"self",
".",
"_read_partial",
"=",
"partial",
"try",
":",
"self",
".",
"_try_inline_read",
"(",
")",
"except",
":",
"future",
".",
"add_done_callback",
"(",
"lambda",
"f",
":",
"f",
".",
"exception",
"(",
")",
")",
"raise",
"return",
"future"
] |
Asynchronously read a number of bytes.
If ``partial`` is true, data is returned as soon as we have
any bytes to return (but never more than ``num_bytes``)
.. versionchanged:: 4.0
Added the ``partial`` argument. The callback argument is now
optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` and ``streaming_callback`` arguments have
been removed. Use the returned `.Future` (and
``partial=True`` for ``streaming_callback``) instead.
|
[
"Asynchronously",
"read",
"a",
"number",
"of",
"bytes",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L419-L445
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream.read_into
|
def read_into(self, buf: bytearray, partial: bool = False) -> Awaitable[int]:
"""Asynchronously read a number of bytes.
``buf`` must be a writable buffer into which data will be read.
If ``partial`` is true, the callback is run as soon as any bytes
have been read. Otherwise, it is run when the ``buf`` has been
entirely filled with read data.
.. versionadded:: 5.0
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
# First copy data already in read buffer
available_bytes = self._read_buffer_size
n = len(buf)
if available_bytes >= n:
end = self._read_buffer_pos + n
buf[:] = memoryview(self._read_buffer)[self._read_buffer_pos : end]
del self._read_buffer[:end]
self._after_user_read_buffer = self._read_buffer
elif available_bytes > 0:
buf[:available_bytes] = memoryview(self._read_buffer)[
self._read_buffer_pos :
]
# Set up the supplied buffer as our temporary read buffer.
# The original (if it had any data remaining) has been
# saved for later.
self._user_read_buffer = True
self._read_buffer = buf
self._read_buffer_pos = 0
self._read_buffer_size = available_bytes
self._read_bytes = n
self._read_partial = partial
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
|
python
|
def read_into(self, buf: bytearray, partial: bool = False) -> Awaitable[int]:
"""Asynchronously read a number of bytes.
``buf`` must be a writable buffer into which data will be read.
If ``partial`` is true, the callback is run as soon as any bytes
have been read. Otherwise, it is run when the ``buf`` has been
entirely filled with read data.
.. versionadded:: 5.0
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
# First copy data already in read buffer
available_bytes = self._read_buffer_size
n = len(buf)
if available_bytes >= n:
end = self._read_buffer_pos + n
buf[:] = memoryview(self._read_buffer)[self._read_buffer_pos : end]
del self._read_buffer[:end]
self._after_user_read_buffer = self._read_buffer
elif available_bytes > 0:
buf[:available_bytes] = memoryview(self._read_buffer)[
self._read_buffer_pos :
]
# Set up the supplied buffer as our temporary read buffer.
# The original (if it had any data remaining) has been
# saved for later.
self._user_read_buffer = True
self._read_buffer = buf
self._read_buffer_pos = 0
self._read_buffer_size = available_bytes
self._read_bytes = n
self._read_partial = partial
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
|
[
"def",
"read_into",
"(",
"self",
",",
"buf",
":",
"bytearray",
",",
"partial",
":",
"bool",
"=",
"False",
")",
"->",
"Awaitable",
"[",
"int",
"]",
":",
"future",
"=",
"self",
".",
"_start_read",
"(",
")",
"# First copy data already in read buffer",
"available_bytes",
"=",
"self",
".",
"_read_buffer_size",
"n",
"=",
"len",
"(",
"buf",
")",
"if",
"available_bytes",
">=",
"n",
":",
"end",
"=",
"self",
".",
"_read_buffer_pos",
"+",
"n",
"buf",
"[",
":",
"]",
"=",
"memoryview",
"(",
"self",
".",
"_read_buffer",
")",
"[",
"self",
".",
"_read_buffer_pos",
":",
"end",
"]",
"del",
"self",
".",
"_read_buffer",
"[",
":",
"end",
"]",
"self",
".",
"_after_user_read_buffer",
"=",
"self",
".",
"_read_buffer",
"elif",
"available_bytes",
">",
"0",
":",
"buf",
"[",
":",
"available_bytes",
"]",
"=",
"memoryview",
"(",
"self",
".",
"_read_buffer",
")",
"[",
"self",
".",
"_read_buffer_pos",
":",
"]",
"# Set up the supplied buffer as our temporary read buffer.",
"# The original (if it had any data remaining) has been",
"# saved for later.",
"self",
".",
"_user_read_buffer",
"=",
"True",
"self",
".",
"_read_buffer",
"=",
"buf",
"self",
".",
"_read_buffer_pos",
"=",
"0",
"self",
".",
"_read_buffer_size",
"=",
"available_bytes",
"self",
".",
"_read_bytes",
"=",
"n",
"self",
".",
"_read_partial",
"=",
"partial",
"try",
":",
"self",
".",
"_try_inline_read",
"(",
")",
"except",
":",
"future",
".",
"add_done_callback",
"(",
"lambda",
"f",
":",
"f",
".",
"exception",
"(",
")",
")",
"raise",
"return",
"future"
] |
Asynchronously read a number of bytes.
``buf`` must be a writable buffer into which data will be read.
If ``partial`` is true, the callback is run as soon as any bytes
have been read. Otherwise, it is run when the ``buf`` has been
entirely filled with read data.
.. versionadded:: 5.0
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
|
[
"Asynchronously",
"read",
"a",
"number",
"of",
"bytes",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L447-L494
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream.read_until_close
|
def read_until_close(self) -> Awaitable[bytes]:
"""Asynchronously reads all data from the socket until it is closed.
This will buffer all available data until ``max_buffer_size``
is reached. If flow control or cancellation are desired, use a
loop with `read_bytes(partial=True) <.read_bytes>` instead.
.. versionchanged:: 4.0
The callback argument is now optional and a `.Future` will
be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` and ``streaming_callback`` arguments have
been removed. Use the returned `.Future` (and `read_bytes`
with ``partial=True`` for ``streaming_callback``) instead.
"""
future = self._start_read()
if self.closed():
self._finish_read(self._read_buffer_size, False)
return future
self._read_until_close = True
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
|
python
|
def read_until_close(self) -> Awaitable[bytes]:
"""Asynchronously reads all data from the socket until it is closed.
This will buffer all available data until ``max_buffer_size``
is reached. If flow control or cancellation are desired, use a
loop with `read_bytes(partial=True) <.read_bytes>` instead.
.. versionchanged:: 4.0
The callback argument is now optional and a `.Future` will
be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` and ``streaming_callback`` arguments have
been removed. Use the returned `.Future` (and `read_bytes`
with ``partial=True`` for ``streaming_callback``) instead.
"""
future = self._start_read()
if self.closed():
self._finish_read(self._read_buffer_size, False)
return future
self._read_until_close = True
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
|
[
"def",
"read_until_close",
"(",
"self",
")",
"->",
"Awaitable",
"[",
"bytes",
"]",
":",
"future",
"=",
"self",
".",
"_start_read",
"(",
")",
"if",
"self",
".",
"closed",
"(",
")",
":",
"self",
".",
"_finish_read",
"(",
"self",
".",
"_read_buffer_size",
",",
"False",
")",
"return",
"future",
"self",
".",
"_read_until_close",
"=",
"True",
"try",
":",
"self",
".",
"_try_inline_read",
"(",
")",
"except",
":",
"future",
".",
"add_done_callback",
"(",
"lambda",
"f",
":",
"f",
".",
"exception",
"(",
")",
")",
"raise",
"return",
"future"
] |
Asynchronously reads all data from the socket until it is closed.
This will buffer all available data until ``max_buffer_size``
is reached. If flow control or cancellation are desired, use a
loop with `read_bytes(partial=True) <.read_bytes>` instead.
.. versionchanged:: 4.0
The callback argument is now optional and a `.Future` will
be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` and ``streaming_callback`` arguments have
been removed. Use the returned `.Future` (and `read_bytes`
with ``partial=True`` for ``streaming_callback``) instead.
|
[
"Asynchronously",
"reads",
"all",
"data",
"from",
"the",
"socket",
"until",
"it",
"is",
"closed",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L496-L524
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream.write
|
def write(self, data: Union[bytes, memoryview]) -> "Future[None]":
"""Asynchronously write the given data to this stream.
This method returns a `.Future` that resolves (with a result
of ``None``) when the write has been completed.
The ``data`` argument may be of type `bytes` or `memoryview`.
.. versionchanged:: 4.0
Now returns a `.Future` if no callback is given.
.. versionchanged:: 4.5
Added support for `memoryview` arguments.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
self._check_closed()
if data:
if (
self.max_write_buffer_size is not None
and len(self._write_buffer) + len(data) > self.max_write_buffer_size
):
raise StreamBufferFullError("Reached maximum write buffer size")
self._write_buffer.append(data)
self._total_write_index += len(data)
future = Future() # type: Future[None]
future.add_done_callback(lambda f: f.exception())
self._write_futures.append((self._total_write_index, future))
if not self._connecting:
self._handle_write()
if self._write_buffer:
self._add_io_state(self.io_loop.WRITE)
self._maybe_add_error_listener()
return future
|
python
|
def write(self, data: Union[bytes, memoryview]) -> "Future[None]":
"""Asynchronously write the given data to this stream.
This method returns a `.Future` that resolves (with a result
of ``None``) when the write has been completed.
The ``data`` argument may be of type `bytes` or `memoryview`.
.. versionchanged:: 4.0
Now returns a `.Future` if no callback is given.
.. versionchanged:: 4.5
Added support for `memoryview` arguments.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
self._check_closed()
if data:
if (
self.max_write_buffer_size is not None
and len(self._write_buffer) + len(data) > self.max_write_buffer_size
):
raise StreamBufferFullError("Reached maximum write buffer size")
self._write_buffer.append(data)
self._total_write_index += len(data)
future = Future() # type: Future[None]
future.add_done_callback(lambda f: f.exception())
self._write_futures.append((self._total_write_index, future))
if not self._connecting:
self._handle_write()
if self._write_buffer:
self._add_io_state(self.io_loop.WRITE)
self._maybe_add_error_listener()
return future
|
[
"def",
"write",
"(",
"self",
",",
"data",
":",
"Union",
"[",
"bytes",
",",
"memoryview",
"]",
")",
"->",
"\"Future[None]\"",
":",
"self",
".",
"_check_closed",
"(",
")",
"if",
"data",
":",
"if",
"(",
"self",
".",
"max_write_buffer_size",
"is",
"not",
"None",
"and",
"len",
"(",
"self",
".",
"_write_buffer",
")",
"+",
"len",
"(",
"data",
")",
">",
"self",
".",
"max_write_buffer_size",
")",
":",
"raise",
"StreamBufferFullError",
"(",
"\"Reached maximum write buffer size\"",
")",
"self",
".",
"_write_buffer",
".",
"append",
"(",
"data",
")",
"self",
".",
"_total_write_index",
"+=",
"len",
"(",
"data",
")",
"future",
"=",
"Future",
"(",
")",
"# type: Future[None]",
"future",
".",
"add_done_callback",
"(",
"lambda",
"f",
":",
"f",
".",
"exception",
"(",
")",
")",
"self",
".",
"_write_futures",
".",
"append",
"(",
"(",
"self",
".",
"_total_write_index",
",",
"future",
")",
")",
"if",
"not",
"self",
".",
"_connecting",
":",
"self",
".",
"_handle_write",
"(",
")",
"if",
"self",
".",
"_write_buffer",
":",
"self",
".",
"_add_io_state",
"(",
"self",
".",
"io_loop",
".",
"WRITE",
")",
"self",
".",
"_maybe_add_error_listener",
"(",
")",
"return",
"future"
] |
Asynchronously write the given data to this stream.
This method returns a `.Future` that resolves (with a result
of ``None``) when the write has been completed.
The ``data`` argument may be of type `bytes` or `memoryview`.
.. versionchanged:: 4.0
Now returns a `.Future` if no callback is given.
.. versionchanged:: 4.5
Added support for `memoryview` arguments.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
|
[
"Asynchronously",
"write",
"the",
"given",
"data",
"to",
"this",
"stream",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L526-L563
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream.set_close_callback
|
def set_close_callback(self, callback: Optional[Callable[[], None]]) -> None:
"""Call the given callback when the stream is closed.
This mostly is not necessary for applications that use the
`.Future` interface; all outstanding ``Futures`` will resolve
with a `StreamClosedError` when the stream is closed. However,
it is still useful as a way to signal that the stream has been
closed while no other read or write is in progress.
Unlike other callback-based interfaces, ``set_close_callback``
was not removed in Tornado 6.0.
"""
self._close_callback = callback
self._maybe_add_error_listener()
|
python
|
def set_close_callback(self, callback: Optional[Callable[[], None]]) -> None:
"""Call the given callback when the stream is closed.
This mostly is not necessary for applications that use the
`.Future` interface; all outstanding ``Futures`` will resolve
with a `StreamClosedError` when the stream is closed. However,
it is still useful as a way to signal that the stream has been
closed while no other read or write is in progress.
Unlike other callback-based interfaces, ``set_close_callback``
was not removed in Tornado 6.0.
"""
self._close_callback = callback
self._maybe_add_error_listener()
|
[
"def",
"set_close_callback",
"(",
"self",
",",
"callback",
":",
"Optional",
"[",
"Callable",
"[",
"[",
"]",
",",
"None",
"]",
"]",
")",
"->",
"None",
":",
"self",
".",
"_close_callback",
"=",
"callback",
"self",
".",
"_maybe_add_error_listener",
"(",
")"
] |
Call the given callback when the stream is closed.
This mostly is not necessary for applications that use the
`.Future` interface; all outstanding ``Futures`` will resolve
with a `StreamClosedError` when the stream is closed. However,
it is still useful as a way to signal that the stream has been
closed while no other read or write is in progress.
Unlike other callback-based interfaces, ``set_close_callback``
was not removed in Tornado 6.0.
|
[
"Call",
"the",
"given",
"callback",
"when",
"the",
"stream",
"is",
"closed",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L565-L578
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream.close
|
def close(
self,
exc_info: Union[
None,
bool,
BaseException,
Tuple[
"Optional[Type[BaseException]]",
Optional[BaseException],
Optional[TracebackType],
],
] = False,
) -> None:
"""Close this stream.
If ``exc_info`` is true, set the ``error`` attribute to the current
exception from `sys.exc_info` (or if ``exc_info`` is a tuple,
use that instead of `sys.exc_info`).
"""
if not self.closed():
if exc_info:
if isinstance(exc_info, tuple):
self.error = exc_info[1]
elif isinstance(exc_info, BaseException):
self.error = exc_info
else:
exc_info = sys.exc_info()
if any(exc_info):
self.error = exc_info[1]
if self._read_until_close:
self._read_until_close = False
self._finish_read(self._read_buffer_size, False)
if self._state is not None:
self.io_loop.remove_handler(self.fileno())
self._state = None
self.close_fd()
self._closed = True
self._signal_closed()
|
python
|
def close(
self,
exc_info: Union[
None,
bool,
BaseException,
Tuple[
"Optional[Type[BaseException]]",
Optional[BaseException],
Optional[TracebackType],
],
] = False,
) -> None:
"""Close this stream.
If ``exc_info`` is true, set the ``error`` attribute to the current
exception from `sys.exc_info` (or if ``exc_info`` is a tuple,
use that instead of `sys.exc_info`).
"""
if not self.closed():
if exc_info:
if isinstance(exc_info, tuple):
self.error = exc_info[1]
elif isinstance(exc_info, BaseException):
self.error = exc_info
else:
exc_info = sys.exc_info()
if any(exc_info):
self.error = exc_info[1]
if self._read_until_close:
self._read_until_close = False
self._finish_read(self._read_buffer_size, False)
if self._state is not None:
self.io_loop.remove_handler(self.fileno())
self._state = None
self.close_fd()
self._closed = True
self._signal_closed()
|
[
"def",
"close",
"(",
"self",
",",
"exc_info",
":",
"Union",
"[",
"None",
",",
"bool",
",",
"BaseException",
",",
"Tuple",
"[",
"\"Optional[Type[BaseException]]\"",
",",
"Optional",
"[",
"BaseException",
"]",
",",
"Optional",
"[",
"TracebackType",
"]",
",",
"]",
",",
"]",
"=",
"False",
",",
")",
"->",
"None",
":",
"if",
"not",
"self",
".",
"closed",
"(",
")",
":",
"if",
"exc_info",
":",
"if",
"isinstance",
"(",
"exc_info",
",",
"tuple",
")",
":",
"self",
".",
"error",
"=",
"exc_info",
"[",
"1",
"]",
"elif",
"isinstance",
"(",
"exc_info",
",",
"BaseException",
")",
":",
"self",
".",
"error",
"=",
"exc_info",
"else",
":",
"exc_info",
"=",
"sys",
".",
"exc_info",
"(",
")",
"if",
"any",
"(",
"exc_info",
")",
":",
"self",
".",
"error",
"=",
"exc_info",
"[",
"1",
"]",
"if",
"self",
".",
"_read_until_close",
":",
"self",
".",
"_read_until_close",
"=",
"False",
"self",
".",
"_finish_read",
"(",
"self",
".",
"_read_buffer_size",
",",
"False",
")",
"if",
"self",
".",
"_state",
"is",
"not",
"None",
":",
"self",
".",
"io_loop",
".",
"remove_handler",
"(",
"self",
".",
"fileno",
"(",
")",
")",
"self",
".",
"_state",
"=",
"None",
"self",
".",
"close_fd",
"(",
")",
"self",
".",
"_closed",
"=",
"True",
"self",
".",
"_signal_closed",
"(",
")"
] |
Close this stream.
If ``exc_info`` is true, set the ``error`` attribute to the current
exception from `sys.exc_info` (or if ``exc_info`` is a tuple,
use that instead of `sys.exc_info`).
|
[
"Close",
"this",
"stream",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L580-L617
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream._try_inline_read
|
def _try_inline_read(self) -> None:
"""Attempt to complete the current read operation from buffered data.
If the read can be completed without blocking, schedules the
read callback on the next IOLoop iteration; otherwise starts
listening for reads on the socket.
"""
# See if we've already got the data from a previous read
pos = self._find_read_pos()
if pos is not None:
self._read_from_buffer(pos)
return
self._check_closed()
pos = self._read_to_buffer_loop()
if pos is not None:
self._read_from_buffer(pos)
return
# We couldn't satisfy the read inline, so make sure we're
# listening for new data unless the stream is closed.
if not self.closed():
self._add_io_state(ioloop.IOLoop.READ)
|
python
|
def _try_inline_read(self) -> None:
"""Attempt to complete the current read operation from buffered data.
If the read can be completed without blocking, schedules the
read callback on the next IOLoop iteration; otherwise starts
listening for reads on the socket.
"""
# See if we've already got the data from a previous read
pos = self._find_read_pos()
if pos is not None:
self._read_from_buffer(pos)
return
self._check_closed()
pos = self._read_to_buffer_loop()
if pos is not None:
self._read_from_buffer(pos)
return
# We couldn't satisfy the read inline, so make sure we're
# listening for new data unless the stream is closed.
if not self.closed():
self._add_io_state(ioloop.IOLoop.READ)
|
[
"def",
"_try_inline_read",
"(",
"self",
")",
"->",
"None",
":",
"# See if we've already got the data from a previous read",
"pos",
"=",
"self",
".",
"_find_read_pos",
"(",
")",
"if",
"pos",
"is",
"not",
"None",
":",
"self",
".",
"_read_from_buffer",
"(",
"pos",
")",
"return",
"self",
".",
"_check_closed",
"(",
")",
"pos",
"=",
"self",
".",
"_read_to_buffer_loop",
"(",
")",
"if",
"pos",
"is",
"not",
"None",
":",
"self",
".",
"_read_from_buffer",
"(",
"pos",
")",
"return",
"# We couldn't satisfy the read inline, so make sure we're",
"# listening for new data unless the stream is closed.",
"if",
"not",
"self",
".",
"closed",
"(",
")",
":",
"self",
".",
"_add_io_state",
"(",
"ioloop",
".",
"IOLoop",
".",
"READ",
")"
] |
Attempt to complete the current read operation from buffered data.
If the read can be completed without blocking, schedules the
read callback on the next IOLoop iteration; otherwise starts
listening for reads on the socket.
|
[
"Attempt",
"to",
"complete",
"the",
"current",
"read",
"operation",
"from",
"buffered",
"data",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L817-L837
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream._read_to_buffer
|
def _read_to_buffer(self) -> Optional[int]:
"""Reads from the socket and appends the result to the read buffer.
Returns the number of bytes read. Returns 0 if there is nothing
to read (i.e. the read returns EWOULDBLOCK or equivalent). On
error closes the socket and raises an exception.
"""
try:
while True:
try:
if self._user_read_buffer:
buf = memoryview(self._read_buffer)[
self._read_buffer_size :
] # type: Union[memoryview, bytearray]
else:
buf = bytearray(self.read_chunk_size)
bytes_read = self.read_from_fd(buf)
except (socket.error, IOError, OSError) as e:
if errno_from_exception(e) == errno.EINTR:
continue
# ssl.SSLError is a subclass of socket.error
if self._is_connreset(e):
# Treat ECONNRESET as a connection close rather than
# an error to minimize log spam (the exception will
# be available on self.error for apps that care).
self.close(exc_info=e)
return None
self.close(exc_info=e)
raise
break
if bytes_read is None:
return 0
elif bytes_read == 0:
self.close()
return 0
if not self._user_read_buffer:
self._read_buffer += memoryview(buf)[:bytes_read]
self._read_buffer_size += bytes_read
finally:
# Break the reference to buf so we don't waste a chunk's worth of
# memory in case an exception hangs on to our stack frame.
del buf
if self._read_buffer_size > self.max_buffer_size:
gen_log.error("Reached maximum read buffer size")
self.close()
raise StreamBufferFullError("Reached maximum read buffer size")
return bytes_read
|
python
|
def _read_to_buffer(self) -> Optional[int]:
"""Reads from the socket and appends the result to the read buffer.
Returns the number of bytes read. Returns 0 if there is nothing
to read (i.e. the read returns EWOULDBLOCK or equivalent). On
error closes the socket and raises an exception.
"""
try:
while True:
try:
if self._user_read_buffer:
buf = memoryview(self._read_buffer)[
self._read_buffer_size :
] # type: Union[memoryview, bytearray]
else:
buf = bytearray(self.read_chunk_size)
bytes_read = self.read_from_fd(buf)
except (socket.error, IOError, OSError) as e:
if errno_from_exception(e) == errno.EINTR:
continue
# ssl.SSLError is a subclass of socket.error
if self._is_connreset(e):
# Treat ECONNRESET as a connection close rather than
# an error to minimize log spam (the exception will
# be available on self.error for apps that care).
self.close(exc_info=e)
return None
self.close(exc_info=e)
raise
break
if bytes_read is None:
return 0
elif bytes_read == 0:
self.close()
return 0
if not self._user_read_buffer:
self._read_buffer += memoryview(buf)[:bytes_read]
self._read_buffer_size += bytes_read
finally:
# Break the reference to buf so we don't waste a chunk's worth of
# memory in case an exception hangs on to our stack frame.
del buf
if self._read_buffer_size > self.max_buffer_size:
gen_log.error("Reached maximum read buffer size")
self.close()
raise StreamBufferFullError("Reached maximum read buffer size")
return bytes_read
|
[
"def",
"_read_to_buffer",
"(",
"self",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"try",
":",
"while",
"True",
":",
"try",
":",
"if",
"self",
".",
"_user_read_buffer",
":",
"buf",
"=",
"memoryview",
"(",
"self",
".",
"_read_buffer",
")",
"[",
"self",
".",
"_read_buffer_size",
":",
"]",
"# type: Union[memoryview, bytearray]",
"else",
":",
"buf",
"=",
"bytearray",
"(",
"self",
".",
"read_chunk_size",
")",
"bytes_read",
"=",
"self",
".",
"read_from_fd",
"(",
"buf",
")",
"except",
"(",
"socket",
".",
"error",
",",
"IOError",
",",
"OSError",
")",
"as",
"e",
":",
"if",
"errno_from_exception",
"(",
"e",
")",
"==",
"errno",
".",
"EINTR",
":",
"continue",
"# ssl.SSLError is a subclass of socket.error",
"if",
"self",
".",
"_is_connreset",
"(",
"e",
")",
":",
"# Treat ECONNRESET as a connection close rather than",
"# an error to minimize log spam (the exception will",
"# be available on self.error for apps that care).",
"self",
".",
"close",
"(",
"exc_info",
"=",
"e",
")",
"return",
"None",
"self",
".",
"close",
"(",
"exc_info",
"=",
"e",
")",
"raise",
"break",
"if",
"bytes_read",
"is",
"None",
":",
"return",
"0",
"elif",
"bytes_read",
"==",
"0",
":",
"self",
".",
"close",
"(",
")",
"return",
"0",
"if",
"not",
"self",
".",
"_user_read_buffer",
":",
"self",
".",
"_read_buffer",
"+=",
"memoryview",
"(",
"buf",
")",
"[",
":",
"bytes_read",
"]",
"self",
".",
"_read_buffer_size",
"+=",
"bytes_read",
"finally",
":",
"# Break the reference to buf so we don't waste a chunk's worth of",
"# memory in case an exception hangs on to our stack frame.",
"del",
"buf",
"if",
"self",
".",
"_read_buffer_size",
">",
"self",
".",
"max_buffer_size",
":",
"gen_log",
".",
"error",
"(",
"\"Reached maximum read buffer size\"",
")",
"self",
".",
"close",
"(",
")",
"raise",
"StreamBufferFullError",
"(",
"\"Reached maximum read buffer size\"",
")",
"return",
"bytes_read"
] |
Reads from the socket and appends the result to the read buffer.
Returns the number of bytes read. Returns 0 if there is nothing
to read (i.e. the read returns EWOULDBLOCK or equivalent). On
error closes the socket and raises an exception.
|
[
"Reads",
"from",
"the",
"socket",
"and",
"appends",
"the",
"result",
"to",
"the",
"read",
"buffer",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L839-L885
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream._read_from_buffer
|
def _read_from_buffer(self, pos: int) -> None:
"""Attempts to complete the currently-pending read from the buffer.
The argument is either a position in the read buffer or None,
as returned by _find_read_pos.
"""
self._read_bytes = self._read_delimiter = self._read_regex = None
self._read_partial = False
self._finish_read(pos, False)
|
python
|
def _read_from_buffer(self, pos: int) -> None:
"""Attempts to complete the currently-pending read from the buffer.
The argument is either a position in the read buffer or None,
as returned by _find_read_pos.
"""
self._read_bytes = self._read_delimiter = self._read_regex = None
self._read_partial = False
self._finish_read(pos, False)
|
[
"def",
"_read_from_buffer",
"(",
"self",
",",
"pos",
":",
"int",
")",
"->",
"None",
":",
"self",
".",
"_read_bytes",
"=",
"self",
".",
"_read_delimiter",
"=",
"self",
".",
"_read_regex",
"=",
"None",
"self",
".",
"_read_partial",
"=",
"False",
"self",
".",
"_finish_read",
"(",
"pos",
",",
"False",
")"
] |
Attempts to complete the currently-pending read from the buffer.
The argument is either a position in the read buffer or None,
as returned by _find_read_pos.
|
[
"Attempts",
"to",
"complete",
"the",
"currently",
"-",
"pending",
"read",
"from",
"the",
"buffer",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L887-L895
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream._find_read_pos
|
def _find_read_pos(self) -> Optional[int]:
"""Attempts to find a position in the read buffer that satisfies
the currently-pending read.
Returns a position in the buffer if the current read can be satisfied,
or None if it cannot.
"""
if self._read_bytes is not None and (
self._read_buffer_size >= self._read_bytes
or (self._read_partial and self._read_buffer_size > 0)
):
num_bytes = min(self._read_bytes, self._read_buffer_size)
return num_bytes
elif self._read_delimiter is not None:
# Multi-byte delimiters (e.g. '\r\n') may straddle two
# chunks in the read buffer, so we can't easily find them
# without collapsing the buffer. However, since protocols
# using delimited reads (as opposed to reads of a known
# length) tend to be "line" oriented, the delimiter is likely
# to be in the first few chunks. Merge the buffer gradually
# since large merges are relatively expensive and get undone in
# _consume().
if self._read_buffer:
loc = self._read_buffer.find(
self._read_delimiter, self._read_buffer_pos
)
if loc != -1:
loc -= self._read_buffer_pos
delimiter_len = len(self._read_delimiter)
self._check_max_bytes(self._read_delimiter, loc + delimiter_len)
return loc + delimiter_len
self._check_max_bytes(self._read_delimiter, self._read_buffer_size)
elif self._read_regex is not None:
if self._read_buffer:
m = self._read_regex.search(self._read_buffer, self._read_buffer_pos)
if m is not None:
loc = m.end() - self._read_buffer_pos
self._check_max_bytes(self._read_regex, loc)
return loc
self._check_max_bytes(self._read_regex, self._read_buffer_size)
return None
|
python
|
def _find_read_pos(self) -> Optional[int]:
"""Attempts to find a position in the read buffer that satisfies
the currently-pending read.
Returns a position in the buffer if the current read can be satisfied,
or None if it cannot.
"""
if self._read_bytes is not None and (
self._read_buffer_size >= self._read_bytes
or (self._read_partial and self._read_buffer_size > 0)
):
num_bytes = min(self._read_bytes, self._read_buffer_size)
return num_bytes
elif self._read_delimiter is not None:
# Multi-byte delimiters (e.g. '\r\n') may straddle two
# chunks in the read buffer, so we can't easily find them
# without collapsing the buffer. However, since protocols
# using delimited reads (as opposed to reads of a known
# length) tend to be "line" oriented, the delimiter is likely
# to be in the first few chunks. Merge the buffer gradually
# since large merges are relatively expensive and get undone in
# _consume().
if self._read_buffer:
loc = self._read_buffer.find(
self._read_delimiter, self._read_buffer_pos
)
if loc != -1:
loc -= self._read_buffer_pos
delimiter_len = len(self._read_delimiter)
self._check_max_bytes(self._read_delimiter, loc + delimiter_len)
return loc + delimiter_len
self._check_max_bytes(self._read_delimiter, self._read_buffer_size)
elif self._read_regex is not None:
if self._read_buffer:
m = self._read_regex.search(self._read_buffer, self._read_buffer_pos)
if m is not None:
loc = m.end() - self._read_buffer_pos
self._check_max_bytes(self._read_regex, loc)
return loc
self._check_max_bytes(self._read_regex, self._read_buffer_size)
return None
|
[
"def",
"_find_read_pos",
"(",
"self",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"if",
"self",
".",
"_read_bytes",
"is",
"not",
"None",
"and",
"(",
"self",
".",
"_read_buffer_size",
">=",
"self",
".",
"_read_bytes",
"or",
"(",
"self",
".",
"_read_partial",
"and",
"self",
".",
"_read_buffer_size",
">",
"0",
")",
")",
":",
"num_bytes",
"=",
"min",
"(",
"self",
".",
"_read_bytes",
",",
"self",
".",
"_read_buffer_size",
")",
"return",
"num_bytes",
"elif",
"self",
".",
"_read_delimiter",
"is",
"not",
"None",
":",
"# Multi-byte delimiters (e.g. '\\r\\n') may straddle two",
"# chunks in the read buffer, so we can't easily find them",
"# without collapsing the buffer. However, since protocols",
"# using delimited reads (as opposed to reads of a known",
"# length) tend to be \"line\" oriented, the delimiter is likely",
"# to be in the first few chunks. Merge the buffer gradually",
"# since large merges are relatively expensive and get undone in",
"# _consume().",
"if",
"self",
".",
"_read_buffer",
":",
"loc",
"=",
"self",
".",
"_read_buffer",
".",
"find",
"(",
"self",
".",
"_read_delimiter",
",",
"self",
".",
"_read_buffer_pos",
")",
"if",
"loc",
"!=",
"-",
"1",
":",
"loc",
"-=",
"self",
".",
"_read_buffer_pos",
"delimiter_len",
"=",
"len",
"(",
"self",
".",
"_read_delimiter",
")",
"self",
".",
"_check_max_bytes",
"(",
"self",
".",
"_read_delimiter",
",",
"loc",
"+",
"delimiter_len",
")",
"return",
"loc",
"+",
"delimiter_len",
"self",
".",
"_check_max_bytes",
"(",
"self",
".",
"_read_delimiter",
",",
"self",
".",
"_read_buffer_size",
")",
"elif",
"self",
".",
"_read_regex",
"is",
"not",
"None",
":",
"if",
"self",
".",
"_read_buffer",
":",
"m",
"=",
"self",
".",
"_read_regex",
".",
"search",
"(",
"self",
".",
"_read_buffer",
",",
"self",
".",
"_read_buffer_pos",
")",
"if",
"m",
"is",
"not",
"None",
":",
"loc",
"=",
"m",
".",
"end",
"(",
")",
"-",
"self",
".",
"_read_buffer_pos",
"self",
".",
"_check_max_bytes",
"(",
"self",
".",
"_read_regex",
",",
"loc",
")",
"return",
"loc",
"self",
".",
"_check_max_bytes",
"(",
"self",
".",
"_read_regex",
",",
"self",
".",
"_read_buffer_size",
")",
"return",
"None"
] |
Attempts to find a position in the read buffer that satisfies
the currently-pending read.
Returns a position in the buffer if the current read can be satisfied,
or None if it cannot.
|
[
"Attempts",
"to",
"find",
"a",
"position",
"in",
"the",
"read",
"buffer",
"that",
"satisfies",
"the",
"currently",
"-",
"pending",
"read",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L897-L937
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream._add_io_state
|
def _add_io_state(self, state: int) -> None:
"""Adds `state` (IOLoop.{READ,WRITE} flags) to our event handler.
Implementation notes: Reads and writes have a fast path and a
slow path. The fast path reads synchronously from socket
buffers, while the slow path uses `_add_io_state` to schedule
an IOLoop callback.
To detect closed connections, we must have called
`_add_io_state` at some point, but we want to delay this as
much as possible so we don't have to set an `IOLoop.ERROR`
listener that will be overwritten by the next slow-path
operation. If a sequence of fast-path ops do not end in a
slow-path op, (e.g. for an @asynchronous long-poll request),
we must add the error handler.
TODO: reevaluate this now that callbacks are gone.
"""
if self.closed():
# connection has been closed, so there can be no future events
return
if self._state is None:
self._state = ioloop.IOLoop.ERROR | state
self.io_loop.add_handler(self.fileno(), self._handle_events, self._state)
elif not self._state & state:
self._state = self._state | state
self.io_loop.update_handler(self.fileno(), self._state)
|
python
|
def _add_io_state(self, state: int) -> None:
"""Adds `state` (IOLoop.{READ,WRITE} flags) to our event handler.
Implementation notes: Reads and writes have a fast path and a
slow path. The fast path reads synchronously from socket
buffers, while the slow path uses `_add_io_state` to schedule
an IOLoop callback.
To detect closed connections, we must have called
`_add_io_state` at some point, but we want to delay this as
much as possible so we don't have to set an `IOLoop.ERROR`
listener that will be overwritten by the next slow-path
operation. If a sequence of fast-path ops do not end in a
slow-path op, (e.g. for an @asynchronous long-poll request),
we must add the error handler.
TODO: reevaluate this now that callbacks are gone.
"""
if self.closed():
# connection has been closed, so there can be no future events
return
if self._state is None:
self._state = ioloop.IOLoop.ERROR | state
self.io_loop.add_handler(self.fileno(), self._handle_events, self._state)
elif not self._state & state:
self._state = self._state | state
self.io_loop.update_handler(self.fileno(), self._state)
|
[
"def",
"_add_io_state",
"(",
"self",
",",
"state",
":",
"int",
")",
"->",
"None",
":",
"if",
"self",
".",
"closed",
"(",
")",
":",
"# connection has been closed, so there can be no future events",
"return",
"if",
"self",
".",
"_state",
"is",
"None",
":",
"self",
".",
"_state",
"=",
"ioloop",
".",
"IOLoop",
".",
"ERROR",
"|",
"state",
"self",
".",
"io_loop",
".",
"add_handler",
"(",
"self",
".",
"fileno",
"(",
")",
",",
"self",
".",
"_handle_events",
",",
"self",
".",
"_state",
")",
"elif",
"not",
"self",
".",
"_state",
"&",
"state",
":",
"self",
".",
"_state",
"=",
"self",
".",
"_state",
"|",
"state",
"self",
".",
"io_loop",
".",
"update_handler",
"(",
"self",
".",
"fileno",
"(",
")",
",",
"self",
".",
"_state",
")"
] |
Adds `state` (IOLoop.{READ,WRITE} flags) to our event handler.
Implementation notes: Reads and writes have a fast path and a
slow path. The fast path reads synchronously from socket
buffers, while the slow path uses `_add_io_state` to schedule
an IOLoop callback.
To detect closed connections, we must have called
`_add_io_state` at some point, but we want to delay this as
much as possible so we don't have to set an `IOLoop.ERROR`
listener that will be overwritten by the next slow-path
operation. If a sequence of fast-path ops do not end in a
slow-path op, (e.g. for an @asynchronous long-poll request),
we must add the error handler.
TODO: reevaluate this now that callbacks are gone.
|
[
"Adds",
"state",
"(",
"IOLoop",
".",
"{",
"READ",
"WRITE",
"}",
"flags",
")",
"to",
"our",
"event",
"handler",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L1025-L1052
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
BaseIOStream._is_connreset
|
def _is_connreset(self, exc: BaseException) -> bool:
"""Return ``True`` if exc is ECONNRESET or equivalent.
May be overridden in subclasses.
"""
return (
isinstance(exc, (socket.error, IOError))
and errno_from_exception(exc) in _ERRNO_CONNRESET
)
|
python
|
def _is_connreset(self, exc: BaseException) -> bool:
"""Return ``True`` if exc is ECONNRESET or equivalent.
May be overridden in subclasses.
"""
return (
isinstance(exc, (socket.error, IOError))
and errno_from_exception(exc) in _ERRNO_CONNRESET
)
|
[
"def",
"_is_connreset",
"(",
"self",
",",
"exc",
":",
"BaseException",
")",
"->",
"bool",
":",
"return",
"(",
"isinstance",
"(",
"exc",
",",
"(",
"socket",
".",
"error",
",",
"IOError",
")",
")",
"and",
"errno_from_exception",
"(",
"exc",
")",
"in",
"_ERRNO_CONNRESET",
")"
] |
Return ``True`` if exc is ECONNRESET or equivalent.
May be overridden in subclasses.
|
[
"Return",
"True",
"if",
"exc",
"is",
"ECONNRESET",
"or",
"equivalent",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L1054-L1062
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
IOStream.connect
|
def connect(
self: _IOStreamType, address: tuple, server_hostname: str = None
) -> "Future[_IOStreamType]":
"""Connects the socket to a remote address without blocking.
May only be called if the socket passed to the constructor was
not previously connected. The address parameter is in the
same format as for `socket.connect <socket.socket.connect>` for
the type of socket passed to the IOStream constructor,
e.g. an ``(ip, port)`` tuple. Hostnames are accepted here,
but will be resolved synchronously and block the IOLoop.
If you have a hostname instead of an IP address, the `.TCPClient`
class is recommended instead of calling this method directly.
`.TCPClient` will do asynchronous DNS resolution and handle
both IPv4 and IPv6.
If ``callback`` is specified, it will be called with no
arguments when the connection is completed; if not this method
returns a `.Future` (whose result after a successful
connection will be the stream itself).
In SSL mode, the ``server_hostname`` parameter will be used
for certificate validation (unless disabled in the
``ssl_options``) and SNI (if supported; requires Python
2.7.9+).
Note that it is safe to call `IOStream.write
<BaseIOStream.write>` while the connection is pending, in
which case the data will be written as soon as the connection
is ready. Calling `IOStream` read methods before the socket is
connected works on some platforms but is non-portable.
.. versionchanged:: 4.0
If no callback is given, returns a `.Future`.
.. versionchanged:: 4.2
SSL certificates are validated by default; pass
``ssl_options=dict(cert_reqs=ssl.CERT_NONE)`` or a
suitably-configured `ssl.SSLContext` to the
`SSLIOStream` constructor to disable.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
self._connecting = True
future = Future() # type: Future[_IOStreamType]
self._connect_future = typing.cast("Future[IOStream]", future)
try:
self.socket.connect(address)
except socket.error as e:
# In non-blocking mode we expect connect() to raise an
# exception with EINPROGRESS or EWOULDBLOCK.
#
# On freebsd, other errors such as ECONNREFUSED may be
# returned immediately when attempting to connect to
# localhost, so handle them the same way as an error
# reported later in _handle_connect.
if (
errno_from_exception(e) not in _ERRNO_INPROGRESS
and errno_from_exception(e) not in _ERRNO_WOULDBLOCK
):
if future is None:
gen_log.warning(
"Connect error on fd %s: %s", self.socket.fileno(), e
)
self.close(exc_info=e)
return future
self._add_io_state(self.io_loop.WRITE)
return future
|
python
|
def connect(
self: _IOStreamType, address: tuple, server_hostname: str = None
) -> "Future[_IOStreamType]":
"""Connects the socket to a remote address without blocking.
May only be called if the socket passed to the constructor was
not previously connected. The address parameter is in the
same format as for `socket.connect <socket.socket.connect>` for
the type of socket passed to the IOStream constructor,
e.g. an ``(ip, port)`` tuple. Hostnames are accepted here,
but will be resolved synchronously and block the IOLoop.
If you have a hostname instead of an IP address, the `.TCPClient`
class is recommended instead of calling this method directly.
`.TCPClient` will do asynchronous DNS resolution and handle
both IPv4 and IPv6.
If ``callback`` is specified, it will be called with no
arguments when the connection is completed; if not this method
returns a `.Future` (whose result after a successful
connection will be the stream itself).
In SSL mode, the ``server_hostname`` parameter will be used
for certificate validation (unless disabled in the
``ssl_options``) and SNI (if supported; requires Python
2.7.9+).
Note that it is safe to call `IOStream.write
<BaseIOStream.write>` while the connection is pending, in
which case the data will be written as soon as the connection
is ready. Calling `IOStream` read methods before the socket is
connected works on some platforms but is non-portable.
.. versionchanged:: 4.0
If no callback is given, returns a `.Future`.
.. versionchanged:: 4.2
SSL certificates are validated by default; pass
``ssl_options=dict(cert_reqs=ssl.CERT_NONE)`` or a
suitably-configured `ssl.SSLContext` to the
`SSLIOStream` constructor to disable.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
self._connecting = True
future = Future() # type: Future[_IOStreamType]
self._connect_future = typing.cast("Future[IOStream]", future)
try:
self.socket.connect(address)
except socket.error as e:
# In non-blocking mode we expect connect() to raise an
# exception with EINPROGRESS or EWOULDBLOCK.
#
# On freebsd, other errors such as ECONNREFUSED may be
# returned immediately when attempting to connect to
# localhost, so handle them the same way as an error
# reported later in _handle_connect.
if (
errno_from_exception(e) not in _ERRNO_INPROGRESS
and errno_from_exception(e) not in _ERRNO_WOULDBLOCK
):
if future is None:
gen_log.warning(
"Connect error on fd %s: %s", self.socket.fileno(), e
)
self.close(exc_info=e)
return future
self._add_io_state(self.io_loop.WRITE)
return future
|
[
"def",
"connect",
"(",
"self",
":",
"_IOStreamType",
",",
"address",
":",
"tuple",
",",
"server_hostname",
":",
"str",
"=",
"None",
")",
"->",
"\"Future[_IOStreamType]\"",
":",
"self",
".",
"_connecting",
"=",
"True",
"future",
"=",
"Future",
"(",
")",
"# type: Future[_IOStreamType]",
"self",
".",
"_connect_future",
"=",
"typing",
".",
"cast",
"(",
"\"Future[IOStream]\"",
",",
"future",
")",
"try",
":",
"self",
".",
"socket",
".",
"connect",
"(",
"address",
")",
"except",
"socket",
".",
"error",
"as",
"e",
":",
"# In non-blocking mode we expect connect() to raise an",
"# exception with EINPROGRESS or EWOULDBLOCK.",
"#",
"# On freebsd, other errors such as ECONNREFUSED may be",
"# returned immediately when attempting to connect to",
"# localhost, so handle them the same way as an error",
"# reported later in _handle_connect.",
"if",
"(",
"errno_from_exception",
"(",
"e",
")",
"not",
"in",
"_ERRNO_INPROGRESS",
"and",
"errno_from_exception",
"(",
"e",
")",
"not",
"in",
"_ERRNO_WOULDBLOCK",
")",
":",
"if",
"future",
"is",
"None",
":",
"gen_log",
".",
"warning",
"(",
"\"Connect error on fd %s: %s\"",
",",
"self",
".",
"socket",
".",
"fileno",
"(",
")",
",",
"e",
")",
"self",
".",
"close",
"(",
"exc_info",
"=",
"e",
")",
"return",
"future",
"self",
".",
"_add_io_state",
"(",
"self",
".",
"io_loop",
".",
"WRITE",
")",
"return",
"future"
] |
Connects the socket to a remote address without blocking.
May only be called if the socket passed to the constructor was
not previously connected. The address parameter is in the
same format as for `socket.connect <socket.socket.connect>` for
the type of socket passed to the IOStream constructor,
e.g. an ``(ip, port)`` tuple. Hostnames are accepted here,
but will be resolved synchronously and block the IOLoop.
If you have a hostname instead of an IP address, the `.TCPClient`
class is recommended instead of calling this method directly.
`.TCPClient` will do asynchronous DNS resolution and handle
both IPv4 and IPv6.
If ``callback`` is specified, it will be called with no
arguments when the connection is completed; if not this method
returns a `.Future` (whose result after a successful
connection will be the stream itself).
In SSL mode, the ``server_hostname`` parameter will be used
for certificate validation (unless disabled in the
``ssl_options``) and SNI (if supported; requires Python
2.7.9+).
Note that it is safe to call `IOStream.write
<BaseIOStream.write>` while the connection is pending, in
which case the data will be written as soon as the connection
is ready. Calling `IOStream` read methods before the socket is
connected works on some platforms but is non-portable.
.. versionchanged:: 4.0
If no callback is given, returns a `.Future`.
.. versionchanged:: 4.2
SSL certificates are validated by default; pass
``ssl_options=dict(cert_reqs=ssl.CERT_NONE)`` or a
suitably-configured `ssl.SSLContext` to the
`SSLIOStream` constructor to disable.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
|
[
"Connects",
"the",
"socket",
"to",
"a",
"remote",
"address",
"without",
"blocking",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L1148-L1219
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
IOStream.start_tls
|
def start_tls(
self,
server_side: bool,
ssl_options: Union[Dict[str, Any], ssl.SSLContext] = None,
server_hostname: str = None,
) -> Awaitable["SSLIOStream"]:
"""Convert this `IOStream` to an `SSLIOStream`.
This enables protocols that begin in clear-text mode and
switch to SSL after some initial negotiation (such as the
``STARTTLS`` extension to SMTP and IMAP).
This method cannot be used if there are outstanding reads
or writes on the stream, or if there is any data in the
IOStream's buffer (data in the operating system's socket
buffer is allowed). This means it must generally be used
immediately after reading or writing the last clear-text
data. It can also be used immediately after connecting,
before any reads or writes.
The ``ssl_options`` argument may be either an `ssl.SSLContext`
object or a dictionary of keyword arguments for the
`ssl.wrap_socket` function. The ``server_hostname`` argument
will be used for certificate validation unless disabled
in the ``ssl_options``.
This method returns a `.Future` whose result is the new
`SSLIOStream`. After this method has been called,
any other operation on the original stream is undefined.
If a close callback is defined on this stream, it will be
transferred to the new stream.
.. versionadded:: 4.0
.. versionchanged:: 4.2
SSL certificates are validated by default; pass
``ssl_options=dict(cert_reqs=ssl.CERT_NONE)`` or a
suitably-configured `ssl.SSLContext` to disable.
"""
if (
self._read_future
or self._write_futures
or self._connect_future
or self._closed
or self._read_buffer
or self._write_buffer
):
raise ValueError("IOStream is not idle; cannot convert to SSL")
if ssl_options is None:
if server_side:
ssl_options = _server_ssl_defaults
else:
ssl_options = _client_ssl_defaults
socket = self.socket
self.io_loop.remove_handler(socket)
self.socket = None # type: ignore
socket = ssl_wrap_socket(
socket,
ssl_options,
server_hostname=server_hostname,
server_side=server_side,
do_handshake_on_connect=False,
)
orig_close_callback = self._close_callback
self._close_callback = None
future = Future() # type: Future[SSLIOStream]
ssl_stream = SSLIOStream(socket, ssl_options=ssl_options)
ssl_stream.set_close_callback(orig_close_callback)
ssl_stream._ssl_connect_future = future
ssl_stream.max_buffer_size = self.max_buffer_size
ssl_stream.read_chunk_size = self.read_chunk_size
return future
|
python
|
def start_tls(
self,
server_side: bool,
ssl_options: Union[Dict[str, Any], ssl.SSLContext] = None,
server_hostname: str = None,
) -> Awaitable["SSLIOStream"]:
"""Convert this `IOStream` to an `SSLIOStream`.
This enables protocols that begin in clear-text mode and
switch to SSL after some initial negotiation (such as the
``STARTTLS`` extension to SMTP and IMAP).
This method cannot be used if there are outstanding reads
or writes on the stream, or if there is any data in the
IOStream's buffer (data in the operating system's socket
buffer is allowed). This means it must generally be used
immediately after reading or writing the last clear-text
data. It can also be used immediately after connecting,
before any reads or writes.
The ``ssl_options`` argument may be either an `ssl.SSLContext`
object or a dictionary of keyword arguments for the
`ssl.wrap_socket` function. The ``server_hostname`` argument
will be used for certificate validation unless disabled
in the ``ssl_options``.
This method returns a `.Future` whose result is the new
`SSLIOStream`. After this method has been called,
any other operation on the original stream is undefined.
If a close callback is defined on this stream, it will be
transferred to the new stream.
.. versionadded:: 4.0
.. versionchanged:: 4.2
SSL certificates are validated by default; pass
``ssl_options=dict(cert_reqs=ssl.CERT_NONE)`` or a
suitably-configured `ssl.SSLContext` to disable.
"""
if (
self._read_future
or self._write_futures
or self._connect_future
or self._closed
or self._read_buffer
or self._write_buffer
):
raise ValueError("IOStream is not idle; cannot convert to SSL")
if ssl_options is None:
if server_side:
ssl_options = _server_ssl_defaults
else:
ssl_options = _client_ssl_defaults
socket = self.socket
self.io_loop.remove_handler(socket)
self.socket = None # type: ignore
socket = ssl_wrap_socket(
socket,
ssl_options,
server_hostname=server_hostname,
server_side=server_side,
do_handshake_on_connect=False,
)
orig_close_callback = self._close_callback
self._close_callback = None
future = Future() # type: Future[SSLIOStream]
ssl_stream = SSLIOStream(socket, ssl_options=ssl_options)
ssl_stream.set_close_callback(orig_close_callback)
ssl_stream._ssl_connect_future = future
ssl_stream.max_buffer_size = self.max_buffer_size
ssl_stream.read_chunk_size = self.read_chunk_size
return future
|
[
"def",
"start_tls",
"(",
"self",
",",
"server_side",
":",
"bool",
",",
"ssl_options",
":",
"Union",
"[",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"ssl",
".",
"SSLContext",
"]",
"=",
"None",
",",
"server_hostname",
":",
"str",
"=",
"None",
",",
")",
"->",
"Awaitable",
"[",
"\"SSLIOStream\"",
"]",
":",
"if",
"(",
"self",
".",
"_read_future",
"or",
"self",
".",
"_write_futures",
"or",
"self",
".",
"_connect_future",
"or",
"self",
".",
"_closed",
"or",
"self",
".",
"_read_buffer",
"or",
"self",
".",
"_write_buffer",
")",
":",
"raise",
"ValueError",
"(",
"\"IOStream is not idle; cannot convert to SSL\"",
")",
"if",
"ssl_options",
"is",
"None",
":",
"if",
"server_side",
":",
"ssl_options",
"=",
"_server_ssl_defaults",
"else",
":",
"ssl_options",
"=",
"_client_ssl_defaults",
"socket",
"=",
"self",
".",
"socket",
"self",
".",
"io_loop",
".",
"remove_handler",
"(",
"socket",
")",
"self",
".",
"socket",
"=",
"None",
"# type: ignore",
"socket",
"=",
"ssl_wrap_socket",
"(",
"socket",
",",
"ssl_options",
",",
"server_hostname",
"=",
"server_hostname",
",",
"server_side",
"=",
"server_side",
",",
"do_handshake_on_connect",
"=",
"False",
",",
")",
"orig_close_callback",
"=",
"self",
".",
"_close_callback",
"self",
".",
"_close_callback",
"=",
"None",
"future",
"=",
"Future",
"(",
")",
"# type: Future[SSLIOStream]",
"ssl_stream",
"=",
"SSLIOStream",
"(",
"socket",
",",
"ssl_options",
"=",
"ssl_options",
")",
"ssl_stream",
".",
"set_close_callback",
"(",
"orig_close_callback",
")",
"ssl_stream",
".",
"_ssl_connect_future",
"=",
"future",
"ssl_stream",
".",
"max_buffer_size",
"=",
"self",
".",
"max_buffer_size",
"ssl_stream",
".",
"read_chunk_size",
"=",
"self",
".",
"read_chunk_size",
"return",
"future"
] |
Convert this `IOStream` to an `SSLIOStream`.
This enables protocols that begin in clear-text mode and
switch to SSL after some initial negotiation (such as the
``STARTTLS`` extension to SMTP and IMAP).
This method cannot be used if there are outstanding reads
or writes on the stream, or if there is any data in the
IOStream's buffer (data in the operating system's socket
buffer is allowed). This means it must generally be used
immediately after reading or writing the last clear-text
data. It can also be used immediately after connecting,
before any reads or writes.
The ``ssl_options`` argument may be either an `ssl.SSLContext`
object or a dictionary of keyword arguments for the
`ssl.wrap_socket` function. The ``server_hostname`` argument
will be used for certificate validation unless disabled
in the ``ssl_options``.
This method returns a `.Future` whose result is the new
`SSLIOStream`. After this method has been called,
any other operation on the original stream is undefined.
If a close callback is defined on this stream, it will be
transferred to the new stream.
.. versionadded:: 4.0
.. versionchanged:: 4.2
SSL certificates are validated by default; pass
``ssl_options=dict(cert_reqs=ssl.CERT_NONE)`` or a
suitably-configured `ssl.SSLContext` to disable.
|
[
"Convert",
"this",
"IOStream",
"to",
"an",
"SSLIOStream",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L1221-L1295
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
SSLIOStream._verify_cert
|
def _verify_cert(self, peercert: Any) -> bool:
"""Returns ``True`` if peercert is valid according to the configured
validation mode and hostname.
The ssl handshake already tested the certificate for a valid
CA signature; the only thing that remains is to check
the hostname.
"""
if isinstance(self._ssl_options, dict):
verify_mode = self._ssl_options.get("cert_reqs", ssl.CERT_NONE)
elif isinstance(self._ssl_options, ssl.SSLContext):
verify_mode = self._ssl_options.verify_mode
assert verify_mode in (ssl.CERT_NONE, ssl.CERT_REQUIRED, ssl.CERT_OPTIONAL)
if verify_mode == ssl.CERT_NONE or self._server_hostname is None:
return True
cert = self.socket.getpeercert()
if cert is None and verify_mode == ssl.CERT_REQUIRED:
gen_log.warning("No SSL certificate given")
return False
try:
ssl.match_hostname(peercert, self._server_hostname)
except ssl.CertificateError as e:
gen_log.warning("Invalid SSL certificate: %s" % e)
return False
else:
return True
|
python
|
def _verify_cert(self, peercert: Any) -> bool:
"""Returns ``True`` if peercert is valid according to the configured
validation mode and hostname.
The ssl handshake already tested the certificate for a valid
CA signature; the only thing that remains is to check
the hostname.
"""
if isinstance(self._ssl_options, dict):
verify_mode = self._ssl_options.get("cert_reqs", ssl.CERT_NONE)
elif isinstance(self._ssl_options, ssl.SSLContext):
verify_mode = self._ssl_options.verify_mode
assert verify_mode in (ssl.CERT_NONE, ssl.CERT_REQUIRED, ssl.CERT_OPTIONAL)
if verify_mode == ssl.CERT_NONE or self._server_hostname is None:
return True
cert = self.socket.getpeercert()
if cert is None and verify_mode == ssl.CERT_REQUIRED:
gen_log.warning("No SSL certificate given")
return False
try:
ssl.match_hostname(peercert, self._server_hostname)
except ssl.CertificateError as e:
gen_log.warning("Invalid SSL certificate: %s" % e)
return False
else:
return True
|
[
"def",
"_verify_cert",
"(",
"self",
",",
"peercert",
":",
"Any",
")",
"->",
"bool",
":",
"if",
"isinstance",
"(",
"self",
".",
"_ssl_options",
",",
"dict",
")",
":",
"verify_mode",
"=",
"self",
".",
"_ssl_options",
".",
"get",
"(",
"\"cert_reqs\"",
",",
"ssl",
".",
"CERT_NONE",
")",
"elif",
"isinstance",
"(",
"self",
".",
"_ssl_options",
",",
"ssl",
".",
"SSLContext",
")",
":",
"verify_mode",
"=",
"self",
".",
"_ssl_options",
".",
"verify_mode",
"assert",
"verify_mode",
"in",
"(",
"ssl",
".",
"CERT_NONE",
",",
"ssl",
".",
"CERT_REQUIRED",
",",
"ssl",
".",
"CERT_OPTIONAL",
")",
"if",
"verify_mode",
"==",
"ssl",
".",
"CERT_NONE",
"or",
"self",
".",
"_server_hostname",
"is",
"None",
":",
"return",
"True",
"cert",
"=",
"self",
".",
"socket",
".",
"getpeercert",
"(",
")",
"if",
"cert",
"is",
"None",
"and",
"verify_mode",
"==",
"ssl",
".",
"CERT_REQUIRED",
":",
"gen_log",
".",
"warning",
"(",
"\"No SSL certificate given\"",
")",
"return",
"False",
"try",
":",
"ssl",
".",
"match_hostname",
"(",
"peercert",
",",
"self",
".",
"_server_hostname",
")",
"except",
"ssl",
".",
"CertificateError",
"as",
"e",
":",
"gen_log",
".",
"warning",
"(",
"\"Invalid SSL certificate: %s\"",
"%",
"e",
")",
"return",
"False",
"else",
":",
"return",
"True"
] |
Returns ``True`` if peercert is valid according to the configured
validation mode and hostname.
The ssl handshake already tested the certificate for a valid
CA signature; the only thing that remains is to check
the hostname.
|
[
"Returns",
"True",
"if",
"peercert",
"is",
"valid",
"according",
"to",
"the",
"configured",
"validation",
"mode",
"and",
"hostname",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L1442-L1467
|
train
|
tornadoweb/tornado
|
tornado/iostream.py
|
SSLIOStream.wait_for_handshake
|
def wait_for_handshake(self) -> "Future[SSLIOStream]":
"""Wait for the initial SSL handshake to complete.
If a ``callback`` is given, it will be called with no
arguments once the handshake is complete; otherwise this
method returns a `.Future` which will resolve to the
stream itself after the handshake is complete.
Once the handshake is complete, information such as
the peer's certificate and NPN/ALPN selections may be
accessed on ``self.socket``.
This method is intended for use on server-side streams
or after using `IOStream.start_tls`; it should not be used
with `IOStream.connect` (which already waits for the
handshake to complete). It may only be called once per stream.
.. versionadded:: 4.2
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
if self._ssl_connect_future is not None:
raise RuntimeError("Already waiting")
future = self._ssl_connect_future = Future()
if not self._ssl_accepting:
self._finish_ssl_connect()
return future
|
python
|
def wait_for_handshake(self) -> "Future[SSLIOStream]":
"""Wait for the initial SSL handshake to complete.
If a ``callback`` is given, it will be called with no
arguments once the handshake is complete; otherwise this
method returns a `.Future` which will resolve to the
stream itself after the handshake is complete.
Once the handshake is complete, information such as
the peer's certificate and NPN/ALPN selections may be
accessed on ``self.socket``.
This method is intended for use on server-side streams
or after using `IOStream.start_tls`; it should not be used
with `IOStream.connect` (which already waits for the
handshake to complete). It may only be called once per stream.
.. versionadded:: 4.2
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
if self._ssl_connect_future is not None:
raise RuntimeError("Already waiting")
future = self._ssl_connect_future = Future()
if not self._ssl_accepting:
self._finish_ssl_connect()
return future
|
[
"def",
"wait_for_handshake",
"(",
"self",
")",
"->",
"\"Future[SSLIOStream]\"",
":",
"if",
"self",
".",
"_ssl_connect_future",
"is",
"not",
"None",
":",
"raise",
"RuntimeError",
"(",
"\"Already waiting\"",
")",
"future",
"=",
"self",
".",
"_ssl_connect_future",
"=",
"Future",
"(",
")",
"if",
"not",
"self",
".",
"_ssl_accepting",
":",
"self",
".",
"_finish_ssl_connect",
"(",
")",
"return",
"future"
] |
Wait for the initial SSL handshake to complete.
If a ``callback`` is given, it will be called with no
arguments once the handshake is complete; otherwise this
method returns a `.Future` which will resolve to the
stream itself after the handshake is complete.
Once the handshake is complete, information such as
the peer's certificate and NPN/ALPN selections may be
accessed on ``self.socket``.
This method is intended for use on server-side streams
or after using `IOStream.start_tls`; it should not be used
with `IOStream.connect` (which already waits for the
handshake to complete). It may only be called once per stream.
.. versionadded:: 4.2
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
|
[
"Wait",
"for",
"the",
"initial",
"SSL",
"handshake",
"to",
"complete",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/iostream.py#L1527-L1557
|
train
|
tornadoweb/tornado
|
tornado/log.py
|
enable_pretty_logging
|
def enable_pretty_logging(options: Any = None, logger: logging.Logger = None) -> None:
"""Turns on formatted logging output as configured.
This is called automatically by `tornado.options.parse_command_line`
and `tornado.options.parse_config_file`.
"""
if options is None:
import tornado.options
options = tornado.options.options
if options.logging is None or options.logging.lower() == "none":
return
if logger is None:
logger = logging.getLogger()
logger.setLevel(getattr(logging, options.logging.upper()))
if options.log_file_prefix:
rotate_mode = options.log_rotate_mode
if rotate_mode == "size":
channel = logging.handlers.RotatingFileHandler(
filename=options.log_file_prefix,
maxBytes=options.log_file_max_size,
backupCount=options.log_file_num_backups,
encoding="utf-8",
) # type: logging.Handler
elif rotate_mode == "time":
channel = logging.handlers.TimedRotatingFileHandler(
filename=options.log_file_prefix,
when=options.log_rotate_when,
interval=options.log_rotate_interval,
backupCount=options.log_file_num_backups,
encoding="utf-8",
)
else:
error_message = (
"The value of log_rotate_mode option should be "
+ '"size" or "time", not "%s".' % rotate_mode
)
raise ValueError(error_message)
channel.setFormatter(LogFormatter(color=False))
logger.addHandler(channel)
if options.log_to_stderr or (options.log_to_stderr is None and not logger.handlers):
# Set up color if we are in a tty and curses is installed
channel = logging.StreamHandler()
channel.setFormatter(LogFormatter())
logger.addHandler(channel)
|
python
|
def enable_pretty_logging(options: Any = None, logger: logging.Logger = None) -> None:
"""Turns on formatted logging output as configured.
This is called automatically by `tornado.options.parse_command_line`
and `tornado.options.parse_config_file`.
"""
if options is None:
import tornado.options
options = tornado.options.options
if options.logging is None or options.logging.lower() == "none":
return
if logger is None:
logger = logging.getLogger()
logger.setLevel(getattr(logging, options.logging.upper()))
if options.log_file_prefix:
rotate_mode = options.log_rotate_mode
if rotate_mode == "size":
channel = logging.handlers.RotatingFileHandler(
filename=options.log_file_prefix,
maxBytes=options.log_file_max_size,
backupCount=options.log_file_num_backups,
encoding="utf-8",
) # type: logging.Handler
elif rotate_mode == "time":
channel = logging.handlers.TimedRotatingFileHandler(
filename=options.log_file_prefix,
when=options.log_rotate_when,
interval=options.log_rotate_interval,
backupCount=options.log_file_num_backups,
encoding="utf-8",
)
else:
error_message = (
"The value of log_rotate_mode option should be "
+ '"size" or "time", not "%s".' % rotate_mode
)
raise ValueError(error_message)
channel.setFormatter(LogFormatter(color=False))
logger.addHandler(channel)
if options.log_to_stderr or (options.log_to_stderr is None and not logger.handlers):
# Set up color if we are in a tty and curses is installed
channel = logging.StreamHandler()
channel.setFormatter(LogFormatter())
logger.addHandler(channel)
|
[
"def",
"enable_pretty_logging",
"(",
"options",
":",
"Any",
"=",
"None",
",",
"logger",
":",
"logging",
".",
"Logger",
"=",
"None",
")",
"->",
"None",
":",
"if",
"options",
"is",
"None",
":",
"import",
"tornado",
".",
"options",
"options",
"=",
"tornado",
".",
"options",
".",
"options",
"if",
"options",
".",
"logging",
"is",
"None",
"or",
"options",
".",
"logging",
".",
"lower",
"(",
")",
"==",
"\"none\"",
":",
"return",
"if",
"logger",
"is",
"None",
":",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
")",
"logger",
".",
"setLevel",
"(",
"getattr",
"(",
"logging",
",",
"options",
".",
"logging",
".",
"upper",
"(",
")",
")",
")",
"if",
"options",
".",
"log_file_prefix",
":",
"rotate_mode",
"=",
"options",
".",
"log_rotate_mode",
"if",
"rotate_mode",
"==",
"\"size\"",
":",
"channel",
"=",
"logging",
".",
"handlers",
".",
"RotatingFileHandler",
"(",
"filename",
"=",
"options",
".",
"log_file_prefix",
",",
"maxBytes",
"=",
"options",
".",
"log_file_max_size",
",",
"backupCount",
"=",
"options",
".",
"log_file_num_backups",
",",
"encoding",
"=",
"\"utf-8\"",
",",
")",
"# type: logging.Handler",
"elif",
"rotate_mode",
"==",
"\"time\"",
":",
"channel",
"=",
"logging",
".",
"handlers",
".",
"TimedRotatingFileHandler",
"(",
"filename",
"=",
"options",
".",
"log_file_prefix",
",",
"when",
"=",
"options",
".",
"log_rotate_when",
",",
"interval",
"=",
"options",
".",
"log_rotate_interval",
",",
"backupCount",
"=",
"options",
".",
"log_file_num_backups",
",",
"encoding",
"=",
"\"utf-8\"",
",",
")",
"else",
":",
"error_message",
"=",
"(",
"\"The value of log_rotate_mode option should be \"",
"+",
"'\"size\" or \"time\", not \"%s\".'",
"%",
"rotate_mode",
")",
"raise",
"ValueError",
"(",
"error_message",
")",
"channel",
".",
"setFormatter",
"(",
"LogFormatter",
"(",
"color",
"=",
"False",
")",
")",
"logger",
".",
"addHandler",
"(",
"channel",
")",
"if",
"options",
".",
"log_to_stderr",
"or",
"(",
"options",
".",
"log_to_stderr",
"is",
"None",
"and",
"not",
"logger",
".",
"handlers",
")",
":",
"# Set up color if we are in a tty and curses is installed",
"channel",
"=",
"logging",
".",
"StreamHandler",
"(",
")",
"channel",
".",
"setFormatter",
"(",
"LogFormatter",
"(",
")",
")",
"logger",
".",
"addHandler",
"(",
"channel",
")"
] |
Turns on formatted logging output as configured.
This is called automatically by `tornado.options.parse_command_line`
and `tornado.options.parse_config_file`.
|
[
"Turns",
"on",
"formatted",
"logging",
"output",
"as",
"configured",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/log.py#L211-L256
|
train
|
tornadoweb/tornado
|
tornado/log.py
|
define_logging_options
|
def define_logging_options(options: Any = None) -> None:
"""Add logging-related flags to ``options``.
These options are present automatically on the default options instance;
this method is only necessary if you have created your own `.OptionParser`.
.. versionadded:: 4.2
This function existed in prior versions but was broken and undocumented until 4.2.
"""
if options is None:
# late import to prevent cycle
import tornado.options
options = tornado.options.options
options.define(
"logging",
default="info",
help=(
"Set the Python log level. If 'none', tornado won't touch the "
"logging configuration."
),
metavar="debug|info|warning|error|none",
)
options.define(
"log_to_stderr",
type=bool,
default=None,
help=(
"Send log output to stderr (colorized if possible). "
"By default use stderr if --log_file_prefix is not set and "
"no other logging is configured."
),
)
options.define(
"log_file_prefix",
type=str,
default=None,
metavar="PATH",
help=(
"Path prefix for log files. "
"Note that if you are running multiple tornado processes, "
"log_file_prefix must be different for each of them (e.g. "
"include the port number)"
),
)
options.define(
"log_file_max_size",
type=int,
default=100 * 1000 * 1000,
help="max size of log files before rollover",
)
options.define(
"log_file_num_backups", type=int, default=10, help="number of log files to keep"
)
options.define(
"log_rotate_when",
type=str,
default="midnight",
help=(
"specify the type of TimedRotatingFileHandler interval "
"other options:('S', 'M', 'H', 'D', 'W0'-'W6')"
),
)
options.define(
"log_rotate_interval",
type=int,
default=1,
help="The interval value of timed rotating",
)
options.define(
"log_rotate_mode",
type=str,
default="size",
help="The mode of rotating files(time or size)",
)
options.add_parse_callback(lambda: enable_pretty_logging(options))
|
python
|
def define_logging_options(options: Any = None) -> None:
"""Add logging-related flags to ``options``.
These options are present automatically on the default options instance;
this method is only necessary if you have created your own `.OptionParser`.
.. versionadded:: 4.2
This function existed in prior versions but was broken and undocumented until 4.2.
"""
if options is None:
# late import to prevent cycle
import tornado.options
options = tornado.options.options
options.define(
"logging",
default="info",
help=(
"Set the Python log level. If 'none', tornado won't touch the "
"logging configuration."
),
metavar="debug|info|warning|error|none",
)
options.define(
"log_to_stderr",
type=bool,
default=None,
help=(
"Send log output to stderr (colorized if possible). "
"By default use stderr if --log_file_prefix is not set and "
"no other logging is configured."
),
)
options.define(
"log_file_prefix",
type=str,
default=None,
metavar="PATH",
help=(
"Path prefix for log files. "
"Note that if you are running multiple tornado processes, "
"log_file_prefix must be different for each of them (e.g. "
"include the port number)"
),
)
options.define(
"log_file_max_size",
type=int,
default=100 * 1000 * 1000,
help="max size of log files before rollover",
)
options.define(
"log_file_num_backups", type=int, default=10, help="number of log files to keep"
)
options.define(
"log_rotate_when",
type=str,
default="midnight",
help=(
"specify the type of TimedRotatingFileHandler interval "
"other options:('S', 'M', 'H', 'D', 'W0'-'W6')"
),
)
options.define(
"log_rotate_interval",
type=int,
default=1,
help="The interval value of timed rotating",
)
options.define(
"log_rotate_mode",
type=str,
default="size",
help="The mode of rotating files(time or size)",
)
options.add_parse_callback(lambda: enable_pretty_logging(options))
|
[
"def",
"define_logging_options",
"(",
"options",
":",
"Any",
"=",
"None",
")",
"->",
"None",
":",
"if",
"options",
"is",
"None",
":",
"# late import to prevent cycle",
"import",
"tornado",
".",
"options",
"options",
"=",
"tornado",
".",
"options",
".",
"options",
"options",
".",
"define",
"(",
"\"logging\"",
",",
"default",
"=",
"\"info\"",
",",
"help",
"=",
"(",
"\"Set the Python log level. If 'none', tornado won't touch the \"",
"\"logging configuration.\"",
")",
",",
"metavar",
"=",
"\"debug|info|warning|error|none\"",
",",
")",
"options",
".",
"define",
"(",
"\"log_to_stderr\"",
",",
"type",
"=",
"bool",
",",
"default",
"=",
"None",
",",
"help",
"=",
"(",
"\"Send log output to stderr (colorized if possible). \"",
"\"By default use stderr if --log_file_prefix is not set and \"",
"\"no other logging is configured.\"",
")",
",",
")",
"options",
".",
"define",
"(",
"\"log_file_prefix\"",
",",
"type",
"=",
"str",
",",
"default",
"=",
"None",
",",
"metavar",
"=",
"\"PATH\"",
",",
"help",
"=",
"(",
"\"Path prefix for log files. \"",
"\"Note that if you are running multiple tornado processes, \"",
"\"log_file_prefix must be different for each of them (e.g. \"",
"\"include the port number)\"",
")",
",",
")",
"options",
".",
"define",
"(",
"\"log_file_max_size\"",
",",
"type",
"=",
"int",
",",
"default",
"=",
"100",
"*",
"1000",
"*",
"1000",
",",
"help",
"=",
"\"max size of log files before rollover\"",
",",
")",
"options",
".",
"define",
"(",
"\"log_file_num_backups\"",
",",
"type",
"=",
"int",
",",
"default",
"=",
"10",
",",
"help",
"=",
"\"number of log files to keep\"",
")",
"options",
".",
"define",
"(",
"\"log_rotate_when\"",
",",
"type",
"=",
"str",
",",
"default",
"=",
"\"midnight\"",
",",
"help",
"=",
"(",
"\"specify the type of TimedRotatingFileHandler interval \"",
"\"other options:('S', 'M', 'H', 'D', 'W0'-'W6')\"",
")",
",",
")",
"options",
".",
"define",
"(",
"\"log_rotate_interval\"",
",",
"type",
"=",
"int",
",",
"default",
"=",
"1",
",",
"help",
"=",
"\"The interval value of timed rotating\"",
",",
")",
"options",
".",
"define",
"(",
"\"log_rotate_mode\"",
",",
"type",
"=",
"str",
",",
"default",
"=",
"\"size\"",
",",
"help",
"=",
"\"The mode of rotating files(time or size)\"",
",",
")",
"options",
".",
"add_parse_callback",
"(",
"lambda",
":",
"enable_pretty_logging",
"(",
"options",
")",
")"
] |
Add logging-related flags to ``options``.
These options are present automatically on the default options instance;
this method is only necessary if you have created your own `.OptionParser`.
.. versionadded:: 4.2
This function existed in prior versions but was broken and undocumented until 4.2.
|
[
"Add",
"logging",
"-",
"related",
"flags",
"to",
"options",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/log.py#L259-L337
|
train
|
tornadoweb/tornado
|
tornado/simple_httpclient.py
|
SimpleAsyncHTTPClient.initialize
|
def initialize( # type: ignore
self,
max_clients: int = 10,
hostname_mapping: Dict[str, str] = None,
max_buffer_size: int = 104857600,
resolver: Resolver = None,
defaults: Dict[str, Any] = None,
max_header_size: int = None,
max_body_size: int = None,
) -> None:
"""Creates a AsyncHTTPClient.
Only a single AsyncHTTPClient instance exists per IOLoop
in order to provide limitations on the number of pending connections.
``force_instance=True`` may be used to suppress this behavior.
Note that because of this implicit reuse, unless ``force_instance``
is used, only the first call to the constructor actually uses
its arguments. It is recommended to use the ``configure`` method
instead of the constructor to ensure that arguments take effect.
``max_clients`` is the number of concurrent requests that can be
in progress; when this limit is reached additional requests will be
queued. Note that time spent waiting in this queue still counts
against the ``request_timeout``.
``hostname_mapping`` is a dictionary mapping hostnames to IP addresses.
It can be used to make local DNS changes when modifying system-wide
settings like ``/etc/hosts`` is not possible or desirable (e.g. in
unittests).
``max_buffer_size`` (default 100MB) is the number of bytes
that can be read into memory at once. ``max_body_size``
(defaults to ``max_buffer_size``) is the largest response body
that the client will accept. Without a
``streaming_callback``, the smaller of these two limits
applies; with a ``streaming_callback`` only ``max_body_size``
does.
.. versionchanged:: 4.2
Added the ``max_body_size`` argument.
"""
super(SimpleAsyncHTTPClient, self).initialize(defaults=defaults)
self.max_clients = max_clients
self.queue = (
collections.deque()
) # type: Deque[Tuple[object, HTTPRequest, Callable[[HTTPResponse], None]]]
self.active = (
{}
) # type: Dict[object, Tuple[HTTPRequest, Callable[[HTTPResponse], None]]]
self.waiting = (
{}
) # type: Dict[object, Tuple[HTTPRequest, Callable[[HTTPResponse], None], object]]
self.max_buffer_size = max_buffer_size
self.max_header_size = max_header_size
self.max_body_size = max_body_size
# TCPClient could create a Resolver for us, but we have to do it
# ourselves to support hostname_mapping.
if resolver:
self.resolver = resolver
self.own_resolver = False
else:
self.resolver = Resolver()
self.own_resolver = True
if hostname_mapping is not None:
self.resolver = OverrideResolver(
resolver=self.resolver, mapping=hostname_mapping
)
self.tcp_client = TCPClient(resolver=self.resolver)
|
python
|
def initialize( # type: ignore
self,
max_clients: int = 10,
hostname_mapping: Dict[str, str] = None,
max_buffer_size: int = 104857600,
resolver: Resolver = None,
defaults: Dict[str, Any] = None,
max_header_size: int = None,
max_body_size: int = None,
) -> None:
"""Creates a AsyncHTTPClient.
Only a single AsyncHTTPClient instance exists per IOLoop
in order to provide limitations on the number of pending connections.
``force_instance=True`` may be used to suppress this behavior.
Note that because of this implicit reuse, unless ``force_instance``
is used, only the first call to the constructor actually uses
its arguments. It is recommended to use the ``configure`` method
instead of the constructor to ensure that arguments take effect.
``max_clients`` is the number of concurrent requests that can be
in progress; when this limit is reached additional requests will be
queued. Note that time spent waiting in this queue still counts
against the ``request_timeout``.
``hostname_mapping`` is a dictionary mapping hostnames to IP addresses.
It can be used to make local DNS changes when modifying system-wide
settings like ``/etc/hosts`` is not possible or desirable (e.g. in
unittests).
``max_buffer_size`` (default 100MB) is the number of bytes
that can be read into memory at once. ``max_body_size``
(defaults to ``max_buffer_size``) is the largest response body
that the client will accept. Without a
``streaming_callback``, the smaller of these two limits
applies; with a ``streaming_callback`` only ``max_body_size``
does.
.. versionchanged:: 4.2
Added the ``max_body_size`` argument.
"""
super(SimpleAsyncHTTPClient, self).initialize(defaults=defaults)
self.max_clients = max_clients
self.queue = (
collections.deque()
) # type: Deque[Tuple[object, HTTPRequest, Callable[[HTTPResponse], None]]]
self.active = (
{}
) # type: Dict[object, Tuple[HTTPRequest, Callable[[HTTPResponse], None]]]
self.waiting = (
{}
) # type: Dict[object, Tuple[HTTPRequest, Callable[[HTTPResponse], None], object]]
self.max_buffer_size = max_buffer_size
self.max_header_size = max_header_size
self.max_body_size = max_body_size
# TCPClient could create a Resolver for us, but we have to do it
# ourselves to support hostname_mapping.
if resolver:
self.resolver = resolver
self.own_resolver = False
else:
self.resolver = Resolver()
self.own_resolver = True
if hostname_mapping is not None:
self.resolver = OverrideResolver(
resolver=self.resolver, mapping=hostname_mapping
)
self.tcp_client = TCPClient(resolver=self.resolver)
|
[
"def",
"initialize",
"(",
"# type: ignore",
"self",
",",
"max_clients",
":",
"int",
"=",
"10",
",",
"hostname_mapping",
":",
"Dict",
"[",
"str",
",",
"str",
"]",
"=",
"None",
",",
"max_buffer_size",
":",
"int",
"=",
"104857600",
",",
"resolver",
":",
"Resolver",
"=",
"None",
",",
"defaults",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"max_header_size",
":",
"int",
"=",
"None",
",",
"max_body_size",
":",
"int",
"=",
"None",
",",
")",
"->",
"None",
":",
"super",
"(",
"SimpleAsyncHTTPClient",
",",
"self",
")",
".",
"initialize",
"(",
"defaults",
"=",
"defaults",
")",
"self",
".",
"max_clients",
"=",
"max_clients",
"self",
".",
"queue",
"=",
"(",
"collections",
".",
"deque",
"(",
")",
")",
"# type: Deque[Tuple[object, HTTPRequest, Callable[[HTTPResponse], None]]]",
"self",
".",
"active",
"=",
"(",
"{",
"}",
")",
"# type: Dict[object, Tuple[HTTPRequest, Callable[[HTTPResponse], None]]]",
"self",
".",
"waiting",
"=",
"(",
"{",
"}",
")",
"# type: Dict[object, Tuple[HTTPRequest, Callable[[HTTPResponse], None], object]]",
"self",
".",
"max_buffer_size",
"=",
"max_buffer_size",
"self",
".",
"max_header_size",
"=",
"max_header_size",
"self",
".",
"max_body_size",
"=",
"max_body_size",
"# TCPClient could create a Resolver for us, but we have to do it",
"# ourselves to support hostname_mapping.",
"if",
"resolver",
":",
"self",
".",
"resolver",
"=",
"resolver",
"self",
".",
"own_resolver",
"=",
"False",
"else",
":",
"self",
".",
"resolver",
"=",
"Resolver",
"(",
")",
"self",
".",
"own_resolver",
"=",
"True",
"if",
"hostname_mapping",
"is",
"not",
"None",
":",
"self",
".",
"resolver",
"=",
"OverrideResolver",
"(",
"resolver",
"=",
"self",
".",
"resolver",
",",
"mapping",
"=",
"hostname_mapping",
")",
"self",
".",
"tcp_client",
"=",
"TCPClient",
"(",
"resolver",
"=",
"self",
".",
"resolver",
")"
] |
Creates a AsyncHTTPClient.
Only a single AsyncHTTPClient instance exists per IOLoop
in order to provide limitations on the number of pending connections.
``force_instance=True`` may be used to suppress this behavior.
Note that because of this implicit reuse, unless ``force_instance``
is used, only the first call to the constructor actually uses
its arguments. It is recommended to use the ``configure`` method
instead of the constructor to ensure that arguments take effect.
``max_clients`` is the number of concurrent requests that can be
in progress; when this limit is reached additional requests will be
queued. Note that time spent waiting in this queue still counts
against the ``request_timeout``.
``hostname_mapping`` is a dictionary mapping hostnames to IP addresses.
It can be used to make local DNS changes when modifying system-wide
settings like ``/etc/hosts`` is not possible or desirable (e.g. in
unittests).
``max_buffer_size`` (default 100MB) is the number of bytes
that can be read into memory at once. ``max_body_size``
(defaults to ``max_buffer_size``) is the largest response body
that the client will accept. Without a
``streaming_callback``, the smaller of these two limits
applies; with a ``streaming_callback`` only ``max_body_size``
does.
.. versionchanged:: 4.2
Added the ``max_body_size`` argument.
|
[
"Creates",
"a",
"AsyncHTTPClient",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/simple_httpclient.py#L89-L157
|
train
|
tornadoweb/tornado
|
tornado/simple_httpclient.py
|
SimpleAsyncHTTPClient._on_timeout
|
def _on_timeout(self, key: object, info: str = None) -> None:
"""Timeout callback of request.
Construct a timeout HTTPResponse when a timeout occurs.
:arg object key: A simple object to mark the request.
:info string key: More detailed timeout information.
"""
request, callback, timeout_handle = self.waiting[key]
self.queue.remove((key, request, callback))
error_message = "Timeout {0}".format(info) if info else "Timeout"
timeout_response = HTTPResponse(
request,
599,
error=HTTPTimeoutError(error_message),
request_time=self.io_loop.time() - request.start_time,
)
self.io_loop.add_callback(callback, timeout_response)
del self.waiting[key]
|
python
|
def _on_timeout(self, key: object, info: str = None) -> None:
"""Timeout callback of request.
Construct a timeout HTTPResponse when a timeout occurs.
:arg object key: A simple object to mark the request.
:info string key: More detailed timeout information.
"""
request, callback, timeout_handle = self.waiting[key]
self.queue.remove((key, request, callback))
error_message = "Timeout {0}".format(info) if info else "Timeout"
timeout_response = HTTPResponse(
request,
599,
error=HTTPTimeoutError(error_message),
request_time=self.io_loop.time() - request.start_time,
)
self.io_loop.add_callback(callback, timeout_response)
del self.waiting[key]
|
[
"def",
"_on_timeout",
"(",
"self",
",",
"key",
":",
"object",
",",
"info",
":",
"str",
"=",
"None",
")",
"->",
"None",
":",
"request",
",",
"callback",
",",
"timeout_handle",
"=",
"self",
".",
"waiting",
"[",
"key",
"]",
"self",
".",
"queue",
".",
"remove",
"(",
"(",
"key",
",",
"request",
",",
"callback",
")",
")",
"error_message",
"=",
"\"Timeout {0}\"",
".",
"format",
"(",
"info",
")",
"if",
"info",
"else",
"\"Timeout\"",
"timeout_response",
"=",
"HTTPResponse",
"(",
"request",
",",
"599",
",",
"error",
"=",
"HTTPTimeoutError",
"(",
"error_message",
")",
",",
"request_time",
"=",
"self",
".",
"io_loop",
".",
"time",
"(",
")",
"-",
"request",
".",
"start_time",
",",
")",
"self",
".",
"io_loop",
".",
"add_callback",
"(",
"callback",
",",
"timeout_response",
")",
"del",
"self",
".",
"waiting",
"[",
"key",
"]"
] |
Timeout callback of request.
Construct a timeout HTTPResponse when a timeout occurs.
:arg object key: A simple object to mark the request.
:info string key: More detailed timeout information.
|
[
"Timeout",
"callback",
"of",
"request",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/simple_httpclient.py#L229-L248
|
train
|
tornadoweb/tornado
|
tornado/simple_httpclient.py
|
_HTTPConnection._on_timeout
|
def _on_timeout(self, info: str = None) -> None:
"""Timeout callback of _HTTPConnection instance.
Raise a `HTTPTimeoutError` when a timeout occurs.
:info string key: More detailed timeout information.
"""
self._timeout = None
error_message = "Timeout {0}".format(info) if info else "Timeout"
if self.final_callback is not None:
self._handle_exception(
HTTPTimeoutError, HTTPTimeoutError(error_message), None
)
|
python
|
def _on_timeout(self, info: str = None) -> None:
"""Timeout callback of _HTTPConnection instance.
Raise a `HTTPTimeoutError` when a timeout occurs.
:info string key: More detailed timeout information.
"""
self._timeout = None
error_message = "Timeout {0}".format(info) if info else "Timeout"
if self.final_callback is not None:
self._handle_exception(
HTTPTimeoutError, HTTPTimeoutError(error_message), None
)
|
[
"def",
"_on_timeout",
"(",
"self",
",",
"info",
":",
"str",
"=",
"None",
")",
"->",
"None",
":",
"self",
".",
"_timeout",
"=",
"None",
"error_message",
"=",
"\"Timeout {0}\"",
".",
"format",
"(",
"info",
")",
"if",
"info",
"else",
"\"Timeout\"",
"if",
"self",
".",
"final_callback",
"is",
"not",
"None",
":",
"self",
".",
"_handle_exception",
"(",
"HTTPTimeoutError",
",",
"HTTPTimeoutError",
"(",
"error_message",
")",
",",
"None",
")"
] |
Timeout callback of _HTTPConnection instance.
Raise a `HTTPTimeoutError` when a timeout occurs.
:info string key: More detailed timeout information.
|
[
"Timeout",
"callback",
"of",
"_HTTPConnection",
"instance",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/simple_httpclient.py#L474-L486
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
_oauth10a_signature
|
def _oauth10a_signature(
consumer_token: Dict[str, Any],
method: str,
url: str,
parameters: Dict[str, Any] = {},
token: Dict[str, Any] = None,
) -> bytes:
"""Calculates the HMAC-SHA1 OAuth 1.0a signature for the given request.
See http://oauth.net/core/1.0a/#signing_process
"""
parts = urllib.parse.urlparse(url)
scheme, netloc, path = parts[:3]
normalized_url = scheme.lower() + "://" + netloc.lower() + path
base_elems = []
base_elems.append(method.upper())
base_elems.append(normalized_url)
base_elems.append(
"&".join(
"%s=%s" % (k, _oauth_escape(str(v))) for k, v in sorted(parameters.items())
)
)
base_string = "&".join(_oauth_escape(e) for e in base_elems)
key_elems = [escape.utf8(urllib.parse.quote(consumer_token["secret"], safe="~"))]
key_elems.append(
escape.utf8(urllib.parse.quote(token["secret"], safe="~") if token else "")
)
key = b"&".join(key_elems)
hash = hmac.new(key, escape.utf8(base_string), hashlib.sha1)
return binascii.b2a_base64(hash.digest())[:-1]
|
python
|
def _oauth10a_signature(
consumer_token: Dict[str, Any],
method: str,
url: str,
parameters: Dict[str, Any] = {},
token: Dict[str, Any] = None,
) -> bytes:
"""Calculates the HMAC-SHA1 OAuth 1.0a signature for the given request.
See http://oauth.net/core/1.0a/#signing_process
"""
parts = urllib.parse.urlparse(url)
scheme, netloc, path = parts[:3]
normalized_url = scheme.lower() + "://" + netloc.lower() + path
base_elems = []
base_elems.append(method.upper())
base_elems.append(normalized_url)
base_elems.append(
"&".join(
"%s=%s" % (k, _oauth_escape(str(v))) for k, v in sorted(parameters.items())
)
)
base_string = "&".join(_oauth_escape(e) for e in base_elems)
key_elems = [escape.utf8(urllib.parse.quote(consumer_token["secret"], safe="~"))]
key_elems.append(
escape.utf8(urllib.parse.quote(token["secret"], safe="~") if token else "")
)
key = b"&".join(key_elems)
hash = hmac.new(key, escape.utf8(base_string), hashlib.sha1)
return binascii.b2a_base64(hash.digest())[:-1]
|
[
"def",
"_oauth10a_signature",
"(",
"consumer_token",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"method",
":",
"str",
",",
"url",
":",
"str",
",",
"parameters",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"{",
"}",
",",
"token",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
")",
"->",
"bytes",
":",
"parts",
"=",
"urllib",
".",
"parse",
".",
"urlparse",
"(",
"url",
")",
"scheme",
",",
"netloc",
",",
"path",
"=",
"parts",
"[",
":",
"3",
"]",
"normalized_url",
"=",
"scheme",
".",
"lower",
"(",
")",
"+",
"\"://\"",
"+",
"netloc",
".",
"lower",
"(",
")",
"+",
"path",
"base_elems",
"=",
"[",
"]",
"base_elems",
".",
"append",
"(",
"method",
".",
"upper",
"(",
")",
")",
"base_elems",
".",
"append",
"(",
"normalized_url",
")",
"base_elems",
".",
"append",
"(",
"\"&\"",
".",
"join",
"(",
"\"%s=%s\"",
"%",
"(",
"k",
",",
"_oauth_escape",
"(",
"str",
"(",
"v",
")",
")",
")",
"for",
"k",
",",
"v",
"in",
"sorted",
"(",
"parameters",
".",
"items",
"(",
")",
")",
")",
")",
"base_string",
"=",
"\"&\"",
".",
"join",
"(",
"_oauth_escape",
"(",
"e",
")",
"for",
"e",
"in",
"base_elems",
")",
"key_elems",
"=",
"[",
"escape",
".",
"utf8",
"(",
"urllib",
".",
"parse",
".",
"quote",
"(",
"consumer_token",
"[",
"\"secret\"",
"]",
",",
"safe",
"=",
"\"~\"",
")",
")",
"]",
"key_elems",
".",
"append",
"(",
"escape",
".",
"utf8",
"(",
"urllib",
".",
"parse",
".",
"quote",
"(",
"token",
"[",
"\"secret\"",
"]",
",",
"safe",
"=",
"\"~\"",
")",
"if",
"token",
"else",
"\"\"",
")",
")",
"key",
"=",
"b\"&\"",
".",
"join",
"(",
"key_elems",
")",
"hash",
"=",
"hmac",
".",
"new",
"(",
"key",
",",
"escape",
".",
"utf8",
"(",
"base_string",
")",
",",
"hashlib",
".",
"sha1",
")",
"return",
"binascii",
".",
"b2a_base64",
"(",
"hash",
".",
"digest",
"(",
")",
")",
"[",
":",
"-",
"1",
"]"
] |
Calculates the HMAC-SHA1 OAuth 1.0a signature for the given request.
See http://oauth.net/core/1.0a/#signing_process
|
[
"Calculates",
"the",
"HMAC",
"-",
"SHA1",
"OAuth",
"1",
".",
"0a",
"signature",
"for",
"the",
"given",
"request",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L1130-L1162
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
OpenIdMixin.authenticate_redirect
|
def authenticate_redirect(
self,
callback_uri: str = None,
ax_attrs: List[str] = ["name", "email", "language", "username"],
) -> None:
"""Redirects to the authentication URL for this service.
After authentication, the service will redirect back to the given
callback URI with additional parameters including ``openid.mode``.
We request the given attributes for the authenticated user by
default (name, email, language, and username). If you don't need
all those attributes for your app, you can request fewer with
the ax_attrs keyword argument.
.. versionchanged:: 6.0
The ``callback`` argument was removed and this method no
longer returns an awaitable object. It is now an ordinary
synchronous function.
"""
handler = cast(RequestHandler, self)
callback_uri = callback_uri or handler.request.uri
assert callback_uri is not None
args = self._openid_args(callback_uri, ax_attrs=ax_attrs)
endpoint = self._OPENID_ENDPOINT # type: ignore
handler.redirect(endpoint + "?" + urllib.parse.urlencode(args))
|
python
|
def authenticate_redirect(
self,
callback_uri: str = None,
ax_attrs: List[str] = ["name", "email", "language", "username"],
) -> None:
"""Redirects to the authentication URL for this service.
After authentication, the service will redirect back to the given
callback URI with additional parameters including ``openid.mode``.
We request the given attributes for the authenticated user by
default (name, email, language, and username). If you don't need
all those attributes for your app, you can request fewer with
the ax_attrs keyword argument.
.. versionchanged:: 6.0
The ``callback`` argument was removed and this method no
longer returns an awaitable object. It is now an ordinary
synchronous function.
"""
handler = cast(RequestHandler, self)
callback_uri = callback_uri or handler.request.uri
assert callback_uri is not None
args = self._openid_args(callback_uri, ax_attrs=ax_attrs)
endpoint = self._OPENID_ENDPOINT # type: ignore
handler.redirect(endpoint + "?" + urllib.parse.urlencode(args))
|
[
"def",
"authenticate_redirect",
"(",
"self",
",",
"callback_uri",
":",
"str",
"=",
"None",
",",
"ax_attrs",
":",
"List",
"[",
"str",
"]",
"=",
"[",
"\"name\"",
",",
"\"email\"",
",",
"\"language\"",
",",
"\"username\"",
"]",
",",
")",
"->",
"None",
":",
"handler",
"=",
"cast",
"(",
"RequestHandler",
",",
"self",
")",
"callback_uri",
"=",
"callback_uri",
"or",
"handler",
".",
"request",
".",
"uri",
"assert",
"callback_uri",
"is",
"not",
"None",
"args",
"=",
"self",
".",
"_openid_args",
"(",
"callback_uri",
",",
"ax_attrs",
"=",
"ax_attrs",
")",
"endpoint",
"=",
"self",
".",
"_OPENID_ENDPOINT",
"# type: ignore",
"handler",
".",
"redirect",
"(",
"endpoint",
"+",
"\"?\"",
"+",
"urllib",
".",
"parse",
".",
"urlencode",
"(",
"args",
")",
")"
] |
Redirects to the authentication URL for this service.
After authentication, the service will redirect back to the given
callback URI with additional parameters including ``openid.mode``.
We request the given attributes for the authenticated user by
default (name, email, language, and username). If you don't need
all those attributes for your app, you can request fewer with
the ax_attrs keyword argument.
.. versionchanged:: 6.0
The ``callback`` argument was removed and this method no
longer returns an awaitable object. It is now an ordinary
synchronous function.
|
[
"Redirects",
"to",
"the",
"authentication",
"URL",
"for",
"this",
"service",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L88-L114
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
OpenIdMixin.get_authenticated_user
|
async def get_authenticated_user(
self, http_client: httpclient.AsyncHTTPClient = None
) -> Dict[str, Any]:
"""Fetches the authenticated user data upon redirect.
This method should be called by the handler that receives the
redirect from the `authenticate_redirect()` method (which is
often the same as the one that calls it; in that case you would
call `get_authenticated_user` if the ``openid.mode`` parameter
is present and `authenticate_redirect` if it is not).
The result of this method will generally be used to set a cookie.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
handler = cast(RequestHandler, self)
# Verify the OpenID response via direct request to the OP
args = dict(
(k, v[-1]) for k, v in handler.request.arguments.items()
) # type: Dict[str, Union[str, bytes]]
args["openid.mode"] = u"check_authentication"
url = self._OPENID_ENDPOINT # type: ignore
if http_client is None:
http_client = self.get_auth_http_client()
resp = await http_client.fetch(
url, method="POST", body=urllib.parse.urlencode(args)
)
return self._on_authentication_verified(resp)
|
python
|
async def get_authenticated_user(
self, http_client: httpclient.AsyncHTTPClient = None
) -> Dict[str, Any]:
"""Fetches the authenticated user data upon redirect.
This method should be called by the handler that receives the
redirect from the `authenticate_redirect()` method (which is
often the same as the one that calls it; in that case you would
call `get_authenticated_user` if the ``openid.mode`` parameter
is present and `authenticate_redirect` if it is not).
The result of this method will generally be used to set a cookie.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
handler = cast(RequestHandler, self)
# Verify the OpenID response via direct request to the OP
args = dict(
(k, v[-1]) for k, v in handler.request.arguments.items()
) # type: Dict[str, Union[str, bytes]]
args["openid.mode"] = u"check_authentication"
url = self._OPENID_ENDPOINT # type: ignore
if http_client is None:
http_client = self.get_auth_http_client()
resp = await http_client.fetch(
url, method="POST", body=urllib.parse.urlencode(args)
)
return self._on_authentication_verified(resp)
|
[
"async",
"def",
"get_authenticated_user",
"(",
"self",
",",
"http_client",
":",
"httpclient",
".",
"AsyncHTTPClient",
"=",
"None",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"handler",
"=",
"cast",
"(",
"RequestHandler",
",",
"self",
")",
"# Verify the OpenID response via direct request to the OP",
"args",
"=",
"dict",
"(",
"(",
"k",
",",
"v",
"[",
"-",
"1",
"]",
")",
"for",
"k",
",",
"v",
"in",
"handler",
".",
"request",
".",
"arguments",
".",
"items",
"(",
")",
")",
"# type: Dict[str, Union[str, bytes]]",
"args",
"[",
"\"openid.mode\"",
"]",
"=",
"u\"check_authentication\"",
"url",
"=",
"self",
".",
"_OPENID_ENDPOINT",
"# type: ignore",
"if",
"http_client",
"is",
"None",
":",
"http_client",
"=",
"self",
".",
"get_auth_http_client",
"(",
")",
"resp",
"=",
"await",
"http_client",
".",
"fetch",
"(",
"url",
",",
"method",
"=",
"\"POST\"",
",",
"body",
"=",
"urllib",
".",
"parse",
".",
"urlencode",
"(",
"args",
")",
")",
"return",
"self",
".",
"_on_authentication_verified",
"(",
"resp",
")"
] |
Fetches the authenticated user data upon redirect.
This method should be called by the handler that receives the
redirect from the `authenticate_redirect()` method (which is
often the same as the one that calls it; in that case you would
call `get_authenticated_user` if the ``openid.mode`` parameter
is present and `authenticate_redirect` if it is not).
The result of this method will generally be used to set a cookie.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
|
[
"Fetches",
"the",
"authenticated",
"user",
"data",
"upon",
"redirect",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L116-L146
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
OAuthMixin.authorize_redirect
|
async def authorize_redirect(
self,
callback_uri: str = None,
extra_params: Dict[str, Any] = None,
http_client: httpclient.AsyncHTTPClient = None,
) -> None:
"""Redirects the user to obtain OAuth authorization for this service.
The ``callback_uri`` may be omitted if you have previously
registered a callback URI with the third-party service. For
some services, you must use a previously-registered callback
URI and cannot specify a callback via this method.
This method sets a cookie called ``_oauth_request_token`` which is
subsequently used (and cleared) in `get_authenticated_user` for
security purposes.
This method is asynchronous and must be called with ``await``
or ``yield`` (This is different from other ``auth*_redirect``
methods defined in this module). It calls
`.RequestHandler.finish` for you so you should not write any
other response after it returns.
.. versionchanged:: 3.1
Now returns a `.Future` and takes an optional callback, for
compatibility with `.gen.coroutine`.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
if callback_uri and getattr(self, "_OAUTH_NO_CALLBACKS", False):
raise Exception("This service does not support oauth_callback")
if http_client is None:
http_client = self.get_auth_http_client()
assert http_client is not None
if getattr(self, "_OAUTH_VERSION", "1.0a") == "1.0a":
response = await http_client.fetch(
self._oauth_request_token_url(
callback_uri=callback_uri, extra_params=extra_params
)
)
else:
response = await http_client.fetch(self._oauth_request_token_url())
url = self._OAUTH_AUTHORIZE_URL # type: ignore
self._on_request_token(url, callback_uri, response)
|
python
|
async def authorize_redirect(
self,
callback_uri: str = None,
extra_params: Dict[str, Any] = None,
http_client: httpclient.AsyncHTTPClient = None,
) -> None:
"""Redirects the user to obtain OAuth authorization for this service.
The ``callback_uri`` may be omitted if you have previously
registered a callback URI with the third-party service. For
some services, you must use a previously-registered callback
URI and cannot specify a callback via this method.
This method sets a cookie called ``_oauth_request_token`` which is
subsequently used (and cleared) in `get_authenticated_user` for
security purposes.
This method is asynchronous and must be called with ``await``
or ``yield`` (This is different from other ``auth*_redirect``
methods defined in this module). It calls
`.RequestHandler.finish` for you so you should not write any
other response after it returns.
.. versionchanged:: 3.1
Now returns a `.Future` and takes an optional callback, for
compatibility with `.gen.coroutine`.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
if callback_uri and getattr(self, "_OAUTH_NO_CALLBACKS", False):
raise Exception("This service does not support oauth_callback")
if http_client is None:
http_client = self.get_auth_http_client()
assert http_client is not None
if getattr(self, "_OAUTH_VERSION", "1.0a") == "1.0a":
response = await http_client.fetch(
self._oauth_request_token_url(
callback_uri=callback_uri, extra_params=extra_params
)
)
else:
response = await http_client.fetch(self._oauth_request_token_url())
url = self._OAUTH_AUTHORIZE_URL # type: ignore
self._on_request_token(url, callback_uri, response)
|
[
"async",
"def",
"authorize_redirect",
"(",
"self",
",",
"callback_uri",
":",
"str",
"=",
"None",
",",
"extra_params",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"http_client",
":",
"httpclient",
".",
"AsyncHTTPClient",
"=",
"None",
",",
")",
"->",
"None",
":",
"if",
"callback_uri",
"and",
"getattr",
"(",
"self",
",",
"\"_OAUTH_NO_CALLBACKS\"",
",",
"False",
")",
":",
"raise",
"Exception",
"(",
"\"This service does not support oauth_callback\"",
")",
"if",
"http_client",
"is",
"None",
":",
"http_client",
"=",
"self",
".",
"get_auth_http_client",
"(",
")",
"assert",
"http_client",
"is",
"not",
"None",
"if",
"getattr",
"(",
"self",
",",
"\"_OAUTH_VERSION\"",
",",
"\"1.0a\"",
")",
"==",
"\"1.0a\"",
":",
"response",
"=",
"await",
"http_client",
".",
"fetch",
"(",
"self",
".",
"_oauth_request_token_url",
"(",
"callback_uri",
"=",
"callback_uri",
",",
"extra_params",
"=",
"extra_params",
")",
")",
"else",
":",
"response",
"=",
"await",
"http_client",
".",
"fetch",
"(",
"self",
".",
"_oauth_request_token_url",
"(",
")",
")",
"url",
"=",
"self",
".",
"_OAUTH_AUTHORIZE_URL",
"# type: ignore",
"self",
".",
"_on_request_token",
"(",
"url",
",",
"callback_uri",
",",
"response",
")"
] |
Redirects the user to obtain OAuth authorization for this service.
The ``callback_uri`` may be omitted if you have previously
registered a callback URI with the third-party service. For
some services, you must use a previously-registered callback
URI and cannot specify a callback via this method.
This method sets a cookie called ``_oauth_request_token`` which is
subsequently used (and cleared) in `get_authenticated_user` for
security purposes.
This method is asynchronous and must be called with ``await``
or ``yield`` (This is different from other ``auth*_redirect``
methods defined in this module). It calls
`.RequestHandler.finish` for you so you should not write any
other response after it returns.
.. versionchanged:: 3.1
Now returns a `.Future` and takes an optional callback, for
compatibility with `.gen.coroutine`.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
|
[
"Redirects",
"the",
"user",
"to",
"obtain",
"OAuth",
"authorization",
"for",
"this",
"service",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L287-L334
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
OAuthMixin.get_authenticated_user
|
async def get_authenticated_user(
self, http_client: httpclient.AsyncHTTPClient = None
) -> Dict[str, Any]:
"""Gets the OAuth authorized user and access token.
This method should be called from the handler for your
OAuth callback URL to complete the registration process. We run the
callback with the authenticated user dictionary. This dictionary
will contain an ``access_key`` which can be used to make authorized
requests to this service on behalf of the user. The dictionary will
also contain other fields such as ``name``, depending on the service
used.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
handler = cast(RequestHandler, self)
request_key = escape.utf8(handler.get_argument("oauth_token"))
oauth_verifier = handler.get_argument("oauth_verifier", None)
request_cookie = handler.get_cookie("_oauth_request_token")
if not request_cookie:
raise AuthError("Missing OAuth request token cookie")
handler.clear_cookie("_oauth_request_token")
cookie_key, cookie_secret = [
base64.b64decode(escape.utf8(i)) for i in request_cookie.split("|")
]
if cookie_key != request_key:
raise AuthError("Request token does not match cookie")
token = dict(
key=cookie_key, secret=cookie_secret
) # type: Dict[str, Union[str, bytes]]
if oauth_verifier:
token["verifier"] = oauth_verifier
if http_client is None:
http_client = self.get_auth_http_client()
assert http_client is not None
response = await http_client.fetch(self._oauth_access_token_url(token))
access_token = _oauth_parse_response(response.body)
user = await self._oauth_get_user_future(access_token)
if not user:
raise AuthError("Error getting user")
user["access_token"] = access_token
return user
|
python
|
async def get_authenticated_user(
self, http_client: httpclient.AsyncHTTPClient = None
) -> Dict[str, Any]:
"""Gets the OAuth authorized user and access token.
This method should be called from the handler for your
OAuth callback URL to complete the registration process. We run the
callback with the authenticated user dictionary. This dictionary
will contain an ``access_key`` which can be used to make authorized
requests to this service on behalf of the user. The dictionary will
also contain other fields such as ``name``, depending on the service
used.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
handler = cast(RequestHandler, self)
request_key = escape.utf8(handler.get_argument("oauth_token"))
oauth_verifier = handler.get_argument("oauth_verifier", None)
request_cookie = handler.get_cookie("_oauth_request_token")
if not request_cookie:
raise AuthError("Missing OAuth request token cookie")
handler.clear_cookie("_oauth_request_token")
cookie_key, cookie_secret = [
base64.b64decode(escape.utf8(i)) for i in request_cookie.split("|")
]
if cookie_key != request_key:
raise AuthError("Request token does not match cookie")
token = dict(
key=cookie_key, secret=cookie_secret
) # type: Dict[str, Union[str, bytes]]
if oauth_verifier:
token["verifier"] = oauth_verifier
if http_client is None:
http_client = self.get_auth_http_client()
assert http_client is not None
response = await http_client.fetch(self._oauth_access_token_url(token))
access_token = _oauth_parse_response(response.body)
user = await self._oauth_get_user_future(access_token)
if not user:
raise AuthError("Error getting user")
user["access_token"] = access_token
return user
|
[
"async",
"def",
"get_authenticated_user",
"(",
"self",
",",
"http_client",
":",
"httpclient",
".",
"AsyncHTTPClient",
"=",
"None",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"handler",
"=",
"cast",
"(",
"RequestHandler",
",",
"self",
")",
"request_key",
"=",
"escape",
".",
"utf8",
"(",
"handler",
".",
"get_argument",
"(",
"\"oauth_token\"",
")",
")",
"oauth_verifier",
"=",
"handler",
".",
"get_argument",
"(",
"\"oauth_verifier\"",
",",
"None",
")",
"request_cookie",
"=",
"handler",
".",
"get_cookie",
"(",
"\"_oauth_request_token\"",
")",
"if",
"not",
"request_cookie",
":",
"raise",
"AuthError",
"(",
"\"Missing OAuth request token cookie\"",
")",
"handler",
".",
"clear_cookie",
"(",
"\"_oauth_request_token\"",
")",
"cookie_key",
",",
"cookie_secret",
"=",
"[",
"base64",
".",
"b64decode",
"(",
"escape",
".",
"utf8",
"(",
"i",
")",
")",
"for",
"i",
"in",
"request_cookie",
".",
"split",
"(",
"\"|\"",
")",
"]",
"if",
"cookie_key",
"!=",
"request_key",
":",
"raise",
"AuthError",
"(",
"\"Request token does not match cookie\"",
")",
"token",
"=",
"dict",
"(",
"key",
"=",
"cookie_key",
",",
"secret",
"=",
"cookie_secret",
")",
"# type: Dict[str, Union[str, bytes]]",
"if",
"oauth_verifier",
":",
"token",
"[",
"\"verifier\"",
"]",
"=",
"oauth_verifier",
"if",
"http_client",
"is",
"None",
":",
"http_client",
"=",
"self",
".",
"get_auth_http_client",
"(",
")",
"assert",
"http_client",
"is",
"not",
"None",
"response",
"=",
"await",
"http_client",
".",
"fetch",
"(",
"self",
".",
"_oauth_access_token_url",
"(",
"token",
")",
")",
"access_token",
"=",
"_oauth_parse_response",
"(",
"response",
".",
"body",
")",
"user",
"=",
"await",
"self",
".",
"_oauth_get_user_future",
"(",
"access_token",
")",
"if",
"not",
"user",
":",
"raise",
"AuthError",
"(",
"\"Error getting user\"",
")",
"user",
"[",
"\"access_token\"",
"]",
"=",
"access_token",
"return",
"user"
] |
Gets the OAuth authorized user and access token.
This method should be called from the handler for your
OAuth callback URL to complete the registration process. We run the
callback with the authenticated user dictionary. This dictionary
will contain an ``access_key`` which can be used to make authorized
requests to this service on behalf of the user. The dictionary will
also contain other fields such as ``name``, depending on the service
used.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
|
[
"Gets",
"the",
"OAuth",
"authorized",
"user",
"and",
"access",
"token",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L336-L380
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
OAuthMixin._oauth_get_user_future
|
async def _oauth_get_user_future(
self, access_token: Dict[str, Any]
) -> Dict[str, Any]:
"""Subclasses must override this to get basic information about the
user.
Should be a coroutine whose result is a dictionary
containing information about the user, which may have been
retrieved by using ``access_token`` to make a request to the
service.
The access token will be added to the returned dictionary to make
the result of `get_authenticated_user`.
.. versionchanged:: 5.1
Subclasses may also define this method with ``async def``.
.. versionchanged:: 6.0
A synchronous fallback to ``_oauth_get_user`` was removed.
"""
raise NotImplementedError()
|
python
|
async def _oauth_get_user_future(
self, access_token: Dict[str, Any]
) -> Dict[str, Any]:
"""Subclasses must override this to get basic information about the
user.
Should be a coroutine whose result is a dictionary
containing information about the user, which may have been
retrieved by using ``access_token`` to make a request to the
service.
The access token will be added to the returned dictionary to make
the result of `get_authenticated_user`.
.. versionchanged:: 5.1
Subclasses may also define this method with ``async def``.
.. versionchanged:: 6.0
A synchronous fallback to ``_oauth_get_user`` was removed.
"""
raise NotImplementedError()
|
[
"async",
"def",
"_oauth_get_user_future",
"(",
"self",
",",
"access_token",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"raise",
"NotImplementedError",
"(",
")"
] |
Subclasses must override this to get basic information about the
user.
Should be a coroutine whose result is a dictionary
containing information about the user, which may have been
retrieved by using ``access_token`` to make a request to the
service.
The access token will be added to the returned dictionary to make
the result of `get_authenticated_user`.
.. versionchanged:: 5.1
Subclasses may also define this method with ``async def``.
.. versionchanged:: 6.0
A synchronous fallback to ``_oauth_get_user`` was removed.
|
[
"Subclasses",
"must",
"override",
"this",
"to",
"get",
"basic",
"information",
"about",
"the",
"user",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L468-L490
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
OAuth2Mixin.authorize_redirect
|
def authorize_redirect(
self,
redirect_uri: str = None,
client_id: str = None,
client_secret: str = None,
extra_params: Dict[str, Any] = None,
scope: str = None,
response_type: str = "code",
) -> None:
"""Redirects the user to obtain OAuth authorization for this service.
Some providers require that you register a redirect URL with
your application instead of passing one via this method. You
should call this method to log the user in, and then call
``get_authenticated_user`` in the handler for your
redirect URL to complete the authorization process.
.. versionchanged:: 6.0
The ``callback`` argument and returned awaitable were removed;
this is now an ordinary synchronous function.
"""
handler = cast(RequestHandler, self)
args = {"response_type": response_type}
if redirect_uri is not None:
args["redirect_uri"] = redirect_uri
if client_id is not None:
args["client_id"] = client_id
if extra_params:
args.update(extra_params)
if scope:
args["scope"] = " ".join(scope)
url = self._OAUTH_AUTHORIZE_URL # type: ignore
handler.redirect(url_concat(url, args))
|
python
|
def authorize_redirect(
self,
redirect_uri: str = None,
client_id: str = None,
client_secret: str = None,
extra_params: Dict[str, Any] = None,
scope: str = None,
response_type: str = "code",
) -> None:
"""Redirects the user to obtain OAuth authorization for this service.
Some providers require that you register a redirect URL with
your application instead of passing one via this method. You
should call this method to log the user in, and then call
``get_authenticated_user`` in the handler for your
redirect URL to complete the authorization process.
.. versionchanged:: 6.0
The ``callback`` argument and returned awaitable were removed;
this is now an ordinary synchronous function.
"""
handler = cast(RequestHandler, self)
args = {"response_type": response_type}
if redirect_uri is not None:
args["redirect_uri"] = redirect_uri
if client_id is not None:
args["client_id"] = client_id
if extra_params:
args.update(extra_params)
if scope:
args["scope"] = " ".join(scope)
url = self._OAUTH_AUTHORIZE_URL # type: ignore
handler.redirect(url_concat(url, args))
|
[
"def",
"authorize_redirect",
"(",
"self",
",",
"redirect_uri",
":",
"str",
"=",
"None",
",",
"client_id",
":",
"str",
"=",
"None",
",",
"client_secret",
":",
"str",
"=",
"None",
",",
"extra_params",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"scope",
":",
"str",
"=",
"None",
",",
"response_type",
":",
"str",
"=",
"\"code\"",
",",
")",
"->",
"None",
":",
"handler",
"=",
"cast",
"(",
"RequestHandler",
",",
"self",
")",
"args",
"=",
"{",
"\"response_type\"",
":",
"response_type",
"}",
"if",
"redirect_uri",
"is",
"not",
"None",
":",
"args",
"[",
"\"redirect_uri\"",
"]",
"=",
"redirect_uri",
"if",
"client_id",
"is",
"not",
"None",
":",
"args",
"[",
"\"client_id\"",
"]",
"=",
"client_id",
"if",
"extra_params",
":",
"args",
".",
"update",
"(",
"extra_params",
")",
"if",
"scope",
":",
"args",
"[",
"\"scope\"",
"]",
"=",
"\" \"",
".",
"join",
"(",
"scope",
")",
"url",
"=",
"self",
".",
"_OAUTH_AUTHORIZE_URL",
"# type: ignore",
"handler",
".",
"redirect",
"(",
"url_concat",
"(",
"url",
",",
"args",
")",
")"
] |
Redirects the user to obtain OAuth authorization for this service.
Some providers require that you register a redirect URL with
your application instead of passing one via this method. You
should call this method to log the user in, and then call
``get_authenticated_user`` in the handler for your
redirect URL to complete the authorization process.
.. versionchanged:: 6.0
The ``callback`` argument and returned awaitable were removed;
this is now an ordinary synchronous function.
|
[
"Redirects",
"the",
"user",
"to",
"obtain",
"OAuth",
"authorization",
"for",
"this",
"service",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L548-L581
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
OAuth2Mixin.oauth2_request
|
async def oauth2_request(
self,
url: str,
access_token: str = None,
post_args: Dict[str, Any] = None,
**args: Any
) -> Any:
"""Fetches the given URL auth an OAuth2 access token.
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
Example usage:
..testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.oauth2_request(
"https://graph.facebook.com/me/feed",
post_args={"message": "I am posting from my Tornado application!"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
await self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
.. versionadded:: 4.3
.. versionchanged::: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
all_args = {}
if access_token:
all_args["access_token"] = access_token
all_args.update(args)
if all_args:
url += "?" + urllib.parse.urlencode(all_args)
http = self.get_auth_http_client()
if post_args is not None:
response = await http.fetch(
url, method="POST", body=urllib.parse.urlencode(post_args)
)
else:
response = await http.fetch(url)
return escape.json_decode(response.body)
|
python
|
async def oauth2_request(
self,
url: str,
access_token: str = None,
post_args: Dict[str, Any] = None,
**args: Any
) -> Any:
"""Fetches the given URL auth an OAuth2 access token.
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
Example usage:
..testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.oauth2_request(
"https://graph.facebook.com/me/feed",
post_args={"message": "I am posting from my Tornado application!"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
await self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
.. versionadded:: 4.3
.. versionchanged::: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
all_args = {}
if access_token:
all_args["access_token"] = access_token
all_args.update(args)
if all_args:
url += "?" + urllib.parse.urlencode(all_args)
http = self.get_auth_http_client()
if post_args is not None:
response = await http.fetch(
url, method="POST", body=urllib.parse.urlencode(post_args)
)
else:
response = await http.fetch(url)
return escape.json_decode(response.body)
|
[
"async",
"def",
"oauth2_request",
"(",
"self",
",",
"url",
":",
"str",
",",
"access_token",
":",
"str",
"=",
"None",
",",
"post_args",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"*",
"*",
"args",
":",
"Any",
")",
"->",
"Any",
":",
"all_args",
"=",
"{",
"}",
"if",
"access_token",
":",
"all_args",
"[",
"\"access_token\"",
"]",
"=",
"access_token",
"all_args",
".",
"update",
"(",
"args",
")",
"if",
"all_args",
":",
"url",
"+=",
"\"?\"",
"+",
"urllib",
".",
"parse",
".",
"urlencode",
"(",
"all_args",
")",
"http",
"=",
"self",
".",
"get_auth_http_client",
"(",
")",
"if",
"post_args",
"is",
"not",
"None",
":",
"response",
"=",
"await",
"http",
".",
"fetch",
"(",
"url",
",",
"method",
"=",
"\"POST\"",
",",
"body",
"=",
"urllib",
".",
"parse",
".",
"urlencode",
"(",
"post_args",
")",
")",
"else",
":",
"response",
"=",
"await",
"http",
".",
"fetch",
"(",
"url",
")",
"return",
"escape",
".",
"json_decode",
"(",
"response",
".",
"body",
")"
] |
Fetches the given URL auth an OAuth2 access token.
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
Example usage:
..testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.oauth2_request(
"https://graph.facebook.com/me/feed",
post_args={"message": "I am posting from my Tornado application!"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
await self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
.. versionadded:: 4.3
.. versionchanged::: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
|
[
"Fetches",
"the",
"given",
"URL",
"auth",
"an",
"OAuth2",
"access",
"token",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L605-L659
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
TwitterMixin.authenticate_redirect
|
async def authenticate_redirect(self, callback_uri: str = None) -> None:
"""Just like `~OAuthMixin.authorize_redirect`, but
auto-redirects if authorized.
This is generally the right interface to use if you are using
Twitter for single-sign on.
.. versionchanged:: 3.1
Now returns a `.Future` and takes an optional callback, for
compatibility with `.gen.coroutine`.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
http = self.get_auth_http_client()
response = await http.fetch(
self._oauth_request_token_url(callback_uri=callback_uri)
)
self._on_request_token(self._OAUTH_AUTHENTICATE_URL, None, response)
|
python
|
async def authenticate_redirect(self, callback_uri: str = None) -> None:
"""Just like `~OAuthMixin.authorize_redirect`, but
auto-redirects if authorized.
This is generally the right interface to use if you are using
Twitter for single-sign on.
.. versionchanged:: 3.1
Now returns a `.Future` and takes an optional callback, for
compatibility with `.gen.coroutine`.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
http = self.get_auth_http_client()
response = await http.fetch(
self._oauth_request_token_url(callback_uri=callback_uri)
)
self._on_request_token(self._OAUTH_AUTHENTICATE_URL, None, response)
|
[
"async",
"def",
"authenticate_redirect",
"(",
"self",
",",
"callback_uri",
":",
"str",
"=",
"None",
")",
"->",
"None",
":",
"http",
"=",
"self",
".",
"get_auth_http_client",
"(",
")",
"response",
"=",
"await",
"http",
".",
"fetch",
"(",
"self",
".",
"_oauth_request_token_url",
"(",
"callback_uri",
"=",
"callback_uri",
")",
")",
"self",
".",
"_on_request_token",
"(",
"self",
".",
"_OAUTH_AUTHENTICATE_URL",
",",
"None",
",",
"response",
")"
] |
Just like `~OAuthMixin.authorize_redirect`, but
auto-redirects if authorized.
This is generally the right interface to use if you are using
Twitter for single-sign on.
.. versionchanged:: 3.1
Now returns a `.Future` and takes an optional callback, for
compatibility with `.gen.coroutine`.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
|
[
"Just",
"like",
"~OAuthMixin",
".",
"authorize_redirect",
"but",
"auto",
"-",
"redirects",
"if",
"authorized",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L712-L732
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
TwitterMixin.twitter_request
|
async def twitter_request(
self,
path: str,
access_token: Dict[str, Any],
post_args: Dict[str, Any] = None,
**args: Any
) -> Any:
"""Fetches the given API path, e.g., ``statuses/user_timeline/btaylor``
The path should not include the format or API version number.
(we automatically use JSON format and API version 1).
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
All the Twitter methods are documented at http://dev.twitter.com/
Many methods require an OAuth access token which you can
obtain through `~OAuthMixin.authorize_redirect` and
`~OAuthMixin.get_authenticated_user`. The user returned through that
process includes an 'access_token' attribute that can be used
to make authenticated requests via this method. Example
usage:
.. testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.TwitterMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.twitter_request(
"/statuses/update",
post_args={"status": "Testing Tornado Web Server"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
yield self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
if path.startswith("http:") or path.startswith("https:"):
# Raw urls are useful for e.g. search which doesn't follow the
# usual pattern: http://search.twitter.com/search.json
url = path
else:
url = self._TWITTER_BASE_URL + path + ".json"
# Add the OAuth resource request signature if we have credentials
if access_token:
all_args = {}
all_args.update(args)
all_args.update(post_args or {})
method = "POST" if post_args is not None else "GET"
oauth = self._oauth_request_parameters(
url, access_token, all_args, method=method
)
args.update(oauth)
if args:
url += "?" + urllib.parse.urlencode(args)
http = self.get_auth_http_client()
if post_args is not None:
response = await http.fetch(
url, method="POST", body=urllib.parse.urlencode(post_args)
)
else:
response = await http.fetch(url)
return escape.json_decode(response.body)
|
python
|
async def twitter_request(
self,
path: str,
access_token: Dict[str, Any],
post_args: Dict[str, Any] = None,
**args: Any
) -> Any:
"""Fetches the given API path, e.g., ``statuses/user_timeline/btaylor``
The path should not include the format or API version number.
(we automatically use JSON format and API version 1).
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
All the Twitter methods are documented at http://dev.twitter.com/
Many methods require an OAuth access token which you can
obtain through `~OAuthMixin.authorize_redirect` and
`~OAuthMixin.get_authenticated_user`. The user returned through that
process includes an 'access_token' attribute that can be used
to make authenticated requests via this method. Example
usage:
.. testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.TwitterMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.twitter_request(
"/statuses/update",
post_args={"status": "Testing Tornado Web Server"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
yield self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
if path.startswith("http:") or path.startswith("https:"):
# Raw urls are useful for e.g. search which doesn't follow the
# usual pattern: http://search.twitter.com/search.json
url = path
else:
url = self._TWITTER_BASE_URL + path + ".json"
# Add the OAuth resource request signature if we have credentials
if access_token:
all_args = {}
all_args.update(args)
all_args.update(post_args or {})
method = "POST" if post_args is not None else "GET"
oauth = self._oauth_request_parameters(
url, access_token, all_args, method=method
)
args.update(oauth)
if args:
url += "?" + urllib.parse.urlencode(args)
http = self.get_auth_http_client()
if post_args is not None:
response = await http.fetch(
url, method="POST", body=urllib.parse.urlencode(post_args)
)
else:
response = await http.fetch(url)
return escape.json_decode(response.body)
|
[
"async",
"def",
"twitter_request",
"(",
"self",
",",
"path",
":",
"str",
",",
"access_token",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"post_args",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"*",
"*",
"args",
":",
"Any",
")",
"->",
"Any",
":",
"if",
"path",
".",
"startswith",
"(",
"\"http:\"",
")",
"or",
"path",
".",
"startswith",
"(",
"\"https:\"",
")",
":",
"# Raw urls are useful for e.g. search which doesn't follow the",
"# usual pattern: http://search.twitter.com/search.json",
"url",
"=",
"path",
"else",
":",
"url",
"=",
"self",
".",
"_TWITTER_BASE_URL",
"+",
"path",
"+",
"\".json\"",
"# Add the OAuth resource request signature if we have credentials",
"if",
"access_token",
":",
"all_args",
"=",
"{",
"}",
"all_args",
".",
"update",
"(",
"args",
")",
"all_args",
".",
"update",
"(",
"post_args",
"or",
"{",
"}",
")",
"method",
"=",
"\"POST\"",
"if",
"post_args",
"is",
"not",
"None",
"else",
"\"GET\"",
"oauth",
"=",
"self",
".",
"_oauth_request_parameters",
"(",
"url",
",",
"access_token",
",",
"all_args",
",",
"method",
"=",
"method",
")",
"args",
".",
"update",
"(",
"oauth",
")",
"if",
"args",
":",
"url",
"+=",
"\"?\"",
"+",
"urllib",
".",
"parse",
".",
"urlencode",
"(",
"args",
")",
"http",
"=",
"self",
".",
"get_auth_http_client",
"(",
")",
"if",
"post_args",
"is",
"not",
"None",
":",
"response",
"=",
"await",
"http",
".",
"fetch",
"(",
"url",
",",
"method",
"=",
"\"POST\"",
",",
"body",
"=",
"urllib",
".",
"parse",
".",
"urlencode",
"(",
"post_args",
")",
")",
"else",
":",
"response",
"=",
"await",
"http",
".",
"fetch",
"(",
"url",
")",
"return",
"escape",
".",
"json_decode",
"(",
"response",
".",
"body",
")"
] |
Fetches the given API path, e.g., ``statuses/user_timeline/btaylor``
The path should not include the format or API version number.
(we automatically use JSON format and API version 1).
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
All the Twitter methods are documented at http://dev.twitter.com/
Many methods require an OAuth access token which you can
obtain through `~OAuthMixin.authorize_redirect` and
`~OAuthMixin.get_authenticated_user`. The user returned through that
process includes an 'access_token' attribute that can be used
to make authenticated requests via this method. Example
usage:
.. testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.TwitterMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.twitter_request(
"/statuses/update",
post_args={"status": "Testing Tornado Web Server"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
yield self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
awaitable object instead.
|
[
"Fetches",
"the",
"given",
"API",
"path",
"e",
".",
"g",
".",
"statuses",
"/",
"user_timeline",
"/",
"btaylor"
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L734-L807
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
GoogleOAuth2Mixin.get_authenticated_user
|
async def get_authenticated_user(
self, redirect_uri: str, code: str
) -> Dict[str, Any]:
"""Handles the login for the Google user, returning an access token.
The result is a dictionary containing an ``access_token`` field
([among others](https://developers.google.com/identity/protocols/OAuth2WebServer#handlingtheresponse)).
Unlike other ``get_authenticated_user`` methods in this package,
this method does not return any additional information about the user.
The returned access token can be used with `OAuth2Mixin.oauth2_request`
to request additional information (perhaps from
``https://www.googleapis.com/oauth2/v2/userinfo``)
Example usage:
.. testcode::
class GoogleOAuth2LoginHandler(tornado.web.RequestHandler,
tornado.auth.GoogleOAuth2Mixin):
async def get(self):
if self.get_argument('code', False):
access = await self.get_authenticated_user(
redirect_uri='http://your.site.com/auth/google',
code=self.get_argument('code'))
user = await self.oauth2_request(
"https://www.googleapis.com/oauth2/v1/userinfo",
access_token=access["access_token"])
# Save the user and access token with
# e.g. set_secure_cookie.
else:
await self.authorize_redirect(
redirect_uri='http://your.site.com/auth/google',
client_id=self.settings['google_oauth']['key'],
scope=['profile', 'email'],
response_type='code',
extra_params={'approval_prompt': 'auto'})
.. testoutput::
:hide:
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
""" # noqa: E501
handler = cast(RequestHandler, self)
http = self.get_auth_http_client()
body = urllib.parse.urlencode(
{
"redirect_uri": redirect_uri,
"code": code,
"client_id": handler.settings[self._OAUTH_SETTINGS_KEY]["key"],
"client_secret": handler.settings[self._OAUTH_SETTINGS_KEY]["secret"],
"grant_type": "authorization_code",
}
)
response = await http.fetch(
self._OAUTH_ACCESS_TOKEN_URL,
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body=body,
)
return escape.json_decode(response.body)
|
python
|
async def get_authenticated_user(
self, redirect_uri: str, code: str
) -> Dict[str, Any]:
"""Handles the login for the Google user, returning an access token.
The result is a dictionary containing an ``access_token`` field
([among others](https://developers.google.com/identity/protocols/OAuth2WebServer#handlingtheresponse)).
Unlike other ``get_authenticated_user`` methods in this package,
this method does not return any additional information about the user.
The returned access token can be used with `OAuth2Mixin.oauth2_request`
to request additional information (perhaps from
``https://www.googleapis.com/oauth2/v2/userinfo``)
Example usage:
.. testcode::
class GoogleOAuth2LoginHandler(tornado.web.RequestHandler,
tornado.auth.GoogleOAuth2Mixin):
async def get(self):
if self.get_argument('code', False):
access = await self.get_authenticated_user(
redirect_uri='http://your.site.com/auth/google',
code=self.get_argument('code'))
user = await self.oauth2_request(
"https://www.googleapis.com/oauth2/v1/userinfo",
access_token=access["access_token"])
# Save the user and access token with
# e.g. set_secure_cookie.
else:
await self.authorize_redirect(
redirect_uri='http://your.site.com/auth/google',
client_id=self.settings['google_oauth']['key'],
scope=['profile', 'email'],
response_type='code',
extra_params={'approval_prompt': 'auto'})
.. testoutput::
:hide:
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
""" # noqa: E501
handler = cast(RequestHandler, self)
http = self.get_auth_http_client()
body = urllib.parse.urlencode(
{
"redirect_uri": redirect_uri,
"code": code,
"client_id": handler.settings[self._OAUTH_SETTINGS_KEY]["key"],
"client_secret": handler.settings[self._OAUTH_SETTINGS_KEY]["secret"],
"grant_type": "authorization_code",
}
)
response = await http.fetch(
self._OAUTH_ACCESS_TOKEN_URL,
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body=body,
)
return escape.json_decode(response.body)
|
[
"async",
"def",
"get_authenticated_user",
"(",
"self",
",",
"redirect_uri",
":",
"str",
",",
"code",
":",
"str",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"# noqa: E501",
"handler",
"=",
"cast",
"(",
"RequestHandler",
",",
"self",
")",
"http",
"=",
"self",
".",
"get_auth_http_client",
"(",
")",
"body",
"=",
"urllib",
".",
"parse",
".",
"urlencode",
"(",
"{",
"\"redirect_uri\"",
":",
"redirect_uri",
",",
"\"code\"",
":",
"code",
",",
"\"client_id\"",
":",
"handler",
".",
"settings",
"[",
"self",
".",
"_OAUTH_SETTINGS_KEY",
"]",
"[",
"\"key\"",
"]",
",",
"\"client_secret\"",
":",
"handler",
".",
"settings",
"[",
"self",
".",
"_OAUTH_SETTINGS_KEY",
"]",
"[",
"\"secret\"",
"]",
",",
"\"grant_type\"",
":",
"\"authorization_code\"",
",",
"}",
")",
"response",
"=",
"await",
"http",
".",
"fetch",
"(",
"self",
".",
"_OAUTH_ACCESS_TOKEN_URL",
",",
"method",
"=",
"\"POST\"",
",",
"headers",
"=",
"{",
"\"Content-Type\"",
":",
"\"application/x-www-form-urlencoded\"",
"}",
",",
"body",
"=",
"body",
",",
")",
"return",
"escape",
".",
"json_decode",
"(",
"response",
".",
"body",
")"
] |
Handles the login for the Google user, returning an access token.
The result is a dictionary containing an ``access_token`` field
([among others](https://developers.google.com/identity/protocols/OAuth2WebServer#handlingtheresponse)).
Unlike other ``get_authenticated_user`` methods in this package,
this method does not return any additional information about the user.
The returned access token can be used with `OAuth2Mixin.oauth2_request`
to request additional information (perhaps from
``https://www.googleapis.com/oauth2/v2/userinfo``)
Example usage:
.. testcode::
class GoogleOAuth2LoginHandler(tornado.web.RequestHandler,
tornado.auth.GoogleOAuth2Mixin):
async def get(self):
if self.get_argument('code', False):
access = await self.get_authenticated_user(
redirect_uri='http://your.site.com/auth/google',
code=self.get_argument('code'))
user = await self.oauth2_request(
"https://www.googleapis.com/oauth2/v1/userinfo",
access_token=access["access_token"])
# Save the user and access token with
# e.g. set_secure_cookie.
else:
await self.authorize_redirect(
redirect_uri='http://your.site.com/auth/google',
client_id=self.settings['google_oauth']['key'],
scope=['profile', 'email'],
response_type='code',
extra_params={'approval_prompt': 'auto'})
.. testoutput::
:hide:
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
|
[
"Handles",
"the",
"login",
"for",
"the",
"Google",
"user",
"returning",
"an",
"access",
"token",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L854-L916
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
FacebookGraphMixin.get_authenticated_user
|
async def get_authenticated_user(
self,
redirect_uri: str,
client_id: str,
client_secret: str,
code: str,
extra_fields: Dict[str, Any] = None,
) -> Optional[Dict[str, Any]]:
"""Handles the login for the Facebook user, returning a user object.
Example usage:
.. testcode::
class FacebookGraphLoginHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
async def get(self):
if self.get_argument("code", False):
user = await self.get_authenticated_user(
redirect_uri='/auth/facebookgraph/',
client_id=self.settings["facebook_api_key"],
client_secret=self.settings["facebook_secret"],
code=self.get_argument("code"))
# Save the user with e.g. set_secure_cookie
else:
await self.authorize_redirect(
redirect_uri='/auth/facebookgraph/',
client_id=self.settings["facebook_api_key"],
extra_params={"scope": "read_stream,offline_access"})
.. testoutput::
:hide:
This method returns a dictionary which may contain the following fields:
* ``access_token``, a string which may be passed to `facebook_request`
* ``session_expires``, an integer encoded as a string representing
the time until the access token expires in seconds. This field should
be used like ``int(user['session_expires'])``; in a future version of
Tornado it will change from a string to an integer.
* ``id``, ``name``, ``first_name``, ``last_name``, ``locale``, ``picture``,
``link``, plus any fields named in the ``extra_fields`` argument. These
fields are copied from the Facebook graph API
`user object <https://developers.facebook.com/docs/graph-api/reference/user>`_
.. versionchanged:: 4.5
The ``session_expires`` field was updated to support changes made to the
Facebook API in March 2017.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
http = self.get_auth_http_client()
args = {
"redirect_uri": redirect_uri,
"code": code,
"client_id": client_id,
"client_secret": client_secret,
}
fields = set(
["id", "name", "first_name", "last_name", "locale", "picture", "link"]
)
if extra_fields:
fields.update(extra_fields)
response = await http.fetch(
self._oauth_request_token_url(**args) # type: ignore
)
args = escape.json_decode(response.body)
session = {
"access_token": args.get("access_token"),
"expires_in": args.get("expires_in"),
}
assert session["access_token"] is not None
user = await self.facebook_request(
path="/me",
access_token=session["access_token"],
appsecret_proof=hmac.new(
key=client_secret.encode("utf8"),
msg=session["access_token"].encode("utf8"),
digestmod=hashlib.sha256,
).hexdigest(),
fields=",".join(fields),
)
if user is None:
return None
fieldmap = {}
for field in fields:
fieldmap[field] = user.get(field)
# session_expires is converted to str for compatibility with
# older versions in which the server used url-encoding and
# this code simply returned the string verbatim.
# This should change in Tornado 5.0.
fieldmap.update(
{
"access_token": session["access_token"],
"session_expires": str(session.get("expires_in")),
}
)
return fieldmap
|
python
|
async def get_authenticated_user(
self,
redirect_uri: str,
client_id: str,
client_secret: str,
code: str,
extra_fields: Dict[str, Any] = None,
) -> Optional[Dict[str, Any]]:
"""Handles the login for the Facebook user, returning a user object.
Example usage:
.. testcode::
class FacebookGraphLoginHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
async def get(self):
if self.get_argument("code", False):
user = await self.get_authenticated_user(
redirect_uri='/auth/facebookgraph/',
client_id=self.settings["facebook_api_key"],
client_secret=self.settings["facebook_secret"],
code=self.get_argument("code"))
# Save the user with e.g. set_secure_cookie
else:
await self.authorize_redirect(
redirect_uri='/auth/facebookgraph/',
client_id=self.settings["facebook_api_key"],
extra_params={"scope": "read_stream,offline_access"})
.. testoutput::
:hide:
This method returns a dictionary which may contain the following fields:
* ``access_token``, a string which may be passed to `facebook_request`
* ``session_expires``, an integer encoded as a string representing
the time until the access token expires in seconds. This field should
be used like ``int(user['session_expires'])``; in a future version of
Tornado it will change from a string to an integer.
* ``id``, ``name``, ``first_name``, ``last_name``, ``locale``, ``picture``,
``link``, plus any fields named in the ``extra_fields`` argument. These
fields are copied from the Facebook graph API
`user object <https://developers.facebook.com/docs/graph-api/reference/user>`_
.. versionchanged:: 4.5
The ``session_expires`` field was updated to support changes made to the
Facebook API in March 2017.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
http = self.get_auth_http_client()
args = {
"redirect_uri": redirect_uri,
"code": code,
"client_id": client_id,
"client_secret": client_secret,
}
fields = set(
["id", "name", "first_name", "last_name", "locale", "picture", "link"]
)
if extra_fields:
fields.update(extra_fields)
response = await http.fetch(
self._oauth_request_token_url(**args) # type: ignore
)
args = escape.json_decode(response.body)
session = {
"access_token": args.get("access_token"),
"expires_in": args.get("expires_in"),
}
assert session["access_token"] is not None
user = await self.facebook_request(
path="/me",
access_token=session["access_token"],
appsecret_proof=hmac.new(
key=client_secret.encode("utf8"),
msg=session["access_token"].encode("utf8"),
digestmod=hashlib.sha256,
).hexdigest(),
fields=",".join(fields),
)
if user is None:
return None
fieldmap = {}
for field in fields:
fieldmap[field] = user.get(field)
# session_expires is converted to str for compatibility with
# older versions in which the server used url-encoding and
# this code simply returned the string verbatim.
# This should change in Tornado 5.0.
fieldmap.update(
{
"access_token": session["access_token"],
"session_expires": str(session.get("expires_in")),
}
)
return fieldmap
|
[
"async",
"def",
"get_authenticated_user",
"(",
"self",
",",
"redirect_uri",
":",
"str",
",",
"client_id",
":",
"str",
",",
"client_secret",
":",
"str",
",",
"code",
":",
"str",
",",
"extra_fields",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
")",
"->",
"Optional",
"[",
"Dict",
"[",
"str",
",",
"Any",
"]",
"]",
":",
"http",
"=",
"self",
".",
"get_auth_http_client",
"(",
")",
"args",
"=",
"{",
"\"redirect_uri\"",
":",
"redirect_uri",
",",
"\"code\"",
":",
"code",
",",
"\"client_id\"",
":",
"client_id",
",",
"\"client_secret\"",
":",
"client_secret",
",",
"}",
"fields",
"=",
"set",
"(",
"[",
"\"id\"",
",",
"\"name\"",
",",
"\"first_name\"",
",",
"\"last_name\"",
",",
"\"locale\"",
",",
"\"picture\"",
",",
"\"link\"",
"]",
")",
"if",
"extra_fields",
":",
"fields",
".",
"update",
"(",
"extra_fields",
")",
"response",
"=",
"await",
"http",
".",
"fetch",
"(",
"self",
".",
"_oauth_request_token_url",
"(",
"*",
"*",
"args",
")",
"# type: ignore",
")",
"args",
"=",
"escape",
".",
"json_decode",
"(",
"response",
".",
"body",
")",
"session",
"=",
"{",
"\"access_token\"",
":",
"args",
".",
"get",
"(",
"\"access_token\"",
")",
",",
"\"expires_in\"",
":",
"args",
".",
"get",
"(",
"\"expires_in\"",
")",
",",
"}",
"assert",
"session",
"[",
"\"access_token\"",
"]",
"is",
"not",
"None",
"user",
"=",
"await",
"self",
".",
"facebook_request",
"(",
"path",
"=",
"\"/me\"",
",",
"access_token",
"=",
"session",
"[",
"\"access_token\"",
"]",
",",
"appsecret_proof",
"=",
"hmac",
".",
"new",
"(",
"key",
"=",
"client_secret",
".",
"encode",
"(",
"\"utf8\"",
")",
",",
"msg",
"=",
"session",
"[",
"\"access_token\"",
"]",
".",
"encode",
"(",
"\"utf8\"",
")",
",",
"digestmod",
"=",
"hashlib",
".",
"sha256",
",",
")",
".",
"hexdigest",
"(",
")",
",",
"fields",
"=",
"\",\"",
".",
"join",
"(",
"fields",
")",
",",
")",
"if",
"user",
"is",
"None",
":",
"return",
"None",
"fieldmap",
"=",
"{",
"}",
"for",
"field",
"in",
"fields",
":",
"fieldmap",
"[",
"field",
"]",
"=",
"user",
".",
"get",
"(",
"field",
")",
"# session_expires is converted to str for compatibility with",
"# older versions in which the server used url-encoding and",
"# this code simply returned the string verbatim.",
"# This should change in Tornado 5.0.",
"fieldmap",
".",
"update",
"(",
"{",
"\"access_token\"",
":",
"session",
"[",
"\"access_token\"",
"]",
",",
"\"session_expires\"",
":",
"str",
"(",
"session",
".",
"get",
"(",
"\"expires_in\"",
")",
")",
",",
"}",
")",
"return",
"fieldmap"
] |
Handles the login for the Facebook user, returning a user object.
Example usage:
.. testcode::
class FacebookGraphLoginHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
async def get(self):
if self.get_argument("code", False):
user = await self.get_authenticated_user(
redirect_uri='/auth/facebookgraph/',
client_id=self.settings["facebook_api_key"],
client_secret=self.settings["facebook_secret"],
code=self.get_argument("code"))
# Save the user with e.g. set_secure_cookie
else:
await self.authorize_redirect(
redirect_uri='/auth/facebookgraph/',
client_id=self.settings["facebook_api_key"],
extra_params={"scope": "read_stream,offline_access"})
.. testoutput::
:hide:
This method returns a dictionary which may contain the following fields:
* ``access_token``, a string which may be passed to `facebook_request`
* ``session_expires``, an integer encoded as a string representing
the time until the access token expires in seconds. This field should
be used like ``int(user['session_expires'])``; in a future version of
Tornado it will change from a string to an integer.
* ``id``, ``name``, ``first_name``, ``last_name``, ``locale``, ``picture``,
``link``, plus any fields named in the ``extra_fields`` argument. These
fields are copied from the Facebook graph API
`user object <https://developers.facebook.com/docs/graph-api/reference/user>`_
.. versionchanged:: 4.5
The ``session_expires`` field was updated to support changes made to the
Facebook API in March 2017.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
|
[
"Handles",
"the",
"login",
"for",
"the",
"Facebook",
"user",
"returning",
"a",
"user",
"object",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L927-L1032
|
train
|
tornadoweb/tornado
|
tornado/auth.py
|
FacebookGraphMixin.facebook_request
|
async def facebook_request(
self,
path: str,
access_token: str = None,
post_args: Dict[str, Any] = None,
**args: Any
) -> Any:
"""Fetches the given relative API path, e.g., "/btaylor/picture"
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
An introduction to the Facebook Graph API can be found at
http://developers.facebook.com/docs/api
Many methods require an OAuth access token which you can
obtain through `~OAuth2Mixin.authorize_redirect` and
`get_authenticated_user`. The user returned through that
process includes an ``access_token`` attribute that can be
used to make authenticated requests via this method.
Example usage:
.. testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.facebook_request(
"/me/feed",
post_args={"message": "I am posting from my Tornado application!"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
yield self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
The given path is relative to ``self._FACEBOOK_BASE_URL``,
by default "https://graph.facebook.com".
This method is a wrapper around `OAuth2Mixin.oauth2_request`;
the only difference is that this method takes a relative path,
while ``oauth2_request`` takes a complete url.
.. versionchanged:: 3.1
Added the ability to override ``self._FACEBOOK_BASE_URL``.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
url = self._FACEBOOK_BASE_URL + path
return await self.oauth2_request(
url, access_token=access_token, post_args=post_args, **args
)
|
python
|
async def facebook_request(
self,
path: str,
access_token: str = None,
post_args: Dict[str, Any] = None,
**args: Any
) -> Any:
"""Fetches the given relative API path, e.g., "/btaylor/picture"
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
An introduction to the Facebook Graph API can be found at
http://developers.facebook.com/docs/api
Many methods require an OAuth access token which you can
obtain through `~OAuth2Mixin.authorize_redirect` and
`get_authenticated_user`. The user returned through that
process includes an ``access_token`` attribute that can be
used to make authenticated requests via this method.
Example usage:
.. testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.facebook_request(
"/me/feed",
post_args={"message": "I am posting from my Tornado application!"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
yield self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
The given path is relative to ``self._FACEBOOK_BASE_URL``,
by default "https://graph.facebook.com".
This method is a wrapper around `OAuth2Mixin.oauth2_request`;
the only difference is that this method takes a relative path,
while ``oauth2_request`` takes a complete url.
.. versionchanged:: 3.1
Added the ability to override ``self._FACEBOOK_BASE_URL``.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
url = self._FACEBOOK_BASE_URL + path
return await self.oauth2_request(
url, access_token=access_token, post_args=post_args, **args
)
|
[
"async",
"def",
"facebook_request",
"(",
"self",
",",
"path",
":",
"str",
",",
"access_token",
":",
"str",
"=",
"None",
",",
"post_args",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"*",
"*",
"args",
":",
"Any",
")",
"->",
"Any",
":",
"url",
"=",
"self",
".",
"_FACEBOOK_BASE_URL",
"+",
"path",
"return",
"await",
"self",
".",
"oauth2_request",
"(",
"url",
",",
"access_token",
"=",
"access_token",
",",
"post_args",
"=",
"post_args",
",",
"*",
"*",
"args",
")"
] |
Fetches the given relative API path, e.g., "/btaylor/picture"
If the request is a POST, ``post_args`` should be provided. Query
string arguments should be given as keyword arguments.
An introduction to the Facebook Graph API can be found at
http://developers.facebook.com/docs/api
Many methods require an OAuth access token which you can
obtain through `~OAuth2Mixin.authorize_redirect` and
`get_authenticated_user`. The user returned through that
process includes an ``access_token`` attribute that can be
used to make authenticated requests via this method.
Example usage:
.. testcode::
class MainHandler(tornado.web.RequestHandler,
tornado.auth.FacebookGraphMixin):
@tornado.web.authenticated
async def get(self):
new_entry = await self.facebook_request(
"/me/feed",
post_args={"message": "I am posting from my Tornado application!"},
access_token=self.current_user["access_token"])
if not new_entry:
# Call failed; perhaps missing permission?
yield self.authorize_redirect()
return
self.finish("Posted a message!")
.. testoutput::
:hide:
The given path is relative to ``self._FACEBOOK_BASE_URL``,
by default "https://graph.facebook.com".
This method is a wrapper around `OAuth2Mixin.oauth2_request`;
the only difference is that this method takes a relative path,
while ``oauth2_request`` takes a complete url.
.. versionchanged:: 3.1
Added the ability to override ``self._FACEBOOK_BASE_URL``.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned awaitable object instead.
|
[
"Fetches",
"the",
"given",
"relative",
"API",
"path",
"e",
".",
"g",
".",
"/",
"btaylor",
"/",
"picture"
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/auth.py#L1034-L1094
|
train
|
tornadoweb/tornado
|
tornado/locks.py
|
Condition.wait
|
def wait(self, timeout: Union[float, datetime.timedelta] = None) -> Awaitable[bool]:
"""Wait for `.notify`.
Returns a `.Future` that resolves ``True`` if the condition is notified,
or ``False`` after a timeout.
"""
waiter = Future() # type: Future[bool]
self._waiters.append(waiter)
if timeout:
def on_timeout() -> None:
if not waiter.done():
future_set_result_unless_cancelled(waiter, False)
self._garbage_collect()
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
waiter.add_done_callback(lambda _: io_loop.remove_timeout(timeout_handle))
return waiter
|
python
|
def wait(self, timeout: Union[float, datetime.timedelta] = None) -> Awaitable[bool]:
"""Wait for `.notify`.
Returns a `.Future` that resolves ``True`` if the condition is notified,
or ``False`` after a timeout.
"""
waiter = Future() # type: Future[bool]
self._waiters.append(waiter)
if timeout:
def on_timeout() -> None:
if not waiter.done():
future_set_result_unless_cancelled(waiter, False)
self._garbage_collect()
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
waiter.add_done_callback(lambda _: io_loop.remove_timeout(timeout_handle))
return waiter
|
[
"def",
"wait",
"(",
"self",
",",
"timeout",
":",
"Union",
"[",
"float",
",",
"datetime",
".",
"timedelta",
"]",
"=",
"None",
")",
"->",
"Awaitable",
"[",
"bool",
"]",
":",
"waiter",
"=",
"Future",
"(",
")",
"# type: Future[bool]",
"self",
".",
"_waiters",
".",
"append",
"(",
"waiter",
")",
"if",
"timeout",
":",
"def",
"on_timeout",
"(",
")",
"->",
"None",
":",
"if",
"not",
"waiter",
".",
"done",
"(",
")",
":",
"future_set_result_unless_cancelled",
"(",
"waiter",
",",
"False",
")",
"self",
".",
"_garbage_collect",
"(",
")",
"io_loop",
"=",
"ioloop",
".",
"IOLoop",
".",
"current",
"(",
")",
"timeout_handle",
"=",
"io_loop",
".",
"add_timeout",
"(",
"timeout",
",",
"on_timeout",
")",
"waiter",
".",
"add_done_callback",
"(",
"lambda",
"_",
":",
"io_loop",
".",
"remove_timeout",
"(",
"timeout_handle",
")",
")",
"return",
"waiter"
] |
Wait for `.notify`.
Returns a `.Future` that resolves ``True`` if the condition is notified,
or ``False`` after a timeout.
|
[
"Wait",
"for",
".",
"notify",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/locks.py#L124-L142
|
train
|
tornadoweb/tornado
|
tornado/locks.py
|
Condition.notify
|
def notify(self, n: int = 1) -> None:
"""Wake ``n`` waiters."""
waiters = [] # Waiters we plan to run right now.
while n and self._waiters:
waiter = self._waiters.popleft()
if not waiter.done(): # Might have timed out.
n -= 1
waiters.append(waiter)
for waiter in waiters:
future_set_result_unless_cancelled(waiter, True)
|
python
|
def notify(self, n: int = 1) -> None:
"""Wake ``n`` waiters."""
waiters = [] # Waiters we plan to run right now.
while n and self._waiters:
waiter = self._waiters.popleft()
if not waiter.done(): # Might have timed out.
n -= 1
waiters.append(waiter)
for waiter in waiters:
future_set_result_unless_cancelled(waiter, True)
|
[
"def",
"notify",
"(",
"self",
",",
"n",
":",
"int",
"=",
"1",
")",
"->",
"None",
":",
"waiters",
"=",
"[",
"]",
"# Waiters we plan to run right now.",
"while",
"n",
"and",
"self",
".",
"_waiters",
":",
"waiter",
"=",
"self",
".",
"_waiters",
".",
"popleft",
"(",
")",
"if",
"not",
"waiter",
".",
"done",
"(",
")",
":",
"# Might have timed out.",
"n",
"-=",
"1",
"waiters",
".",
"append",
"(",
"waiter",
")",
"for",
"waiter",
"in",
"waiters",
":",
"future_set_result_unless_cancelled",
"(",
"waiter",
",",
"True",
")"
] |
Wake ``n`` waiters.
|
[
"Wake",
"n",
"waiters",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/locks.py#L144-L154
|
train
|
tornadoweb/tornado
|
tornado/locks.py
|
Event.set
|
def set(self) -> None:
"""Set the internal flag to ``True``. All waiters are awakened.
Calling `.wait` once the flag is set will not block.
"""
if not self._value:
self._value = True
for fut in self._waiters:
if not fut.done():
fut.set_result(None)
|
python
|
def set(self) -> None:
"""Set the internal flag to ``True``. All waiters are awakened.
Calling `.wait` once the flag is set will not block.
"""
if not self._value:
self._value = True
for fut in self._waiters:
if not fut.done():
fut.set_result(None)
|
[
"def",
"set",
"(",
"self",
")",
"->",
"None",
":",
"if",
"not",
"self",
".",
"_value",
":",
"self",
".",
"_value",
"=",
"True",
"for",
"fut",
"in",
"self",
".",
"_waiters",
":",
"if",
"not",
"fut",
".",
"done",
"(",
")",
":",
"fut",
".",
"set_result",
"(",
"None",
")"
] |
Set the internal flag to ``True``. All waiters are awakened.
Calling `.wait` once the flag is set will not block.
|
[
"Set",
"the",
"internal",
"flag",
"to",
"True",
".",
"All",
"waiters",
"are",
"awakened",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/locks.py#L215-L225
|
train
|
tornadoweb/tornado
|
tornado/locks.py
|
Event.wait
|
def wait(self, timeout: Union[float, datetime.timedelta] = None) -> Awaitable[None]:
"""Block until the internal flag is true.
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
"""
fut = Future() # type: Future[None]
if self._value:
fut.set_result(None)
return fut
self._waiters.add(fut)
fut.add_done_callback(lambda fut: self._waiters.remove(fut))
if timeout is None:
return fut
else:
timeout_fut = gen.with_timeout(
timeout, fut, quiet_exceptions=(CancelledError,)
)
# This is a slightly clumsy workaround for the fact that
# gen.with_timeout doesn't cancel its futures. Cancelling
# fut will remove it from the waiters list.
timeout_fut.add_done_callback(
lambda tf: fut.cancel() if not fut.done() else None
)
return timeout_fut
|
python
|
def wait(self, timeout: Union[float, datetime.timedelta] = None) -> Awaitable[None]:
"""Block until the internal flag is true.
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
"""
fut = Future() # type: Future[None]
if self._value:
fut.set_result(None)
return fut
self._waiters.add(fut)
fut.add_done_callback(lambda fut: self._waiters.remove(fut))
if timeout is None:
return fut
else:
timeout_fut = gen.with_timeout(
timeout, fut, quiet_exceptions=(CancelledError,)
)
# This is a slightly clumsy workaround for the fact that
# gen.with_timeout doesn't cancel its futures. Cancelling
# fut will remove it from the waiters list.
timeout_fut.add_done_callback(
lambda tf: fut.cancel() if not fut.done() else None
)
return timeout_fut
|
[
"def",
"wait",
"(",
"self",
",",
"timeout",
":",
"Union",
"[",
"float",
",",
"datetime",
".",
"timedelta",
"]",
"=",
"None",
")",
"->",
"Awaitable",
"[",
"None",
"]",
":",
"fut",
"=",
"Future",
"(",
")",
"# type: Future[None]",
"if",
"self",
".",
"_value",
":",
"fut",
".",
"set_result",
"(",
"None",
")",
"return",
"fut",
"self",
".",
"_waiters",
".",
"add",
"(",
"fut",
")",
"fut",
".",
"add_done_callback",
"(",
"lambda",
"fut",
":",
"self",
".",
"_waiters",
".",
"remove",
"(",
"fut",
")",
")",
"if",
"timeout",
"is",
"None",
":",
"return",
"fut",
"else",
":",
"timeout_fut",
"=",
"gen",
".",
"with_timeout",
"(",
"timeout",
",",
"fut",
",",
"quiet_exceptions",
"=",
"(",
"CancelledError",
",",
")",
")",
"# This is a slightly clumsy workaround for the fact that",
"# gen.with_timeout doesn't cancel its futures. Cancelling",
"# fut will remove it from the waiters list.",
"timeout_fut",
".",
"add_done_callback",
"(",
"lambda",
"tf",
":",
"fut",
".",
"cancel",
"(",
")",
"if",
"not",
"fut",
".",
"done",
"(",
")",
"else",
"None",
")",
"return",
"timeout_fut"
] |
Block until the internal flag is true.
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
|
[
"Block",
"until",
"the",
"internal",
"flag",
"is",
"true",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/locks.py#L234-L258
|
train
|
tornadoweb/tornado
|
tornado/locks.py
|
Semaphore.release
|
def release(self) -> None:
"""Increment the counter and wake one waiter."""
self._value += 1
while self._waiters:
waiter = self._waiters.popleft()
if not waiter.done():
self._value -= 1
# If the waiter is a coroutine paused at
#
# with (yield semaphore.acquire()):
#
# then the context manager's __exit__ calls release() at the end
# of the "with" block.
waiter.set_result(_ReleasingContextManager(self))
break
|
python
|
def release(self) -> None:
"""Increment the counter and wake one waiter."""
self._value += 1
while self._waiters:
waiter = self._waiters.popleft()
if not waiter.done():
self._value -= 1
# If the waiter is a coroutine paused at
#
# with (yield semaphore.acquire()):
#
# then the context manager's __exit__ calls release() at the end
# of the "with" block.
waiter.set_result(_ReleasingContextManager(self))
break
|
[
"def",
"release",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_value",
"+=",
"1",
"while",
"self",
".",
"_waiters",
":",
"waiter",
"=",
"self",
".",
"_waiters",
".",
"popleft",
"(",
")",
"if",
"not",
"waiter",
".",
"done",
"(",
")",
":",
"self",
".",
"_value",
"-=",
"1",
"# If the waiter is a coroutine paused at",
"#",
"# with (yield semaphore.acquire()):",
"#",
"# then the context manager's __exit__ calls release() at the end",
"# of the \"with\" block.",
"waiter",
".",
"set_result",
"(",
"_ReleasingContextManager",
"(",
"self",
")",
")",
"break"
] |
Increment the counter and wake one waiter.
|
[
"Increment",
"the",
"counter",
"and",
"wake",
"one",
"waiter",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/locks.py#L397-L412
|
train
|
tornadoweb/tornado
|
tornado/locks.py
|
Semaphore.acquire
|
def acquire(
self, timeout: Union[float, datetime.timedelta] = None
) -> Awaitable[_ReleasingContextManager]:
"""Decrement the counter. Returns an awaitable.
Block if the counter is zero and wait for a `.release`. The awaitable
raises `.TimeoutError` after the deadline.
"""
waiter = Future() # type: Future[_ReleasingContextManager]
if self._value > 0:
self._value -= 1
waiter.set_result(_ReleasingContextManager(self))
else:
self._waiters.append(waiter)
if timeout:
def on_timeout() -> None:
if not waiter.done():
waiter.set_exception(gen.TimeoutError())
self._garbage_collect()
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
waiter.add_done_callback(
lambda _: io_loop.remove_timeout(timeout_handle)
)
return waiter
|
python
|
def acquire(
self, timeout: Union[float, datetime.timedelta] = None
) -> Awaitable[_ReleasingContextManager]:
"""Decrement the counter. Returns an awaitable.
Block if the counter is zero and wait for a `.release`. The awaitable
raises `.TimeoutError` after the deadline.
"""
waiter = Future() # type: Future[_ReleasingContextManager]
if self._value > 0:
self._value -= 1
waiter.set_result(_ReleasingContextManager(self))
else:
self._waiters.append(waiter)
if timeout:
def on_timeout() -> None:
if not waiter.done():
waiter.set_exception(gen.TimeoutError())
self._garbage_collect()
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
waiter.add_done_callback(
lambda _: io_loop.remove_timeout(timeout_handle)
)
return waiter
|
[
"def",
"acquire",
"(",
"self",
",",
"timeout",
":",
"Union",
"[",
"float",
",",
"datetime",
".",
"timedelta",
"]",
"=",
"None",
")",
"->",
"Awaitable",
"[",
"_ReleasingContextManager",
"]",
":",
"waiter",
"=",
"Future",
"(",
")",
"# type: Future[_ReleasingContextManager]",
"if",
"self",
".",
"_value",
">",
"0",
":",
"self",
".",
"_value",
"-=",
"1",
"waiter",
".",
"set_result",
"(",
"_ReleasingContextManager",
"(",
"self",
")",
")",
"else",
":",
"self",
".",
"_waiters",
".",
"append",
"(",
"waiter",
")",
"if",
"timeout",
":",
"def",
"on_timeout",
"(",
")",
"->",
"None",
":",
"if",
"not",
"waiter",
".",
"done",
"(",
")",
":",
"waiter",
".",
"set_exception",
"(",
"gen",
".",
"TimeoutError",
"(",
")",
")",
"self",
".",
"_garbage_collect",
"(",
")",
"io_loop",
"=",
"ioloop",
".",
"IOLoop",
".",
"current",
"(",
")",
"timeout_handle",
"=",
"io_loop",
".",
"add_timeout",
"(",
"timeout",
",",
"on_timeout",
")",
"waiter",
".",
"add_done_callback",
"(",
"lambda",
"_",
":",
"io_loop",
".",
"remove_timeout",
"(",
"timeout_handle",
")",
")",
"return",
"waiter"
] |
Decrement the counter. Returns an awaitable.
Block if the counter is zero and wait for a `.release`. The awaitable
raises `.TimeoutError` after the deadline.
|
[
"Decrement",
"the",
"counter",
".",
"Returns",
"an",
"awaitable",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/locks.py#L414-L440
|
train
|
tornadoweb/tornado
|
tornado/locks.py
|
BoundedSemaphore.release
|
def release(self) -> None:
"""Increment the counter and wake one waiter."""
if self._value >= self._initial_value:
raise ValueError("Semaphore released too many times")
super(BoundedSemaphore, self).release()
|
python
|
def release(self) -> None:
"""Increment the counter and wake one waiter."""
if self._value >= self._initial_value:
raise ValueError("Semaphore released too many times")
super(BoundedSemaphore, self).release()
|
[
"def",
"release",
"(",
"self",
")",
"->",
"None",
":",
"if",
"self",
".",
"_value",
">=",
"self",
".",
"_initial_value",
":",
"raise",
"ValueError",
"(",
"\"Semaphore released too many times\"",
")",
"super",
"(",
"BoundedSemaphore",
",",
"self",
")",
".",
"release",
"(",
")"
] |
Increment the counter and wake one waiter.
|
[
"Increment",
"the",
"counter",
"and",
"wake",
"one",
"waiter",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/locks.py#L478-L482
|
train
|
tornadoweb/tornado
|
tornado/locks.py
|
Lock.acquire
|
def acquire(
self, timeout: Union[float, datetime.timedelta] = None
) -> Awaitable[_ReleasingContextManager]:
"""Attempt to lock. Returns an awaitable.
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
"""
return self._block.acquire(timeout)
|
python
|
def acquire(
self, timeout: Union[float, datetime.timedelta] = None
) -> Awaitable[_ReleasingContextManager]:
"""Attempt to lock. Returns an awaitable.
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
"""
return self._block.acquire(timeout)
|
[
"def",
"acquire",
"(",
"self",
",",
"timeout",
":",
"Union",
"[",
"float",
",",
"datetime",
".",
"timedelta",
"]",
"=",
"None",
")",
"->",
"Awaitable",
"[",
"_ReleasingContextManager",
"]",
":",
"return",
"self",
".",
"_block",
".",
"acquire",
"(",
"timeout",
")"
] |
Attempt to lock. Returns an awaitable.
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
|
[
"Attempt",
"to",
"lock",
".",
"Returns",
"an",
"awaitable",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/locks.py#L528-L536
|
train
|
tornadoweb/tornado
|
tornado/http1connection.py
|
HTTP1Connection.read_response
|
def read_response(self, delegate: httputil.HTTPMessageDelegate) -> Awaitable[bool]:
"""Read a single HTTP response.
Typical client-mode usage is to write a request using `write_headers`,
`write`, and `finish`, and then call ``read_response``.
:arg delegate: a `.HTTPMessageDelegate`
Returns a `.Future` that resolves to a bool after the full response has
been read. The result is true if the stream is still open.
"""
if self.params.decompress:
delegate = _GzipMessageDelegate(delegate, self.params.chunk_size)
return self._read_message(delegate)
|
python
|
def read_response(self, delegate: httputil.HTTPMessageDelegate) -> Awaitable[bool]:
"""Read a single HTTP response.
Typical client-mode usage is to write a request using `write_headers`,
`write`, and `finish`, and then call ``read_response``.
:arg delegate: a `.HTTPMessageDelegate`
Returns a `.Future` that resolves to a bool after the full response has
been read. The result is true if the stream is still open.
"""
if self.params.decompress:
delegate = _GzipMessageDelegate(delegate, self.params.chunk_size)
return self._read_message(delegate)
|
[
"def",
"read_response",
"(",
"self",
",",
"delegate",
":",
"httputil",
".",
"HTTPMessageDelegate",
")",
"->",
"Awaitable",
"[",
"bool",
"]",
":",
"if",
"self",
".",
"params",
".",
"decompress",
":",
"delegate",
"=",
"_GzipMessageDelegate",
"(",
"delegate",
",",
"self",
".",
"params",
".",
"chunk_size",
")",
"return",
"self",
".",
"_read_message",
"(",
"delegate",
")"
] |
Read a single HTTP response.
Typical client-mode usage is to write a request using `write_headers`,
`write`, and `finish`, and then call ``read_response``.
:arg delegate: a `.HTTPMessageDelegate`
Returns a `.Future` that resolves to a bool after the full response has
been read. The result is true if the stream is still open.
|
[
"Read",
"a",
"single",
"HTTP",
"response",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/http1connection.py#L165-L178
|
train
|
tornadoweb/tornado
|
tornado/http1connection.py
|
HTTP1Connection._clear_callbacks
|
def _clear_callbacks(self) -> None:
"""Clears the callback attributes.
This allows the request handler to be garbage collected more
quickly in CPython by breaking up reference cycles.
"""
self._write_callback = None
self._write_future = None # type: Optional[Future[None]]
self._close_callback = None # type: Optional[Callable[[], None]]
if self.stream is not None:
self.stream.set_close_callback(None)
|
python
|
def _clear_callbacks(self) -> None:
"""Clears the callback attributes.
This allows the request handler to be garbage collected more
quickly in CPython by breaking up reference cycles.
"""
self._write_callback = None
self._write_future = None # type: Optional[Future[None]]
self._close_callback = None # type: Optional[Callable[[], None]]
if self.stream is not None:
self.stream.set_close_callback(None)
|
[
"def",
"_clear_callbacks",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_write_callback",
"=",
"None",
"self",
".",
"_write_future",
"=",
"None",
"# type: Optional[Future[None]]",
"self",
".",
"_close_callback",
"=",
"None",
"# type: Optional[Callable[[], None]]",
"if",
"self",
".",
"stream",
"is",
"not",
"None",
":",
"self",
".",
"stream",
".",
"set_close_callback",
"(",
"None",
")"
] |
Clears the callback attributes.
This allows the request handler to be garbage collected more
quickly in CPython by breaking up reference cycles.
|
[
"Clears",
"the",
"callback",
"attributes",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/http1connection.py#L302-L312
|
train
|
tornadoweb/tornado
|
tornado/http1connection.py
|
HTTP1Connection.detach
|
def detach(self) -> iostream.IOStream:
"""Take control of the underlying stream.
Returns the underlying `.IOStream` object and stops all further
HTTP processing. May only be called during
`.HTTPMessageDelegate.headers_received`. Intended for implementing
protocols like websockets that tunnel over an HTTP handshake.
"""
self._clear_callbacks()
stream = self.stream
self.stream = None # type: ignore
if not self._finish_future.done():
future_set_result_unless_cancelled(self._finish_future, None)
return stream
|
python
|
def detach(self) -> iostream.IOStream:
"""Take control of the underlying stream.
Returns the underlying `.IOStream` object and stops all further
HTTP processing. May only be called during
`.HTTPMessageDelegate.headers_received`. Intended for implementing
protocols like websockets that tunnel over an HTTP handshake.
"""
self._clear_callbacks()
stream = self.stream
self.stream = None # type: ignore
if not self._finish_future.done():
future_set_result_unless_cancelled(self._finish_future, None)
return stream
|
[
"def",
"detach",
"(",
"self",
")",
"->",
"iostream",
".",
"IOStream",
":",
"self",
".",
"_clear_callbacks",
"(",
")",
"stream",
"=",
"self",
".",
"stream",
"self",
".",
"stream",
"=",
"None",
"# type: ignore",
"if",
"not",
"self",
".",
"_finish_future",
".",
"done",
"(",
")",
":",
"future_set_result_unless_cancelled",
"(",
"self",
".",
"_finish_future",
",",
"None",
")",
"return",
"stream"
] |
Take control of the underlying stream.
Returns the underlying `.IOStream` object and stops all further
HTTP processing. May only be called during
`.HTTPMessageDelegate.headers_received`. Intended for implementing
protocols like websockets that tunnel over an HTTP handshake.
|
[
"Take",
"control",
"of",
"the",
"underlying",
"stream",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/http1connection.py#L347-L360
|
train
|
tornadoweb/tornado
|
tornado/http1connection.py
|
HTTP1Connection.write_headers
|
def write_headers(
self,
start_line: Union[httputil.RequestStartLine, httputil.ResponseStartLine],
headers: httputil.HTTPHeaders,
chunk: bytes = None,
) -> "Future[None]":
"""Implements `.HTTPConnection.write_headers`."""
lines = []
if self.is_client:
assert isinstance(start_line, httputil.RequestStartLine)
self._request_start_line = start_line
lines.append(utf8("%s %s HTTP/1.1" % (start_line[0], start_line[1])))
# Client requests with a non-empty body must have either a
# Content-Length or a Transfer-Encoding.
self._chunking_output = (
start_line.method in ("POST", "PUT", "PATCH")
and "Content-Length" not in headers
and (
"Transfer-Encoding" not in headers
or headers["Transfer-Encoding"] == "chunked"
)
)
else:
assert isinstance(start_line, httputil.ResponseStartLine)
assert self._request_start_line is not None
assert self._request_headers is not None
self._response_start_line = start_line
lines.append(utf8("HTTP/1.1 %d %s" % (start_line[1], start_line[2])))
self._chunking_output = (
# TODO: should this use
# self._request_start_line.version or
# start_line.version?
self._request_start_line.version == "HTTP/1.1"
# 1xx, 204 and 304 responses have no body (not even a zero-length
# body), and so should not have either Content-Length or
# Transfer-Encoding headers.
and start_line.code not in (204, 304)
and (start_line.code < 100 or start_line.code >= 200)
# No need to chunk the output if a Content-Length is specified.
and "Content-Length" not in headers
# Applications are discouraged from touching Transfer-Encoding,
# but if they do, leave it alone.
and "Transfer-Encoding" not in headers
)
# If connection to a 1.1 client will be closed, inform client
if (
self._request_start_line.version == "HTTP/1.1"
and self._disconnect_on_finish
):
headers["Connection"] = "close"
# If a 1.0 client asked for keep-alive, add the header.
if (
self._request_start_line.version == "HTTP/1.0"
and self._request_headers.get("Connection", "").lower() == "keep-alive"
):
headers["Connection"] = "Keep-Alive"
if self._chunking_output:
headers["Transfer-Encoding"] = "chunked"
if not self.is_client and (
self._request_start_line.method == "HEAD"
or cast(httputil.ResponseStartLine, start_line).code == 304
):
self._expected_content_remaining = 0
elif "Content-Length" in headers:
self._expected_content_remaining = int(headers["Content-Length"])
else:
self._expected_content_remaining = None
# TODO: headers are supposed to be of type str, but we still have some
# cases that let bytes slip through. Remove these native_str calls when those
# are fixed.
header_lines = (
native_str(n) + ": " + native_str(v) for n, v in headers.get_all()
)
lines.extend(l.encode("latin1") for l in header_lines)
for line in lines:
if b"\n" in line:
raise ValueError("Newline in header: " + repr(line))
future = None
if self.stream.closed():
future = self._write_future = Future()
future.set_exception(iostream.StreamClosedError())
future.exception()
else:
future = self._write_future = Future()
data = b"\r\n".join(lines) + b"\r\n\r\n"
if chunk:
data += self._format_chunk(chunk)
self._pending_write = self.stream.write(data)
future_add_done_callback(self._pending_write, self._on_write_complete)
return future
|
python
|
def write_headers(
self,
start_line: Union[httputil.RequestStartLine, httputil.ResponseStartLine],
headers: httputil.HTTPHeaders,
chunk: bytes = None,
) -> "Future[None]":
"""Implements `.HTTPConnection.write_headers`."""
lines = []
if self.is_client:
assert isinstance(start_line, httputil.RequestStartLine)
self._request_start_line = start_line
lines.append(utf8("%s %s HTTP/1.1" % (start_line[0], start_line[1])))
# Client requests with a non-empty body must have either a
# Content-Length or a Transfer-Encoding.
self._chunking_output = (
start_line.method in ("POST", "PUT", "PATCH")
and "Content-Length" not in headers
and (
"Transfer-Encoding" not in headers
or headers["Transfer-Encoding"] == "chunked"
)
)
else:
assert isinstance(start_line, httputil.ResponseStartLine)
assert self._request_start_line is not None
assert self._request_headers is not None
self._response_start_line = start_line
lines.append(utf8("HTTP/1.1 %d %s" % (start_line[1], start_line[2])))
self._chunking_output = (
# TODO: should this use
# self._request_start_line.version or
# start_line.version?
self._request_start_line.version == "HTTP/1.1"
# 1xx, 204 and 304 responses have no body (not even a zero-length
# body), and so should not have either Content-Length or
# Transfer-Encoding headers.
and start_line.code not in (204, 304)
and (start_line.code < 100 or start_line.code >= 200)
# No need to chunk the output if a Content-Length is specified.
and "Content-Length" not in headers
# Applications are discouraged from touching Transfer-Encoding,
# but if they do, leave it alone.
and "Transfer-Encoding" not in headers
)
# If connection to a 1.1 client will be closed, inform client
if (
self._request_start_line.version == "HTTP/1.1"
and self._disconnect_on_finish
):
headers["Connection"] = "close"
# If a 1.0 client asked for keep-alive, add the header.
if (
self._request_start_line.version == "HTTP/1.0"
and self._request_headers.get("Connection", "").lower() == "keep-alive"
):
headers["Connection"] = "Keep-Alive"
if self._chunking_output:
headers["Transfer-Encoding"] = "chunked"
if not self.is_client and (
self._request_start_line.method == "HEAD"
or cast(httputil.ResponseStartLine, start_line).code == 304
):
self._expected_content_remaining = 0
elif "Content-Length" in headers:
self._expected_content_remaining = int(headers["Content-Length"])
else:
self._expected_content_remaining = None
# TODO: headers are supposed to be of type str, but we still have some
# cases that let bytes slip through. Remove these native_str calls when those
# are fixed.
header_lines = (
native_str(n) + ": " + native_str(v) for n, v in headers.get_all()
)
lines.extend(l.encode("latin1") for l in header_lines)
for line in lines:
if b"\n" in line:
raise ValueError("Newline in header: " + repr(line))
future = None
if self.stream.closed():
future = self._write_future = Future()
future.set_exception(iostream.StreamClosedError())
future.exception()
else:
future = self._write_future = Future()
data = b"\r\n".join(lines) + b"\r\n\r\n"
if chunk:
data += self._format_chunk(chunk)
self._pending_write = self.stream.write(data)
future_add_done_callback(self._pending_write, self._on_write_complete)
return future
|
[
"def",
"write_headers",
"(",
"self",
",",
"start_line",
":",
"Union",
"[",
"httputil",
".",
"RequestStartLine",
",",
"httputil",
".",
"ResponseStartLine",
"]",
",",
"headers",
":",
"httputil",
".",
"HTTPHeaders",
",",
"chunk",
":",
"bytes",
"=",
"None",
",",
")",
"->",
"\"Future[None]\"",
":",
"lines",
"=",
"[",
"]",
"if",
"self",
".",
"is_client",
":",
"assert",
"isinstance",
"(",
"start_line",
",",
"httputil",
".",
"RequestStartLine",
")",
"self",
".",
"_request_start_line",
"=",
"start_line",
"lines",
".",
"append",
"(",
"utf8",
"(",
"\"%s %s HTTP/1.1\"",
"%",
"(",
"start_line",
"[",
"0",
"]",
",",
"start_line",
"[",
"1",
"]",
")",
")",
")",
"# Client requests with a non-empty body must have either a",
"# Content-Length or a Transfer-Encoding.",
"self",
".",
"_chunking_output",
"=",
"(",
"start_line",
".",
"method",
"in",
"(",
"\"POST\"",
",",
"\"PUT\"",
",",
"\"PATCH\"",
")",
"and",
"\"Content-Length\"",
"not",
"in",
"headers",
"and",
"(",
"\"Transfer-Encoding\"",
"not",
"in",
"headers",
"or",
"headers",
"[",
"\"Transfer-Encoding\"",
"]",
"==",
"\"chunked\"",
")",
")",
"else",
":",
"assert",
"isinstance",
"(",
"start_line",
",",
"httputil",
".",
"ResponseStartLine",
")",
"assert",
"self",
".",
"_request_start_line",
"is",
"not",
"None",
"assert",
"self",
".",
"_request_headers",
"is",
"not",
"None",
"self",
".",
"_response_start_line",
"=",
"start_line",
"lines",
".",
"append",
"(",
"utf8",
"(",
"\"HTTP/1.1 %d %s\"",
"%",
"(",
"start_line",
"[",
"1",
"]",
",",
"start_line",
"[",
"2",
"]",
")",
")",
")",
"self",
".",
"_chunking_output",
"=",
"(",
"# TODO: should this use",
"# self._request_start_line.version or",
"# start_line.version?",
"self",
".",
"_request_start_line",
".",
"version",
"==",
"\"HTTP/1.1\"",
"# 1xx, 204 and 304 responses have no body (not even a zero-length",
"# body), and so should not have either Content-Length or",
"# Transfer-Encoding headers.",
"and",
"start_line",
".",
"code",
"not",
"in",
"(",
"204",
",",
"304",
")",
"and",
"(",
"start_line",
".",
"code",
"<",
"100",
"or",
"start_line",
".",
"code",
">=",
"200",
")",
"# No need to chunk the output if a Content-Length is specified.",
"and",
"\"Content-Length\"",
"not",
"in",
"headers",
"# Applications are discouraged from touching Transfer-Encoding,",
"# but if they do, leave it alone.",
"and",
"\"Transfer-Encoding\"",
"not",
"in",
"headers",
")",
"# If connection to a 1.1 client will be closed, inform client",
"if",
"(",
"self",
".",
"_request_start_line",
".",
"version",
"==",
"\"HTTP/1.1\"",
"and",
"self",
".",
"_disconnect_on_finish",
")",
":",
"headers",
"[",
"\"Connection\"",
"]",
"=",
"\"close\"",
"# If a 1.0 client asked for keep-alive, add the header.",
"if",
"(",
"self",
".",
"_request_start_line",
".",
"version",
"==",
"\"HTTP/1.0\"",
"and",
"self",
".",
"_request_headers",
".",
"get",
"(",
"\"Connection\"",
",",
"\"\"",
")",
".",
"lower",
"(",
")",
"==",
"\"keep-alive\"",
")",
":",
"headers",
"[",
"\"Connection\"",
"]",
"=",
"\"Keep-Alive\"",
"if",
"self",
".",
"_chunking_output",
":",
"headers",
"[",
"\"Transfer-Encoding\"",
"]",
"=",
"\"chunked\"",
"if",
"not",
"self",
".",
"is_client",
"and",
"(",
"self",
".",
"_request_start_line",
".",
"method",
"==",
"\"HEAD\"",
"or",
"cast",
"(",
"httputil",
".",
"ResponseStartLine",
",",
"start_line",
")",
".",
"code",
"==",
"304",
")",
":",
"self",
".",
"_expected_content_remaining",
"=",
"0",
"elif",
"\"Content-Length\"",
"in",
"headers",
":",
"self",
".",
"_expected_content_remaining",
"=",
"int",
"(",
"headers",
"[",
"\"Content-Length\"",
"]",
")",
"else",
":",
"self",
".",
"_expected_content_remaining",
"=",
"None",
"# TODO: headers are supposed to be of type str, but we still have some",
"# cases that let bytes slip through. Remove these native_str calls when those",
"# are fixed.",
"header_lines",
"=",
"(",
"native_str",
"(",
"n",
")",
"+",
"\": \"",
"+",
"native_str",
"(",
"v",
")",
"for",
"n",
",",
"v",
"in",
"headers",
".",
"get_all",
"(",
")",
")",
"lines",
".",
"extend",
"(",
"l",
".",
"encode",
"(",
"\"latin1\"",
")",
"for",
"l",
"in",
"header_lines",
")",
"for",
"line",
"in",
"lines",
":",
"if",
"b\"\\n\"",
"in",
"line",
":",
"raise",
"ValueError",
"(",
"\"Newline in header: \"",
"+",
"repr",
"(",
"line",
")",
")",
"future",
"=",
"None",
"if",
"self",
".",
"stream",
".",
"closed",
"(",
")",
":",
"future",
"=",
"self",
".",
"_write_future",
"=",
"Future",
"(",
")",
"future",
".",
"set_exception",
"(",
"iostream",
".",
"StreamClosedError",
"(",
")",
")",
"future",
".",
"exception",
"(",
")",
"else",
":",
"future",
"=",
"self",
".",
"_write_future",
"=",
"Future",
"(",
")",
"data",
"=",
"b\"\\r\\n\"",
".",
"join",
"(",
"lines",
")",
"+",
"b\"\\r\\n\\r\\n\"",
"if",
"chunk",
":",
"data",
"+=",
"self",
".",
"_format_chunk",
"(",
"chunk",
")",
"self",
".",
"_pending_write",
"=",
"self",
".",
"stream",
".",
"write",
"(",
"data",
")",
"future_add_done_callback",
"(",
"self",
".",
"_pending_write",
",",
"self",
".",
"_on_write_complete",
")",
"return",
"future"
] |
Implements `.HTTPConnection.write_headers`.
|
[
"Implements",
".",
"HTTPConnection",
".",
"write_headers",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/http1connection.py#L376-L465
|
train
|
tornadoweb/tornado
|
tornado/http1connection.py
|
HTTP1Connection.write
|
def write(self, chunk: bytes) -> "Future[None]":
"""Implements `.HTTPConnection.write`.
For backwards compatibility it is allowed but deprecated to
skip `write_headers` and instead call `write()` with a
pre-encoded header block.
"""
future = None
if self.stream.closed():
future = self._write_future = Future()
self._write_future.set_exception(iostream.StreamClosedError())
self._write_future.exception()
else:
future = self._write_future = Future()
self._pending_write = self.stream.write(self._format_chunk(chunk))
future_add_done_callback(self._pending_write, self._on_write_complete)
return future
|
python
|
def write(self, chunk: bytes) -> "Future[None]":
"""Implements `.HTTPConnection.write`.
For backwards compatibility it is allowed but deprecated to
skip `write_headers` and instead call `write()` with a
pre-encoded header block.
"""
future = None
if self.stream.closed():
future = self._write_future = Future()
self._write_future.set_exception(iostream.StreamClosedError())
self._write_future.exception()
else:
future = self._write_future = Future()
self._pending_write = self.stream.write(self._format_chunk(chunk))
future_add_done_callback(self._pending_write, self._on_write_complete)
return future
|
[
"def",
"write",
"(",
"self",
",",
"chunk",
":",
"bytes",
")",
"->",
"\"Future[None]\"",
":",
"future",
"=",
"None",
"if",
"self",
".",
"stream",
".",
"closed",
"(",
")",
":",
"future",
"=",
"self",
".",
"_write_future",
"=",
"Future",
"(",
")",
"self",
".",
"_write_future",
".",
"set_exception",
"(",
"iostream",
".",
"StreamClosedError",
"(",
")",
")",
"self",
".",
"_write_future",
".",
"exception",
"(",
")",
"else",
":",
"future",
"=",
"self",
".",
"_write_future",
"=",
"Future",
"(",
")",
"self",
".",
"_pending_write",
"=",
"self",
".",
"stream",
".",
"write",
"(",
"self",
".",
"_format_chunk",
"(",
"chunk",
")",
")",
"future_add_done_callback",
"(",
"self",
".",
"_pending_write",
",",
"self",
".",
"_on_write_complete",
")",
"return",
"future"
] |
Implements `.HTTPConnection.write`.
For backwards compatibility it is allowed but deprecated to
skip `write_headers` and instead call `write()` with a
pre-encoded header block.
|
[
"Implements",
".",
"HTTPConnection",
".",
"write",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/http1connection.py#L483-L499
|
train
|
tornadoweb/tornado
|
tornado/http1connection.py
|
HTTP1Connection.finish
|
def finish(self) -> None:
"""Implements `.HTTPConnection.finish`."""
if (
self._expected_content_remaining is not None
and self._expected_content_remaining != 0
and not self.stream.closed()
):
self.stream.close()
raise httputil.HTTPOutputError(
"Tried to write %d bytes less than Content-Length"
% self._expected_content_remaining
)
if self._chunking_output:
if not self.stream.closed():
self._pending_write = self.stream.write(b"0\r\n\r\n")
self._pending_write.add_done_callback(self._on_write_complete)
self._write_finished = True
# If the app finished the request while we're still reading,
# divert any remaining data away from the delegate and
# close the connection when we're done sending our response.
# Closing the connection is the only way to avoid reading the
# whole input body.
if not self._read_finished:
self._disconnect_on_finish = True
# No more data is coming, so instruct TCP to send any remaining
# data immediately instead of waiting for a full packet or ack.
self.stream.set_nodelay(True)
if self._pending_write is None:
self._finish_request(None)
else:
future_add_done_callback(self._pending_write, self._finish_request)
|
python
|
def finish(self) -> None:
"""Implements `.HTTPConnection.finish`."""
if (
self._expected_content_remaining is not None
and self._expected_content_remaining != 0
and not self.stream.closed()
):
self.stream.close()
raise httputil.HTTPOutputError(
"Tried to write %d bytes less than Content-Length"
% self._expected_content_remaining
)
if self._chunking_output:
if not self.stream.closed():
self._pending_write = self.stream.write(b"0\r\n\r\n")
self._pending_write.add_done_callback(self._on_write_complete)
self._write_finished = True
# If the app finished the request while we're still reading,
# divert any remaining data away from the delegate and
# close the connection when we're done sending our response.
# Closing the connection is the only way to avoid reading the
# whole input body.
if not self._read_finished:
self._disconnect_on_finish = True
# No more data is coming, so instruct TCP to send any remaining
# data immediately instead of waiting for a full packet or ack.
self.stream.set_nodelay(True)
if self._pending_write is None:
self._finish_request(None)
else:
future_add_done_callback(self._pending_write, self._finish_request)
|
[
"def",
"finish",
"(",
"self",
")",
"->",
"None",
":",
"if",
"(",
"self",
".",
"_expected_content_remaining",
"is",
"not",
"None",
"and",
"self",
".",
"_expected_content_remaining",
"!=",
"0",
"and",
"not",
"self",
".",
"stream",
".",
"closed",
"(",
")",
")",
":",
"self",
".",
"stream",
".",
"close",
"(",
")",
"raise",
"httputil",
".",
"HTTPOutputError",
"(",
"\"Tried to write %d bytes less than Content-Length\"",
"%",
"self",
".",
"_expected_content_remaining",
")",
"if",
"self",
".",
"_chunking_output",
":",
"if",
"not",
"self",
".",
"stream",
".",
"closed",
"(",
")",
":",
"self",
".",
"_pending_write",
"=",
"self",
".",
"stream",
".",
"write",
"(",
"b\"0\\r\\n\\r\\n\"",
")",
"self",
".",
"_pending_write",
".",
"add_done_callback",
"(",
"self",
".",
"_on_write_complete",
")",
"self",
".",
"_write_finished",
"=",
"True",
"# If the app finished the request while we're still reading,",
"# divert any remaining data away from the delegate and",
"# close the connection when we're done sending our response.",
"# Closing the connection is the only way to avoid reading the",
"# whole input body.",
"if",
"not",
"self",
".",
"_read_finished",
":",
"self",
".",
"_disconnect_on_finish",
"=",
"True",
"# No more data is coming, so instruct TCP to send any remaining",
"# data immediately instead of waiting for a full packet or ack.",
"self",
".",
"stream",
".",
"set_nodelay",
"(",
"True",
")",
"if",
"self",
".",
"_pending_write",
"is",
"None",
":",
"self",
".",
"_finish_request",
"(",
"None",
")",
"else",
":",
"future_add_done_callback",
"(",
"self",
".",
"_pending_write",
",",
"self",
".",
"_finish_request",
")"
] |
Implements `.HTTPConnection.finish`.
|
[
"Implements",
".",
"HTTPConnection",
".",
"finish",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/http1connection.py#L501-L531
|
train
|
tornadoweb/tornado
|
tornado/http1connection.py
|
HTTP1ServerConnection.close
|
async def close(self) -> None:
"""Closes the connection.
Returns a `.Future` that resolves after the serving loop has exited.
"""
self.stream.close()
# Block until the serving loop is done, but ignore any exceptions
# (start_serving is already responsible for logging them).
assert self._serving_future is not None
try:
await self._serving_future
except Exception:
pass
|
python
|
async def close(self) -> None:
"""Closes the connection.
Returns a `.Future` that resolves after the serving loop has exited.
"""
self.stream.close()
# Block until the serving loop is done, but ignore any exceptions
# (start_serving is already responsible for logging them).
assert self._serving_future is not None
try:
await self._serving_future
except Exception:
pass
|
[
"async",
"def",
"close",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"stream",
".",
"close",
"(",
")",
"# Block until the serving loop is done, but ignore any exceptions",
"# (start_serving is already responsible for logging them).",
"assert",
"self",
".",
"_serving_future",
"is",
"not",
"None",
"try",
":",
"await",
"self",
".",
"_serving_future",
"except",
"Exception",
":",
"pass"
] |
Closes the connection.
Returns a `.Future` that resolves after the serving loop has exited.
|
[
"Closes",
"the",
"connection",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/http1connection.py#L784-L796
|
train
|
tornadoweb/tornado
|
tornado/http1connection.py
|
HTTP1ServerConnection.start_serving
|
def start_serving(self, delegate: httputil.HTTPServerConnectionDelegate) -> None:
"""Starts serving requests on this connection.
:arg delegate: a `.HTTPServerConnectionDelegate`
"""
assert isinstance(delegate, httputil.HTTPServerConnectionDelegate)
fut = gen.convert_yielded(self._server_request_loop(delegate))
self._serving_future = fut
# Register the future on the IOLoop so its errors get logged.
self.stream.io_loop.add_future(fut, lambda f: f.result())
|
python
|
def start_serving(self, delegate: httputil.HTTPServerConnectionDelegate) -> None:
"""Starts serving requests on this connection.
:arg delegate: a `.HTTPServerConnectionDelegate`
"""
assert isinstance(delegate, httputil.HTTPServerConnectionDelegate)
fut = gen.convert_yielded(self._server_request_loop(delegate))
self._serving_future = fut
# Register the future on the IOLoop so its errors get logged.
self.stream.io_loop.add_future(fut, lambda f: f.result())
|
[
"def",
"start_serving",
"(",
"self",
",",
"delegate",
":",
"httputil",
".",
"HTTPServerConnectionDelegate",
")",
"->",
"None",
":",
"assert",
"isinstance",
"(",
"delegate",
",",
"httputil",
".",
"HTTPServerConnectionDelegate",
")",
"fut",
"=",
"gen",
".",
"convert_yielded",
"(",
"self",
".",
"_server_request_loop",
"(",
"delegate",
")",
")",
"self",
".",
"_serving_future",
"=",
"fut",
"# Register the future on the IOLoop so its errors get logged.",
"self",
".",
"stream",
".",
"io_loop",
".",
"add_future",
"(",
"fut",
",",
"lambda",
"f",
":",
"f",
".",
"result",
"(",
")",
")"
] |
Starts serving requests on this connection.
:arg delegate: a `.HTTPServerConnectionDelegate`
|
[
"Starts",
"serving",
"requests",
"on",
"this",
"connection",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/http1connection.py#L798-L807
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
websocket_connect
|
def websocket_connect(
url: Union[str, httpclient.HTTPRequest],
callback: Callable[["Future[WebSocketClientConnection]"], None] = None,
connect_timeout: float = None,
on_message_callback: Callable[[Union[None, str, bytes]], None] = None,
compression_options: Dict[str, Any] = None,
ping_interval: float = None,
ping_timeout: float = None,
max_message_size: int = _default_max_message_size,
subprotocols: List[str] = None,
) -> "Awaitable[WebSocketClientConnection]":
"""Client-side websocket support.
Takes a url and returns a Future whose result is a
`WebSocketClientConnection`.
``compression_options`` is interpreted in the same way as the
return value of `.WebSocketHandler.get_compression_options`.
The connection supports two styles of operation. In the coroutine
style, the application typically calls
`~.WebSocketClientConnection.read_message` in a loop::
conn = yield websocket_connect(url)
while True:
msg = yield conn.read_message()
if msg is None: break
# Do something with msg
In the callback style, pass an ``on_message_callback`` to
``websocket_connect``. In both styles, a message of ``None``
indicates that the connection has been closed.
``subprotocols`` may be a list of strings specifying proposed
subprotocols. The selected protocol may be found on the
``selected_subprotocol`` attribute of the connection object
when the connection is complete.
.. versionchanged:: 3.2
Also accepts ``HTTPRequest`` objects in place of urls.
.. versionchanged:: 4.1
Added ``compression_options`` and ``on_message_callback``.
.. versionchanged:: 4.5
Added the ``ping_interval``, ``ping_timeout``, and ``max_message_size``
arguments, which have the same meaning as in `WebSocketHandler`.
.. versionchanged:: 5.0
The ``io_loop`` argument (deprecated since version 4.1) has been removed.
.. versionchanged:: 5.1
Added the ``subprotocols`` argument.
"""
if isinstance(url, httpclient.HTTPRequest):
assert connect_timeout is None
request = url
# Copy and convert the headers dict/object (see comments in
# AsyncHTTPClient.fetch)
request.headers = httputil.HTTPHeaders(request.headers)
else:
request = httpclient.HTTPRequest(url, connect_timeout=connect_timeout)
request = cast(
httpclient.HTTPRequest,
httpclient._RequestProxy(request, httpclient.HTTPRequest._DEFAULTS),
)
conn = WebSocketClientConnection(
request,
on_message_callback=on_message_callback,
compression_options=compression_options,
ping_interval=ping_interval,
ping_timeout=ping_timeout,
max_message_size=max_message_size,
subprotocols=subprotocols,
)
if callback is not None:
IOLoop.current().add_future(conn.connect_future, callback)
return conn.connect_future
|
python
|
def websocket_connect(
url: Union[str, httpclient.HTTPRequest],
callback: Callable[["Future[WebSocketClientConnection]"], None] = None,
connect_timeout: float = None,
on_message_callback: Callable[[Union[None, str, bytes]], None] = None,
compression_options: Dict[str, Any] = None,
ping_interval: float = None,
ping_timeout: float = None,
max_message_size: int = _default_max_message_size,
subprotocols: List[str] = None,
) -> "Awaitable[WebSocketClientConnection]":
"""Client-side websocket support.
Takes a url and returns a Future whose result is a
`WebSocketClientConnection`.
``compression_options`` is interpreted in the same way as the
return value of `.WebSocketHandler.get_compression_options`.
The connection supports two styles of operation. In the coroutine
style, the application typically calls
`~.WebSocketClientConnection.read_message` in a loop::
conn = yield websocket_connect(url)
while True:
msg = yield conn.read_message()
if msg is None: break
# Do something with msg
In the callback style, pass an ``on_message_callback`` to
``websocket_connect``. In both styles, a message of ``None``
indicates that the connection has been closed.
``subprotocols`` may be a list of strings specifying proposed
subprotocols. The selected protocol may be found on the
``selected_subprotocol`` attribute of the connection object
when the connection is complete.
.. versionchanged:: 3.2
Also accepts ``HTTPRequest`` objects in place of urls.
.. versionchanged:: 4.1
Added ``compression_options`` and ``on_message_callback``.
.. versionchanged:: 4.5
Added the ``ping_interval``, ``ping_timeout``, and ``max_message_size``
arguments, which have the same meaning as in `WebSocketHandler`.
.. versionchanged:: 5.0
The ``io_loop`` argument (deprecated since version 4.1) has been removed.
.. versionchanged:: 5.1
Added the ``subprotocols`` argument.
"""
if isinstance(url, httpclient.HTTPRequest):
assert connect_timeout is None
request = url
# Copy and convert the headers dict/object (see comments in
# AsyncHTTPClient.fetch)
request.headers = httputil.HTTPHeaders(request.headers)
else:
request = httpclient.HTTPRequest(url, connect_timeout=connect_timeout)
request = cast(
httpclient.HTTPRequest,
httpclient._RequestProxy(request, httpclient.HTTPRequest._DEFAULTS),
)
conn = WebSocketClientConnection(
request,
on_message_callback=on_message_callback,
compression_options=compression_options,
ping_interval=ping_interval,
ping_timeout=ping_timeout,
max_message_size=max_message_size,
subprotocols=subprotocols,
)
if callback is not None:
IOLoop.current().add_future(conn.connect_future, callback)
return conn.connect_future
|
[
"def",
"websocket_connect",
"(",
"url",
":",
"Union",
"[",
"str",
",",
"httpclient",
".",
"HTTPRequest",
"]",
",",
"callback",
":",
"Callable",
"[",
"[",
"\"Future[WebSocketClientConnection]\"",
"]",
",",
"None",
"]",
"=",
"None",
",",
"connect_timeout",
":",
"float",
"=",
"None",
",",
"on_message_callback",
":",
"Callable",
"[",
"[",
"Union",
"[",
"None",
",",
"str",
",",
"bytes",
"]",
"]",
",",
"None",
"]",
"=",
"None",
",",
"compression_options",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"ping_interval",
":",
"float",
"=",
"None",
",",
"ping_timeout",
":",
"float",
"=",
"None",
",",
"max_message_size",
":",
"int",
"=",
"_default_max_message_size",
",",
"subprotocols",
":",
"List",
"[",
"str",
"]",
"=",
"None",
",",
")",
"->",
"\"Awaitable[WebSocketClientConnection]\"",
":",
"if",
"isinstance",
"(",
"url",
",",
"httpclient",
".",
"HTTPRequest",
")",
":",
"assert",
"connect_timeout",
"is",
"None",
"request",
"=",
"url",
"# Copy and convert the headers dict/object (see comments in",
"# AsyncHTTPClient.fetch)",
"request",
".",
"headers",
"=",
"httputil",
".",
"HTTPHeaders",
"(",
"request",
".",
"headers",
")",
"else",
":",
"request",
"=",
"httpclient",
".",
"HTTPRequest",
"(",
"url",
",",
"connect_timeout",
"=",
"connect_timeout",
")",
"request",
"=",
"cast",
"(",
"httpclient",
".",
"HTTPRequest",
",",
"httpclient",
".",
"_RequestProxy",
"(",
"request",
",",
"httpclient",
".",
"HTTPRequest",
".",
"_DEFAULTS",
")",
",",
")",
"conn",
"=",
"WebSocketClientConnection",
"(",
"request",
",",
"on_message_callback",
"=",
"on_message_callback",
",",
"compression_options",
"=",
"compression_options",
",",
"ping_interval",
"=",
"ping_interval",
",",
"ping_timeout",
"=",
"ping_timeout",
",",
"max_message_size",
"=",
"max_message_size",
",",
"subprotocols",
"=",
"subprotocols",
",",
")",
"if",
"callback",
"is",
"not",
"None",
":",
"IOLoop",
".",
"current",
"(",
")",
".",
"add_future",
"(",
"conn",
".",
"connect_future",
",",
"callback",
")",
"return",
"conn",
".",
"connect_future"
] |
Client-side websocket support.
Takes a url and returns a Future whose result is a
`WebSocketClientConnection`.
``compression_options`` is interpreted in the same way as the
return value of `.WebSocketHandler.get_compression_options`.
The connection supports two styles of operation. In the coroutine
style, the application typically calls
`~.WebSocketClientConnection.read_message` in a loop::
conn = yield websocket_connect(url)
while True:
msg = yield conn.read_message()
if msg is None: break
# Do something with msg
In the callback style, pass an ``on_message_callback`` to
``websocket_connect``. In both styles, a message of ``None``
indicates that the connection has been closed.
``subprotocols`` may be a list of strings specifying proposed
subprotocols. The selected protocol may be found on the
``selected_subprotocol`` attribute of the connection object
when the connection is complete.
.. versionchanged:: 3.2
Also accepts ``HTTPRequest`` objects in place of urls.
.. versionchanged:: 4.1
Added ``compression_options`` and ``on_message_callback``.
.. versionchanged:: 4.5
Added the ``ping_interval``, ``ping_timeout``, and ``max_message_size``
arguments, which have the same meaning as in `WebSocketHandler`.
.. versionchanged:: 5.0
The ``io_loop`` argument (deprecated since version 4.1) has been removed.
.. versionchanged:: 5.1
Added the ``subprotocols`` argument.
|
[
"Client",
"-",
"side",
"websocket",
"support",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1586-L1663
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketHandler.write_message
|
def write_message(
self, message: Union[bytes, str, Dict[str, Any]], binary: bool = False
) -> "Future[None]":
"""Sends the given message to the client of this Web Socket.
The message may be either a string or a dict (which will be
encoded as json). If the ``binary`` argument is false, the
message will be sent as utf8; in binary mode any byte string
is allowed.
If the connection is already closed, raises `WebSocketClosedError`.
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 3.2
`WebSocketClosedError` was added (previously a closed connection
would raise an `AttributeError`)
.. versionchanged:: 4.3
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 5.0
Consistently raises `WebSocketClosedError`. Previously could
sometimes raise `.StreamClosedError`.
"""
if self.ws_connection is None or self.ws_connection.is_closing():
raise WebSocketClosedError()
if isinstance(message, dict):
message = tornado.escape.json_encode(message)
return self.ws_connection.write_message(message, binary=binary)
|
python
|
def write_message(
self, message: Union[bytes, str, Dict[str, Any]], binary: bool = False
) -> "Future[None]":
"""Sends the given message to the client of this Web Socket.
The message may be either a string or a dict (which will be
encoded as json). If the ``binary`` argument is false, the
message will be sent as utf8; in binary mode any byte string
is allowed.
If the connection is already closed, raises `WebSocketClosedError`.
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 3.2
`WebSocketClosedError` was added (previously a closed connection
would raise an `AttributeError`)
.. versionchanged:: 4.3
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 5.0
Consistently raises `WebSocketClosedError`. Previously could
sometimes raise `.StreamClosedError`.
"""
if self.ws_connection is None or self.ws_connection.is_closing():
raise WebSocketClosedError()
if isinstance(message, dict):
message = tornado.escape.json_encode(message)
return self.ws_connection.write_message(message, binary=binary)
|
[
"def",
"write_message",
"(",
"self",
",",
"message",
":",
"Union",
"[",
"bytes",
",",
"str",
",",
"Dict",
"[",
"str",
",",
"Any",
"]",
"]",
",",
"binary",
":",
"bool",
"=",
"False",
")",
"->",
"\"Future[None]\"",
":",
"if",
"self",
".",
"ws_connection",
"is",
"None",
"or",
"self",
".",
"ws_connection",
".",
"is_closing",
"(",
")",
":",
"raise",
"WebSocketClosedError",
"(",
")",
"if",
"isinstance",
"(",
"message",
",",
"dict",
")",
":",
"message",
"=",
"tornado",
".",
"escape",
".",
"json_encode",
"(",
"message",
")",
"return",
"self",
".",
"ws_connection",
".",
"write_message",
"(",
"message",
",",
"binary",
"=",
"binary",
")"
] |
Sends the given message to the client of this Web Socket.
The message may be either a string or a dict (which will be
encoded as json). If the ``binary`` argument is false, the
message will be sent as utf8; in binary mode any byte string
is allowed.
If the connection is already closed, raises `WebSocketClosedError`.
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 3.2
`WebSocketClosedError` was added (previously a closed connection
would raise an `AttributeError`)
.. versionchanged:: 4.3
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 5.0
Consistently raises `WebSocketClosedError`. Previously could
sometimes raise `.StreamClosedError`.
|
[
"Sends",
"the",
"given",
"message",
"to",
"the",
"client",
"of",
"this",
"Web",
"Socket",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L314-L342
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketHandler.ping
|
def ping(self, data: Union[str, bytes] = b"") -> None:
"""Send ping frame to the remote end.
The data argument allows a small amount of data (up to 125
bytes) to be sent as a part of the ping message. Note that not
all websocket implementations expose this data to
applications.
Consider using the ``websocket_ping_interval`` application
setting instead of sending pings manually.
.. versionchanged:: 5.1
The data argument is now optional.
"""
data = utf8(data)
if self.ws_connection is None or self.ws_connection.is_closing():
raise WebSocketClosedError()
self.ws_connection.write_ping(data)
|
python
|
def ping(self, data: Union[str, bytes] = b"") -> None:
"""Send ping frame to the remote end.
The data argument allows a small amount of data (up to 125
bytes) to be sent as a part of the ping message. Note that not
all websocket implementations expose this data to
applications.
Consider using the ``websocket_ping_interval`` application
setting instead of sending pings manually.
.. versionchanged:: 5.1
The data argument is now optional.
"""
data = utf8(data)
if self.ws_connection is None or self.ws_connection.is_closing():
raise WebSocketClosedError()
self.ws_connection.write_ping(data)
|
[
"def",
"ping",
"(",
"self",
",",
"data",
":",
"Union",
"[",
"str",
",",
"bytes",
"]",
"=",
"b\"\"",
")",
"->",
"None",
":",
"data",
"=",
"utf8",
"(",
"data",
")",
"if",
"self",
".",
"ws_connection",
"is",
"None",
"or",
"self",
".",
"ws_connection",
".",
"is_closing",
"(",
")",
":",
"raise",
"WebSocketClosedError",
"(",
")",
"self",
".",
"ws_connection",
".",
"write_ping",
"(",
"data",
")"
] |
Send ping frame to the remote end.
The data argument allows a small amount of data (up to 125
bytes) to be sent as a part of the ping message. Note that not
all websocket implementations expose this data to
applications.
Consider using the ``websocket_ping_interval`` application
setting instead of sending pings manually.
.. versionchanged:: 5.1
The data argument is now optional.
|
[
"Send",
"ping",
"frame",
"to",
"the",
"remote",
"end",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L429-L448
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketHandler.close
|
def close(self, code: int = None, reason: str = None) -> None:
"""Closes this Web Socket.
Once the close handshake is successful the socket will be closed.
``code`` may be a numeric status code, taken from the values
defined in `RFC 6455 section 7.4.1
<https://tools.ietf.org/html/rfc6455#section-7.4.1>`_.
``reason`` may be a textual message about why the connection is
closing. These values are made available to the client, but are
not otherwise interpreted by the websocket protocol.
.. versionchanged:: 4.0
Added the ``code`` and ``reason`` arguments.
"""
if self.ws_connection:
self.ws_connection.close(code, reason)
self.ws_connection = None
|
python
|
def close(self, code: int = None, reason: str = None) -> None:
"""Closes this Web Socket.
Once the close handshake is successful the socket will be closed.
``code`` may be a numeric status code, taken from the values
defined in `RFC 6455 section 7.4.1
<https://tools.ietf.org/html/rfc6455#section-7.4.1>`_.
``reason`` may be a textual message about why the connection is
closing. These values are made available to the client, but are
not otherwise interpreted by the websocket protocol.
.. versionchanged:: 4.0
Added the ``code`` and ``reason`` arguments.
"""
if self.ws_connection:
self.ws_connection.close(code, reason)
self.ws_connection = None
|
[
"def",
"close",
"(",
"self",
",",
"code",
":",
"int",
"=",
"None",
",",
"reason",
":",
"str",
"=",
"None",
")",
"->",
"None",
":",
"if",
"self",
".",
"ws_connection",
":",
"self",
".",
"ws_connection",
".",
"close",
"(",
"code",
",",
"reason",
")",
"self",
".",
"ws_connection",
"=",
"None"
] |
Closes this Web Socket.
Once the close handshake is successful the socket will be closed.
``code`` may be a numeric status code, taken from the values
defined in `RFC 6455 section 7.4.1
<https://tools.ietf.org/html/rfc6455#section-7.4.1>`_.
``reason`` may be a textual message about why the connection is
closing. These values are made available to the client, but are
not otherwise interpreted by the websocket protocol.
.. versionchanged:: 4.0
Added the ``code`` and ``reason`` arguments.
|
[
"Closes",
"this",
"Web",
"Socket",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L471-L489
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketHandler.check_origin
|
def check_origin(self, origin: str) -> bool:
"""Override to enable support for allowing alternate origins.
The ``origin`` argument is the value of the ``Origin`` HTTP
header, the url responsible for initiating this request. This
method is not called for clients that do not send this header;
such requests are always allowed (because all browsers that
implement WebSockets support this header, and non-browser
clients do not have the same cross-site security concerns).
Should return ``True`` to accept the request or ``False`` to
reject it. By default, rejects all requests with an origin on
a host other than this one.
This is a security protection against cross site scripting attacks on
browsers, since WebSockets are allowed to bypass the usual same-origin
policies and don't use CORS headers.
.. warning::
This is an important security measure; don't disable it
without understanding the security implications. In
particular, if your authentication is cookie-based, you
must either restrict the origins allowed by
``check_origin()`` or implement your own XSRF-like
protection for websocket connections. See `these
<https://www.christian-schneider.net/CrossSiteWebSocketHijacking.html>`_
`articles
<https://devcenter.heroku.com/articles/websocket-security>`_
for more.
To accept all cross-origin traffic (which was the default prior to
Tornado 4.0), simply override this method to always return ``True``::
def check_origin(self, origin):
return True
To allow connections from any subdomain of your site, you might
do something like::
def check_origin(self, origin):
parsed_origin = urllib.parse.urlparse(origin)
return parsed_origin.netloc.endswith(".mydomain.com")
.. versionadded:: 4.0
"""
parsed_origin = urlparse(origin)
origin = parsed_origin.netloc
origin = origin.lower()
host = self.request.headers.get("Host")
# Check to see that origin matches host directly, including ports
return origin == host
|
python
|
def check_origin(self, origin: str) -> bool:
"""Override to enable support for allowing alternate origins.
The ``origin`` argument is the value of the ``Origin`` HTTP
header, the url responsible for initiating this request. This
method is not called for clients that do not send this header;
such requests are always allowed (because all browsers that
implement WebSockets support this header, and non-browser
clients do not have the same cross-site security concerns).
Should return ``True`` to accept the request or ``False`` to
reject it. By default, rejects all requests with an origin on
a host other than this one.
This is a security protection against cross site scripting attacks on
browsers, since WebSockets are allowed to bypass the usual same-origin
policies and don't use CORS headers.
.. warning::
This is an important security measure; don't disable it
without understanding the security implications. In
particular, if your authentication is cookie-based, you
must either restrict the origins allowed by
``check_origin()`` or implement your own XSRF-like
protection for websocket connections. See `these
<https://www.christian-schneider.net/CrossSiteWebSocketHijacking.html>`_
`articles
<https://devcenter.heroku.com/articles/websocket-security>`_
for more.
To accept all cross-origin traffic (which was the default prior to
Tornado 4.0), simply override this method to always return ``True``::
def check_origin(self, origin):
return True
To allow connections from any subdomain of your site, you might
do something like::
def check_origin(self, origin):
parsed_origin = urllib.parse.urlparse(origin)
return parsed_origin.netloc.endswith(".mydomain.com")
.. versionadded:: 4.0
"""
parsed_origin = urlparse(origin)
origin = parsed_origin.netloc
origin = origin.lower()
host = self.request.headers.get("Host")
# Check to see that origin matches host directly, including ports
return origin == host
|
[
"def",
"check_origin",
"(",
"self",
",",
"origin",
":",
"str",
")",
"->",
"bool",
":",
"parsed_origin",
"=",
"urlparse",
"(",
"origin",
")",
"origin",
"=",
"parsed_origin",
".",
"netloc",
"origin",
"=",
"origin",
".",
"lower",
"(",
")",
"host",
"=",
"self",
".",
"request",
".",
"headers",
".",
"get",
"(",
"\"Host\"",
")",
"# Check to see that origin matches host directly, including ports",
"return",
"origin",
"==",
"host"
] |
Override to enable support for allowing alternate origins.
The ``origin`` argument is the value of the ``Origin`` HTTP
header, the url responsible for initiating this request. This
method is not called for clients that do not send this header;
such requests are always allowed (because all browsers that
implement WebSockets support this header, and non-browser
clients do not have the same cross-site security concerns).
Should return ``True`` to accept the request or ``False`` to
reject it. By default, rejects all requests with an origin on
a host other than this one.
This is a security protection against cross site scripting attacks on
browsers, since WebSockets are allowed to bypass the usual same-origin
policies and don't use CORS headers.
.. warning::
This is an important security measure; don't disable it
without understanding the security implications. In
particular, if your authentication is cookie-based, you
must either restrict the origins allowed by
``check_origin()`` or implement your own XSRF-like
protection for websocket connections. See `these
<https://www.christian-schneider.net/CrossSiteWebSocketHijacking.html>`_
`articles
<https://devcenter.heroku.com/articles/websocket-security>`_
for more.
To accept all cross-origin traffic (which was the default prior to
Tornado 4.0), simply override this method to always return ``True``::
def check_origin(self, origin):
return True
To allow connections from any subdomain of your site, you might
do something like::
def check_origin(self, origin):
parsed_origin = urllib.parse.urlparse(origin)
return parsed_origin.netloc.endswith(".mydomain.com")
.. versionadded:: 4.0
|
[
"Override",
"to",
"enable",
"support",
"for",
"allowing",
"alternate",
"origins",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L491-L545
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketHandler.set_nodelay
|
def set_nodelay(self, value: bool) -> None:
"""Set the no-delay flag for this stream.
By default, small messages may be delayed and/or combined to minimize
the number of packets sent. This can sometimes cause 200-500ms delays
due to the interaction between Nagle's algorithm and TCP delayed
ACKs. To reduce this delay (at the expense of possibly increasing
bandwidth usage), call ``self.set_nodelay(True)`` once the websocket
connection is established.
See `.BaseIOStream.set_nodelay` for additional details.
.. versionadded:: 3.1
"""
assert self.ws_connection is not None
self.ws_connection.set_nodelay(value)
|
python
|
def set_nodelay(self, value: bool) -> None:
"""Set the no-delay flag for this stream.
By default, small messages may be delayed and/or combined to minimize
the number of packets sent. This can sometimes cause 200-500ms delays
due to the interaction between Nagle's algorithm and TCP delayed
ACKs. To reduce this delay (at the expense of possibly increasing
bandwidth usage), call ``self.set_nodelay(True)`` once the websocket
connection is established.
See `.BaseIOStream.set_nodelay` for additional details.
.. versionadded:: 3.1
"""
assert self.ws_connection is not None
self.ws_connection.set_nodelay(value)
|
[
"def",
"set_nodelay",
"(",
"self",
",",
"value",
":",
"bool",
")",
"->",
"None",
":",
"assert",
"self",
".",
"ws_connection",
"is",
"not",
"None",
"self",
".",
"ws_connection",
".",
"set_nodelay",
"(",
"value",
")"
] |
Set the no-delay flag for this stream.
By default, small messages may be delayed and/or combined to minimize
the number of packets sent. This can sometimes cause 200-500ms delays
due to the interaction between Nagle's algorithm and TCP delayed
ACKs. To reduce this delay (at the expense of possibly increasing
bandwidth usage), call ``self.set_nodelay(True)`` once the websocket
connection is established.
See `.BaseIOStream.set_nodelay` for additional details.
.. versionadded:: 3.1
|
[
"Set",
"the",
"no",
"-",
"delay",
"flag",
"for",
"this",
"stream",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L547-L562
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol._run_callback
|
def _run_callback(
self, callback: Callable, *args: Any, **kwargs: Any
) -> "Optional[Future[Any]]":
"""Runs the given callback with exception handling.
If the callback is a coroutine, returns its Future. On error, aborts the
websocket connection and returns None.
"""
try:
result = callback(*args, **kwargs)
except Exception:
self.handler.log_exception(*sys.exc_info())
self._abort()
return None
else:
if result is not None:
result = gen.convert_yielded(result)
assert self.stream is not None
self.stream.io_loop.add_future(result, lambda f: f.result())
return result
|
python
|
def _run_callback(
self, callback: Callable, *args: Any, **kwargs: Any
) -> "Optional[Future[Any]]":
"""Runs the given callback with exception handling.
If the callback is a coroutine, returns its Future. On error, aborts the
websocket connection and returns None.
"""
try:
result = callback(*args, **kwargs)
except Exception:
self.handler.log_exception(*sys.exc_info())
self._abort()
return None
else:
if result is not None:
result = gen.convert_yielded(result)
assert self.stream is not None
self.stream.io_loop.add_future(result, lambda f: f.result())
return result
|
[
"def",
"_run_callback",
"(",
"self",
",",
"callback",
":",
"Callable",
",",
"*",
"args",
":",
"Any",
",",
"*",
"*",
"kwargs",
":",
"Any",
")",
"->",
"\"Optional[Future[Any]]\"",
":",
"try",
":",
"result",
"=",
"callback",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"except",
"Exception",
":",
"self",
".",
"handler",
".",
"log_exception",
"(",
"*",
"sys",
".",
"exc_info",
"(",
")",
")",
"self",
".",
"_abort",
"(",
")",
"return",
"None",
"else",
":",
"if",
"result",
"is",
"not",
"None",
":",
"result",
"=",
"gen",
".",
"convert_yielded",
"(",
"result",
")",
"assert",
"self",
".",
"stream",
"is",
"not",
"None",
"self",
".",
"stream",
".",
"io_loop",
".",
"add_future",
"(",
"result",
",",
"lambda",
"f",
":",
"f",
".",
"result",
"(",
")",
")",
"return",
"result"
] |
Runs the given callback with exception handling.
If the callback is a coroutine, returns its Future. On error, aborts the
websocket connection and returns None.
|
[
"Runs",
"the",
"given",
"callback",
"with",
"exception",
"handling",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L640-L659
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol._abort
|
def _abort(self) -> None:
"""Instantly aborts the WebSocket connection by closing the socket"""
self.client_terminated = True
self.server_terminated = True
if self.stream is not None:
self.stream.close() # forcibly tear down the connection
self.close()
|
python
|
def _abort(self) -> None:
"""Instantly aborts the WebSocket connection by closing the socket"""
self.client_terminated = True
self.server_terminated = True
if self.stream is not None:
self.stream.close() # forcibly tear down the connection
self.close()
|
[
"def",
"_abort",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"client_terminated",
"=",
"True",
"self",
".",
"server_terminated",
"=",
"True",
"if",
"self",
".",
"stream",
"is",
"not",
"None",
":",
"self",
".",
"stream",
".",
"close",
"(",
")",
"# forcibly tear down the connection",
"self",
".",
"close",
"(",
")"
] |
Instantly aborts the WebSocket connection by closing the socket
|
[
"Instantly",
"aborts",
"the",
"WebSocket",
"connection",
"by",
"closing",
"the",
"socket"
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L664-L670
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13._handle_websocket_headers
|
def _handle_websocket_headers(self, handler: WebSocketHandler) -> None:
"""Verifies all invariant- and required headers
If a header is missing or have an incorrect value ValueError will be
raised
"""
fields = ("Host", "Sec-Websocket-Key", "Sec-Websocket-Version")
if not all(map(lambda f: handler.request.headers.get(f), fields)):
raise ValueError("Missing/Invalid WebSocket headers")
|
python
|
def _handle_websocket_headers(self, handler: WebSocketHandler) -> None:
"""Verifies all invariant- and required headers
If a header is missing or have an incorrect value ValueError will be
raised
"""
fields = ("Host", "Sec-Websocket-Key", "Sec-Websocket-Version")
if not all(map(lambda f: handler.request.headers.get(f), fields)):
raise ValueError("Missing/Invalid WebSocket headers")
|
[
"def",
"_handle_websocket_headers",
"(",
"self",
",",
"handler",
":",
"WebSocketHandler",
")",
"->",
"None",
":",
"fields",
"=",
"(",
"\"Host\"",
",",
"\"Sec-Websocket-Key\"",
",",
"\"Sec-Websocket-Version\"",
")",
"if",
"not",
"all",
"(",
"map",
"(",
"lambda",
"f",
":",
"handler",
".",
"request",
".",
"headers",
".",
"get",
"(",
"f",
")",
",",
"fields",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"Missing/Invalid WebSocket headers\"",
")"
] |
Verifies all invariant- and required headers
If a header is missing or have an incorrect value ValueError will be
raised
|
[
"Verifies",
"all",
"invariant",
"-",
"and",
"required",
"headers"
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L890-L898
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13.compute_accept_value
|
def compute_accept_value(key: Union[str, bytes]) -> str:
"""Computes the value for the Sec-WebSocket-Accept header,
given the value for Sec-WebSocket-Key.
"""
sha1 = hashlib.sha1()
sha1.update(utf8(key))
sha1.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11") # Magic value
return native_str(base64.b64encode(sha1.digest()))
|
python
|
def compute_accept_value(key: Union[str, bytes]) -> str:
"""Computes the value for the Sec-WebSocket-Accept header,
given the value for Sec-WebSocket-Key.
"""
sha1 = hashlib.sha1()
sha1.update(utf8(key))
sha1.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11") # Magic value
return native_str(base64.b64encode(sha1.digest()))
|
[
"def",
"compute_accept_value",
"(",
"key",
":",
"Union",
"[",
"str",
",",
"bytes",
"]",
")",
"->",
"str",
":",
"sha1",
"=",
"hashlib",
".",
"sha1",
"(",
")",
"sha1",
".",
"update",
"(",
"utf8",
"(",
"key",
")",
")",
"sha1",
".",
"update",
"(",
"b\"258EAFA5-E914-47DA-95CA-C5AB0DC85B11\"",
")",
"# Magic value",
"return",
"native_str",
"(",
"base64",
".",
"b64encode",
"(",
"sha1",
".",
"digest",
"(",
")",
")",
")"
] |
Computes the value for the Sec-WebSocket-Accept header,
given the value for Sec-WebSocket-Key.
|
[
"Computes",
"the",
"value",
"for",
"the",
"Sec",
"-",
"WebSocket",
"-",
"Accept",
"header",
"given",
"the",
"value",
"for",
"Sec",
"-",
"WebSocket",
"-",
"Key",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L901-L908
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13._process_server_headers
|
def _process_server_headers(
self, key: Union[str, bytes], headers: httputil.HTTPHeaders
) -> None:
"""Process the headers sent by the server to this client connection.
'key' is the websocket handshake challenge/response key.
"""
assert headers["Upgrade"].lower() == "websocket"
assert headers["Connection"].lower() == "upgrade"
accept = self.compute_accept_value(key)
assert headers["Sec-Websocket-Accept"] == accept
extensions = self._parse_extensions_header(headers)
for ext in extensions:
if ext[0] == "permessage-deflate" and self._compression_options is not None:
self._create_compressors("client", ext[1])
else:
raise ValueError("unsupported extension %r", ext)
self.selected_subprotocol = headers.get("Sec-WebSocket-Protocol", None)
|
python
|
def _process_server_headers(
self, key: Union[str, bytes], headers: httputil.HTTPHeaders
) -> None:
"""Process the headers sent by the server to this client connection.
'key' is the websocket handshake challenge/response key.
"""
assert headers["Upgrade"].lower() == "websocket"
assert headers["Connection"].lower() == "upgrade"
accept = self.compute_accept_value(key)
assert headers["Sec-Websocket-Accept"] == accept
extensions = self._parse_extensions_header(headers)
for ext in extensions:
if ext[0] == "permessage-deflate" and self._compression_options is not None:
self._create_compressors("client", ext[1])
else:
raise ValueError("unsupported extension %r", ext)
self.selected_subprotocol = headers.get("Sec-WebSocket-Protocol", None)
|
[
"def",
"_process_server_headers",
"(",
"self",
",",
"key",
":",
"Union",
"[",
"str",
",",
"bytes",
"]",
",",
"headers",
":",
"httputil",
".",
"HTTPHeaders",
")",
"->",
"None",
":",
"assert",
"headers",
"[",
"\"Upgrade\"",
"]",
".",
"lower",
"(",
")",
"==",
"\"websocket\"",
"assert",
"headers",
"[",
"\"Connection\"",
"]",
".",
"lower",
"(",
")",
"==",
"\"upgrade\"",
"accept",
"=",
"self",
".",
"compute_accept_value",
"(",
"key",
")",
"assert",
"headers",
"[",
"\"Sec-Websocket-Accept\"",
"]",
"==",
"accept",
"extensions",
"=",
"self",
".",
"_parse_extensions_header",
"(",
"headers",
")",
"for",
"ext",
"in",
"extensions",
":",
"if",
"ext",
"[",
"0",
"]",
"==",
"\"permessage-deflate\"",
"and",
"self",
".",
"_compression_options",
"is",
"not",
"None",
":",
"self",
".",
"_create_compressors",
"(",
"\"client\"",
",",
"ext",
"[",
"1",
"]",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"unsupported extension %r\"",
",",
"ext",
")",
"self",
".",
"selected_subprotocol",
"=",
"headers",
".",
"get",
"(",
"\"Sec-WebSocket-Protocol\"",
",",
"None",
")"
] |
Process the headers sent by the server to this client connection.
'key' is the websocket handshake challenge/response key.
|
[
"Process",
"the",
"headers",
"sent",
"by",
"the",
"server",
"to",
"this",
"client",
"connection",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L974-L993
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13._get_compressor_options
|
def _get_compressor_options(
self,
side: str,
agreed_parameters: Dict[str, Any],
compression_options: Dict[str, Any] = None,
) -> Dict[str, Any]:
"""Converts a websocket agreed_parameters set to keyword arguments
for our compressor objects.
"""
options = dict(
persistent=(side + "_no_context_takeover") not in agreed_parameters
) # type: Dict[str, Any]
wbits_header = agreed_parameters.get(side + "_max_window_bits", None)
if wbits_header is None:
options["max_wbits"] = zlib.MAX_WBITS
else:
options["max_wbits"] = int(wbits_header)
options["compression_options"] = compression_options
return options
|
python
|
def _get_compressor_options(
self,
side: str,
agreed_parameters: Dict[str, Any],
compression_options: Dict[str, Any] = None,
) -> Dict[str, Any]:
"""Converts a websocket agreed_parameters set to keyword arguments
for our compressor objects.
"""
options = dict(
persistent=(side + "_no_context_takeover") not in agreed_parameters
) # type: Dict[str, Any]
wbits_header = agreed_parameters.get(side + "_max_window_bits", None)
if wbits_header is None:
options["max_wbits"] = zlib.MAX_WBITS
else:
options["max_wbits"] = int(wbits_header)
options["compression_options"] = compression_options
return options
|
[
"def",
"_get_compressor_options",
"(",
"self",
",",
"side",
":",
"str",
",",
"agreed_parameters",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"compression_options",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"options",
"=",
"dict",
"(",
"persistent",
"=",
"(",
"side",
"+",
"\"_no_context_takeover\"",
")",
"not",
"in",
"agreed_parameters",
")",
"# type: Dict[str, Any]",
"wbits_header",
"=",
"agreed_parameters",
".",
"get",
"(",
"side",
"+",
"\"_max_window_bits\"",
",",
"None",
")",
"if",
"wbits_header",
"is",
"None",
":",
"options",
"[",
"\"max_wbits\"",
"]",
"=",
"zlib",
".",
"MAX_WBITS",
"else",
":",
"options",
"[",
"\"max_wbits\"",
"]",
"=",
"int",
"(",
"wbits_header",
")",
"options",
"[",
"\"compression_options\"",
"]",
"=",
"compression_options",
"return",
"options"
] |
Converts a websocket agreed_parameters set to keyword arguments
for our compressor objects.
|
[
"Converts",
"a",
"websocket",
"agreed_parameters",
"set",
"to",
"keyword",
"arguments",
"for",
"our",
"compressor",
"objects",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L995-L1013
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13.write_message
|
def write_message(
self, message: Union[str, bytes], binary: bool = False
) -> "Future[None]":
"""Sends the given message to the client of this Web Socket."""
if binary:
opcode = 0x2
else:
opcode = 0x1
message = tornado.escape.utf8(message)
assert isinstance(message, bytes)
self._message_bytes_out += len(message)
flags = 0
if self._compressor:
message = self._compressor.compress(message)
flags |= self.RSV1
# For historical reasons, write methods in Tornado operate in a semi-synchronous
# mode in which awaiting the Future they return is optional (But errors can
# still be raised). This requires us to go through an awkward dance here
# to transform the errors that may be returned while presenting the same
# semi-synchronous interface.
try:
fut = self._write_frame(True, opcode, message, flags=flags)
except StreamClosedError:
raise WebSocketClosedError()
async def wrapper() -> None:
try:
await fut
except StreamClosedError:
raise WebSocketClosedError()
return asyncio.ensure_future(wrapper())
|
python
|
def write_message(
self, message: Union[str, bytes], binary: bool = False
) -> "Future[None]":
"""Sends the given message to the client of this Web Socket."""
if binary:
opcode = 0x2
else:
opcode = 0x1
message = tornado.escape.utf8(message)
assert isinstance(message, bytes)
self._message_bytes_out += len(message)
flags = 0
if self._compressor:
message = self._compressor.compress(message)
flags |= self.RSV1
# For historical reasons, write methods in Tornado operate in a semi-synchronous
# mode in which awaiting the Future they return is optional (But errors can
# still be raised). This requires us to go through an awkward dance here
# to transform the errors that may be returned while presenting the same
# semi-synchronous interface.
try:
fut = self._write_frame(True, opcode, message, flags=flags)
except StreamClosedError:
raise WebSocketClosedError()
async def wrapper() -> None:
try:
await fut
except StreamClosedError:
raise WebSocketClosedError()
return asyncio.ensure_future(wrapper())
|
[
"def",
"write_message",
"(",
"self",
",",
"message",
":",
"Union",
"[",
"str",
",",
"bytes",
"]",
",",
"binary",
":",
"bool",
"=",
"False",
")",
"->",
"\"Future[None]\"",
":",
"if",
"binary",
":",
"opcode",
"=",
"0x2",
"else",
":",
"opcode",
"=",
"0x1",
"message",
"=",
"tornado",
".",
"escape",
".",
"utf8",
"(",
"message",
")",
"assert",
"isinstance",
"(",
"message",
",",
"bytes",
")",
"self",
".",
"_message_bytes_out",
"+=",
"len",
"(",
"message",
")",
"flags",
"=",
"0",
"if",
"self",
".",
"_compressor",
":",
"message",
"=",
"self",
".",
"_compressor",
".",
"compress",
"(",
"message",
")",
"flags",
"|=",
"self",
".",
"RSV1",
"# For historical reasons, write methods in Tornado operate in a semi-synchronous",
"# mode in which awaiting the Future they return is optional (But errors can",
"# still be raised). This requires us to go through an awkward dance here",
"# to transform the errors that may be returned while presenting the same",
"# semi-synchronous interface.",
"try",
":",
"fut",
"=",
"self",
".",
"_write_frame",
"(",
"True",
",",
"opcode",
",",
"message",
",",
"flags",
"=",
"flags",
")",
"except",
"StreamClosedError",
":",
"raise",
"WebSocketClosedError",
"(",
")",
"async",
"def",
"wrapper",
"(",
")",
"->",
"None",
":",
"try",
":",
"await",
"fut",
"except",
"StreamClosedError",
":",
"raise",
"WebSocketClosedError",
"(",
")",
"return",
"asyncio",
".",
"ensure_future",
"(",
"wrapper",
"(",
")",
")"
] |
Sends the given message to the client of this Web Socket.
|
[
"Sends",
"the",
"given",
"message",
"to",
"the",
"client",
"of",
"this",
"Web",
"Socket",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1077-L1108
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13.write_ping
|
def write_ping(self, data: bytes) -> None:
"""Send ping frame."""
assert isinstance(data, bytes)
self._write_frame(True, 0x9, data)
|
python
|
def write_ping(self, data: bytes) -> None:
"""Send ping frame."""
assert isinstance(data, bytes)
self._write_frame(True, 0x9, data)
|
[
"def",
"write_ping",
"(",
"self",
",",
"data",
":",
"bytes",
")",
"->",
"None",
":",
"assert",
"isinstance",
"(",
"data",
",",
"bytes",
")",
"self",
".",
"_write_frame",
"(",
"True",
",",
"0x9",
",",
"data",
")"
] |
Send ping frame.
|
[
"Send",
"ping",
"frame",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1110-L1113
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13._handle_message
|
def _handle_message(self, opcode: int, data: bytes) -> "Optional[Future[None]]":
"""Execute on_message, returning its Future if it is a coroutine."""
if self.client_terminated:
return None
if self._frame_compressed:
assert self._decompressor is not None
try:
data = self._decompressor.decompress(data)
except _DecompressTooLargeError:
self.close(1009, "message too big after decompression")
self._abort()
return None
if opcode == 0x1:
# UTF-8 data
self._message_bytes_in += len(data)
try:
decoded = data.decode("utf-8")
except UnicodeDecodeError:
self._abort()
return None
return self._run_callback(self.handler.on_message, decoded)
elif opcode == 0x2:
# Binary data
self._message_bytes_in += len(data)
return self._run_callback(self.handler.on_message, data)
elif opcode == 0x8:
# Close
self.client_terminated = True
if len(data) >= 2:
self.close_code = struct.unpack(">H", data[:2])[0]
if len(data) > 2:
self.close_reason = to_unicode(data[2:])
# Echo the received close code, if any (RFC 6455 section 5.5.1).
self.close(self.close_code)
elif opcode == 0x9:
# Ping
try:
self._write_frame(True, 0xA, data)
except StreamClosedError:
self._abort()
self._run_callback(self.handler.on_ping, data)
elif opcode == 0xA:
# Pong
self.last_pong = IOLoop.current().time()
return self._run_callback(self.handler.on_pong, data)
else:
self._abort()
return None
|
python
|
def _handle_message(self, opcode: int, data: bytes) -> "Optional[Future[None]]":
"""Execute on_message, returning its Future if it is a coroutine."""
if self.client_terminated:
return None
if self._frame_compressed:
assert self._decompressor is not None
try:
data = self._decompressor.decompress(data)
except _DecompressTooLargeError:
self.close(1009, "message too big after decompression")
self._abort()
return None
if opcode == 0x1:
# UTF-8 data
self._message_bytes_in += len(data)
try:
decoded = data.decode("utf-8")
except UnicodeDecodeError:
self._abort()
return None
return self._run_callback(self.handler.on_message, decoded)
elif opcode == 0x2:
# Binary data
self._message_bytes_in += len(data)
return self._run_callback(self.handler.on_message, data)
elif opcode == 0x8:
# Close
self.client_terminated = True
if len(data) >= 2:
self.close_code = struct.unpack(">H", data[:2])[0]
if len(data) > 2:
self.close_reason = to_unicode(data[2:])
# Echo the received close code, if any (RFC 6455 section 5.5.1).
self.close(self.close_code)
elif opcode == 0x9:
# Ping
try:
self._write_frame(True, 0xA, data)
except StreamClosedError:
self._abort()
self._run_callback(self.handler.on_ping, data)
elif opcode == 0xA:
# Pong
self.last_pong = IOLoop.current().time()
return self._run_callback(self.handler.on_pong, data)
else:
self._abort()
return None
|
[
"def",
"_handle_message",
"(",
"self",
",",
"opcode",
":",
"int",
",",
"data",
":",
"bytes",
")",
"->",
"\"Optional[Future[None]]\"",
":",
"if",
"self",
".",
"client_terminated",
":",
"return",
"None",
"if",
"self",
".",
"_frame_compressed",
":",
"assert",
"self",
".",
"_decompressor",
"is",
"not",
"None",
"try",
":",
"data",
"=",
"self",
".",
"_decompressor",
".",
"decompress",
"(",
"data",
")",
"except",
"_DecompressTooLargeError",
":",
"self",
".",
"close",
"(",
"1009",
",",
"\"message too big after decompression\"",
")",
"self",
".",
"_abort",
"(",
")",
"return",
"None",
"if",
"opcode",
"==",
"0x1",
":",
"# UTF-8 data",
"self",
".",
"_message_bytes_in",
"+=",
"len",
"(",
"data",
")",
"try",
":",
"decoded",
"=",
"data",
".",
"decode",
"(",
"\"utf-8\"",
")",
"except",
"UnicodeDecodeError",
":",
"self",
".",
"_abort",
"(",
")",
"return",
"None",
"return",
"self",
".",
"_run_callback",
"(",
"self",
".",
"handler",
".",
"on_message",
",",
"decoded",
")",
"elif",
"opcode",
"==",
"0x2",
":",
"# Binary data",
"self",
".",
"_message_bytes_in",
"+=",
"len",
"(",
"data",
")",
"return",
"self",
".",
"_run_callback",
"(",
"self",
".",
"handler",
".",
"on_message",
",",
"data",
")",
"elif",
"opcode",
"==",
"0x8",
":",
"# Close",
"self",
".",
"client_terminated",
"=",
"True",
"if",
"len",
"(",
"data",
")",
">=",
"2",
":",
"self",
".",
"close_code",
"=",
"struct",
".",
"unpack",
"(",
"\">H\"",
",",
"data",
"[",
":",
"2",
"]",
")",
"[",
"0",
"]",
"if",
"len",
"(",
"data",
")",
">",
"2",
":",
"self",
".",
"close_reason",
"=",
"to_unicode",
"(",
"data",
"[",
"2",
":",
"]",
")",
"# Echo the received close code, if any (RFC 6455 section 5.5.1).",
"self",
".",
"close",
"(",
"self",
".",
"close_code",
")",
"elif",
"opcode",
"==",
"0x9",
":",
"# Ping",
"try",
":",
"self",
".",
"_write_frame",
"(",
"True",
",",
"0xA",
",",
"data",
")",
"except",
"StreamClosedError",
":",
"self",
".",
"_abort",
"(",
")",
"self",
".",
"_run_callback",
"(",
"self",
".",
"handler",
".",
"on_ping",
",",
"data",
")",
"elif",
"opcode",
"==",
"0xA",
":",
"# Pong",
"self",
".",
"last_pong",
"=",
"IOLoop",
".",
"current",
"(",
")",
".",
"time",
"(",
")",
"return",
"self",
".",
"_run_callback",
"(",
"self",
".",
"handler",
".",
"on_pong",
",",
"data",
")",
"else",
":",
"self",
".",
"_abort",
"(",
")",
"return",
"None"
] |
Execute on_message, returning its Future if it is a coroutine.
|
[
"Execute",
"on_message",
"returning",
"its",
"Future",
"if",
"it",
"is",
"a",
"coroutine",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1211-L1260
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13.close
|
def close(self, code: int = None, reason: str = None) -> None:
"""Closes the WebSocket connection."""
if not self.server_terminated:
if not self.stream.closed():
if code is None and reason is not None:
code = 1000 # "normal closure" status code
if code is None:
close_data = b""
else:
close_data = struct.pack(">H", code)
if reason is not None:
close_data += utf8(reason)
try:
self._write_frame(True, 0x8, close_data)
except StreamClosedError:
self._abort()
self.server_terminated = True
if self.client_terminated:
if self._waiting is not None:
self.stream.io_loop.remove_timeout(self._waiting)
self._waiting = None
self.stream.close()
elif self._waiting is None:
# Give the client a few seconds to complete a clean shutdown,
# otherwise just close the connection.
self._waiting = self.stream.io_loop.add_timeout(
self.stream.io_loop.time() + 5, self._abort
)
|
python
|
def close(self, code: int = None, reason: str = None) -> None:
"""Closes the WebSocket connection."""
if not self.server_terminated:
if not self.stream.closed():
if code is None and reason is not None:
code = 1000 # "normal closure" status code
if code is None:
close_data = b""
else:
close_data = struct.pack(">H", code)
if reason is not None:
close_data += utf8(reason)
try:
self._write_frame(True, 0x8, close_data)
except StreamClosedError:
self._abort()
self.server_terminated = True
if self.client_terminated:
if self._waiting is not None:
self.stream.io_loop.remove_timeout(self._waiting)
self._waiting = None
self.stream.close()
elif self._waiting is None:
# Give the client a few seconds to complete a clean shutdown,
# otherwise just close the connection.
self._waiting = self.stream.io_loop.add_timeout(
self.stream.io_loop.time() + 5, self._abort
)
|
[
"def",
"close",
"(",
"self",
",",
"code",
":",
"int",
"=",
"None",
",",
"reason",
":",
"str",
"=",
"None",
")",
"->",
"None",
":",
"if",
"not",
"self",
".",
"server_terminated",
":",
"if",
"not",
"self",
".",
"stream",
".",
"closed",
"(",
")",
":",
"if",
"code",
"is",
"None",
"and",
"reason",
"is",
"not",
"None",
":",
"code",
"=",
"1000",
"# \"normal closure\" status code",
"if",
"code",
"is",
"None",
":",
"close_data",
"=",
"b\"\"",
"else",
":",
"close_data",
"=",
"struct",
".",
"pack",
"(",
"\">H\"",
",",
"code",
")",
"if",
"reason",
"is",
"not",
"None",
":",
"close_data",
"+=",
"utf8",
"(",
"reason",
")",
"try",
":",
"self",
".",
"_write_frame",
"(",
"True",
",",
"0x8",
",",
"close_data",
")",
"except",
"StreamClosedError",
":",
"self",
".",
"_abort",
"(",
")",
"self",
".",
"server_terminated",
"=",
"True",
"if",
"self",
".",
"client_terminated",
":",
"if",
"self",
".",
"_waiting",
"is",
"not",
"None",
":",
"self",
".",
"stream",
".",
"io_loop",
".",
"remove_timeout",
"(",
"self",
".",
"_waiting",
")",
"self",
".",
"_waiting",
"=",
"None",
"self",
".",
"stream",
".",
"close",
"(",
")",
"elif",
"self",
".",
"_waiting",
"is",
"None",
":",
"# Give the client a few seconds to complete a clean shutdown,",
"# otherwise just close the connection.",
"self",
".",
"_waiting",
"=",
"self",
".",
"stream",
".",
"io_loop",
".",
"add_timeout",
"(",
"self",
".",
"stream",
".",
"io_loop",
".",
"time",
"(",
")",
"+",
"5",
",",
"self",
".",
"_abort",
")"
] |
Closes the WebSocket connection.
|
[
"Closes",
"the",
"WebSocket",
"connection",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1262-L1289
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13.is_closing
|
def is_closing(self) -> bool:
"""Return ``True`` if this connection is closing.
The connection is considered closing if either side has
initiated its closing handshake or if the stream has been
shut down uncleanly.
"""
return self.stream.closed() or self.client_terminated or self.server_terminated
|
python
|
def is_closing(self) -> bool:
"""Return ``True`` if this connection is closing.
The connection is considered closing if either side has
initiated its closing handshake or if the stream has been
shut down uncleanly.
"""
return self.stream.closed() or self.client_terminated or self.server_terminated
|
[
"def",
"is_closing",
"(",
"self",
")",
"->",
"bool",
":",
"return",
"self",
".",
"stream",
".",
"closed",
"(",
")",
"or",
"self",
".",
"client_terminated",
"or",
"self",
".",
"server_terminated"
] |
Return ``True`` if this connection is closing.
The connection is considered closing if either side has
initiated its closing handshake or if the stream has been
shut down uncleanly.
|
[
"Return",
"True",
"if",
"this",
"connection",
"is",
"closing",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1291-L1298
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13.start_pinging
|
def start_pinging(self) -> None:
"""Start sending periodic pings to keep the connection alive"""
assert self.ping_interval is not None
if self.ping_interval > 0:
self.last_ping = self.last_pong = IOLoop.current().time()
self.ping_callback = PeriodicCallback(
self.periodic_ping, self.ping_interval * 1000
)
self.ping_callback.start()
|
python
|
def start_pinging(self) -> None:
"""Start sending periodic pings to keep the connection alive"""
assert self.ping_interval is not None
if self.ping_interval > 0:
self.last_ping = self.last_pong = IOLoop.current().time()
self.ping_callback = PeriodicCallback(
self.periodic_ping, self.ping_interval * 1000
)
self.ping_callback.start()
|
[
"def",
"start_pinging",
"(",
"self",
")",
"->",
"None",
":",
"assert",
"self",
".",
"ping_interval",
"is",
"not",
"None",
"if",
"self",
".",
"ping_interval",
">",
"0",
":",
"self",
".",
"last_ping",
"=",
"self",
".",
"last_pong",
"=",
"IOLoop",
".",
"current",
"(",
")",
".",
"time",
"(",
")",
"self",
".",
"ping_callback",
"=",
"PeriodicCallback",
"(",
"self",
".",
"periodic_ping",
",",
"self",
".",
"ping_interval",
"*",
"1000",
")",
"self",
".",
"ping_callback",
".",
"start",
"(",
")"
] |
Start sending periodic pings to keep the connection alive
|
[
"Start",
"sending",
"periodic",
"pings",
"to",
"keep",
"the",
"connection",
"alive"
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1315-L1323
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketProtocol13.periodic_ping
|
def periodic_ping(self) -> None:
"""Send a ping to keep the websocket alive
Called periodically if the websocket_ping_interval is set and non-zero.
"""
if self.is_closing() and self.ping_callback is not None:
self.ping_callback.stop()
return
# Check for timeout on pong. Make sure that we really have
# sent a recent ping in case the machine with both server and
# client has been suspended since the last ping.
now = IOLoop.current().time()
since_last_pong = now - self.last_pong
since_last_ping = now - self.last_ping
assert self.ping_interval is not None
assert self.ping_timeout is not None
if (
since_last_ping < 2 * self.ping_interval
and since_last_pong > self.ping_timeout
):
self.close()
return
self.write_ping(b"")
self.last_ping = now
|
python
|
def periodic_ping(self) -> None:
"""Send a ping to keep the websocket alive
Called periodically if the websocket_ping_interval is set and non-zero.
"""
if self.is_closing() and self.ping_callback is not None:
self.ping_callback.stop()
return
# Check for timeout on pong. Make sure that we really have
# sent a recent ping in case the machine with both server and
# client has been suspended since the last ping.
now = IOLoop.current().time()
since_last_pong = now - self.last_pong
since_last_ping = now - self.last_ping
assert self.ping_interval is not None
assert self.ping_timeout is not None
if (
since_last_ping < 2 * self.ping_interval
and since_last_pong > self.ping_timeout
):
self.close()
return
self.write_ping(b"")
self.last_ping = now
|
[
"def",
"periodic_ping",
"(",
"self",
")",
"->",
"None",
":",
"if",
"self",
".",
"is_closing",
"(",
")",
"and",
"self",
".",
"ping_callback",
"is",
"not",
"None",
":",
"self",
".",
"ping_callback",
".",
"stop",
"(",
")",
"return",
"# Check for timeout on pong. Make sure that we really have",
"# sent a recent ping in case the machine with both server and",
"# client has been suspended since the last ping.",
"now",
"=",
"IOLoop",
".",
"current",
"(",
")",
".",
"time",
"(",
")",
"since_last_pong",
"=",
"now",
"-",
"self",
".",
"last_pong",
"since_last_ping",
"=",
"now",
"-",
"self",
".",
"last_ping",
"assert",
"self",
".",
"ping_interval",
"is",
"not",
"None",
"assert",
"self",
".",
"ping_timeout",
"is",
"not",
"None",
"if",
"(",
"since_last_ping",
"<",
"2",
"*",
"self",
".",
"ping_interval",
"and",
"since_last_pong",
">",
"self",
".",
"ping_timeout",
")",
":",
"self",
".",
"close",
"(",
")",
"return",
"self",
".",
"write_ping",
"(",
"b\"\"",
")",
"self",
".",
"last_ping",
"=",
"now"
] |
Send a ping to keep the websocket alive
Called periodically if the websocket_ping_interval is set and non-zero.
|
[
"Send",
"a",
"ping",
"to",
"keep",
"the",
"websocket",
"alive"
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1325-L1350
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketClientConnection.close
|
def close(self, code: int = None, reason: str = None) -> None:
"""Closes the websocket connection.
``code`` and ``reason`` are documented under
`WebSocketHandler.close`.
.. versionadded:: 3.2
.. versionchanged:: 4.0
Added the ``code`` and ``reason`` arguments.
"""
if self.protocol is not None:
self.protocol.close(code, reason)
self.protocol = None
|
python
|
def close(self, code: int = None, reason: str = None) -> None:
"""Closes the websocket connection.
``code`` and ``reason`` are documented under
`WebSocketHandler.close`.
.. versionadded:: 3.2
.. versionchanged:: 4.0
Added the ``code`` and ``reason`` arguments.
"""
if self.protocol is not None:
self.protocol.close(code, reason)
self.protocol = None
|
[
"def",
"close",
"(",
"self",
",",
"code",
":",
"int",
"=",
"None",
",",
"reason",
":",
"str",
"=",
"None",
")",
"->",
"None",
":",
"if",
"self",
".",
"protocol",
"is",
"not",
"None",
":",
"self",
".",
"protocol",
".",
"close",
"(",
"code",
",",
"reason",
")",
"self",
".",
"protocol",
"=",
"None"
] |
Closes the websocket connection.
``code`` and ``reason`` are documented under
`WebSocketHandler.close`.
.. versionadded:: 3.2
.. versionchanged:: 4.0
Added the ``code`` and ``reason`` arguments.
|
[
"Closes",
"the",
"websocket",
"connection",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1423-L1437
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketClientConnection.write_message
|
def write_message(
self, message: Union[str, bytes], binary: bool = False
) -> "Future[None]":
"""Sends a message to the WebSocket server.
If the stream is closed, raises `WebSocketClosedError`.
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 5.0
Exception raised on a closed stream changed from `.StreamClosedError`
to `WebSocketClosedError`.
"""
return self.protocol.write_message(message, binary=binary)
|
python
|
def write_message(
self, message: Union[str, bytes], binary: bool = False
) -> "Future[None]":
"""Sends a message to the WebSocket server.
If the stream is closed, raises `WebSocketClosedError`.
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 5.0
Exception raised on a closed stream changed from `.StreamClosedError`
to `WebSocketClosedError`.
"""
return self.protocol.write_message(message, binary=binary)
|
[
"def",
"write_message",
"(",
"self",
",",
"message",
":",
"Union",
"[",
"str",
",",
"bytes",
"]",
",",
"binary",
":",
"bool",
"=",
"False",
")",
"->",
"\"Future[None]\"",
":",
"return",
"self",
".",
"protocol",
".",
"write_message",
"(",
"message",
",",
"binary",
"=",
"binary",
")"
] |
Sends a message to the WebSocket server.
If the stream is closed, raises `WebSocketClosedError`.
Returns a `.Future` which can be used for flow control.
.. versionchanged:: 5.0
Exception raised on a closed stream changed from `.StreamClosedError`
to `WebSocketClosedError`.
|
[
"Sends",
"a",
"message",
"to",
"the",
"WebSocket",
"server",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1494-L1506
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketClientConnection.read_message
|
def read_message(
self, callback: Callable[["Future[Union[None, str, bytes]]"], None] = None
) -> Awaitable[Union[None, str, bytes]]:
"""Reads a message from the WebSocket server.
If on_message_callback was specified at WebSocket
initialization, this function will never return messages
Returns a future whose result is the message, or None
if the connection is closed. If a callback argument
is given it will be called with the future when it is
ready.
"""
awaitable = self.read_queue.get()
if callback is not None:
self.io_loop.add_future(asyncio.ensure_future(awaitable), callback)
return awaitable
|
python
|
def read_message(
self, callback: Callable[["Future[Union[None, str, bytes]]"], None] = None
) -> Awaitable[Union[None, str, bytes]]:
"""Reads a message from the WebSocket server.
If on_message_callback was specified at WebSocket
initialization, this function will never return messages
Returns a future whose result is the message, or None
if the connection is closed. If a callback argument
is given it will be called with the future when it is
ready.
"""
awaitable = self.read_queue.get()
if callback is not None:
self.io_loop.add_future(asyncio.ensure_future(awaitable), callback)
return awaitable
|
[
"def",
"read_message",
"(",
"self",
",",
"callback",
":",
"Callable",
"[",
"[",
"\"Future[Union[None, str, bytes]]\"",
"]",
",",
"None",
"]",
"=",
"None",
")",
"->",
"Awaitable",
"[",
"Union",
"[",
"None",
",",
"str",
",",
"bytes",
"]",
"]",
":",
"awaitable",
"=",
"self",
".",
"read_queue",
".",
"get",
"(",
")",
"if",
"callback",
"is",
"not",
"None",
":",
"self",
".",
"io_loop",
".",
"add_future",
"(",
"asyncio",
".",
"ensure_future",
"(",
"awaitable",
")",
",",
"callback",
")",
"return",
"awaitable"
] |
Reads a message from the WebSocket server.
If on_message_callback was specified at WebSocket
initialization, this function will never return messages
Returns a future whose result is the message, or None
if the connection is closed. If a callback argument
is given it will be called with the future when it is
ready.
|
[
"Reads",
"a",
"message",
"from",
"the",
"WebSocket",
"server",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1508-L1525
|
train
|
tornadoweb/tornado
|
tornado/websocket.py
|
WebSocketClientConnection.ping
|
def ping(self, data: bytes = b"") -> None:
"""Send ping frame to the remote end.
The data argument allows a small amount of data (up to 125
bytes) to be sent as a part of the ping message. Note that not
all websocket implementations expose this data to
applications.
Consider using the ``ping_interval`` argument to
`websocket_connect` instead of sending pings manually.
.. versionadded:: 5.1
"""
data = utf8(data)
if self.protocol is None:
raise WebSocketClosedError()
self.protocol.write_ping(data)
|
python
|
def ping(self, data: bytes = b"") -> None:
"""Send ping frame to the remote end.
The data argument allows a small amount of data (up to 125
bytes) to be sent as a part of the ping message. Note that not
all websocket implementations expose this data to
applications.
Consider using the ``ping_interval`` argument to
`websocket_connect` instead of sending pings manually.
.. versionadded:: 5.1
"""
data = utf8(data)
if self.protocol is None:
raise WebSocketClosedError()
self.protocol.write_ping(data)
|
[
"def",
"ping",
"(",
"self",
",",
"data",
":",
"bytes",
"=",
"b\"\"",
")",
"->",
"None",
":",
"data",
"=",
"utf8",
"(",
"data",
")",
"if",
"self",
".",
"protocol",
"is",
"None",
":",
"raise",
"WebSocketClosedError",
"(",
")",
"self",
".",
"protocol",
".",
"write_ping",
"(",
"data",
")"
] |
Send ping frame to the remote end.
The data argument allows a small amount of data (up to 125
bytes) to be sent as a part of the ping message. Note that not
all websocket implementations expose this data to
applications.
Consider using the ``ping_interval`` argument to
`websocket_connect` instead of sending pings manually.
.. versionadded:: 5.1
|
[
"Send",
"ping",
"frame",
"to",
"the",
"remote",
"end",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/websocket.py#L1539-L1556
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
define
|
def define(
name: str,
default: Any = None,
type: type = None,
help: str = None,
metavar: str = None,
multiple: bool = False,
group: str = None,
callback: Callable[[Any], None] = None,
) -> None:
"""Defines an option in the global namespace.
See `OptionParser.define`.
"""
return options.define(
name,
default=default,
type=type,
help=help,
metavar=metavar,
multiple=multiple,
group=group,
callback=callback,
)
|
python
|
def define(
name: str,
default: Any = None,
type: type = None,
help: str = None,
metavar: str = None,
multiple: bool = False,
group: str = None,
callback: Callable[[Any], None] = None,
) -> None:
"""Defines an option in the global namespace.
See `OptionParser.define`.
"""
return options.define(
name,
default=default,
type=type,
help=help,
metavar=metavar,
multiple=multiple,
group=group,
callback=callback,
)
|
[
"def",
"define",
"(",
"name",
":",
"str",
",",
"default",
":",
"Any",
"=",
"None",
",",
"type",
":",
"type",
"=",
"None",
",",
"help",
":",
"str",
"=",
"None",
",",
"metavar",
":",
"str",
"=",
"None",
",",
"multiple",
":",
"bool",
"=",
"False",
",",
"group",
":",
"str",
"=",
"None",
",",
"callback",
":",
"Callable",
"[",
"[",
"Any",
"]",
",",
"None",
"]",
"=",
"None",
",",
")",
"->",
"None",
":",
"return",
"options",
".",
"define",
"(",
"name",
",",
"default",
"=",
"default",
",",
"type",
"=",
"type",
",",
"help",
"=",
"help",
",",
"metavar",
"=",
"metavar",
",",
"multiple",
"=",
"multiple",
",",
"group",
"=",
"group",
",",
"callback",
"=",
"callback",
",",
")"
] |
Defines an option in the global namespace.
See `OptionParser.define`.
|
[
"Defines",
"an",
"option",
"in",
"the",
"global",
"namespace",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L667-L690
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
parse_command_line
|
def parse_command_line(args: List[str] = None, final: bool = True) -> List[str]:
"""Parses global options from the command line.
See `OptionParser.parse_command_line`.
"""
return options.parse_command_line(args, final=final)
|
python
|
def parse_command_line(args: List[str] = None, final: bool = True) -> List[str]:
"""Parses global options from the command line.
See `OptionParser.parse_command_line`.
"""
return options.parse_command_line(args, final=final)
|
[
"def",
"parse_command_line",
"(",
"args",
":",
"List",
"[",
"str",
"]",
"=",
"None",
",",
"final",
":",
"bool",
"=",
"True",
")",
"->",
"List",
"[",
"str",
"]",
":",
"return",
"options",
".",
"parse_command_line",
"(",
"args",
",",
"final",
"=",
"final",
")"
] |
Parses global options from the command line.
See `OptionParser.parse_command_line`.
|
[
"Parses",
"global",
"options",
"from",
"the",
"command",
"line",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L693-L698
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
parse_config_file
|
def parse_config_file(path: str, final: bool = True) -> None:
"""Parses global options from a config file.
See `OptionParser.parse_config_file`.
"""
return options.parse_config_file(path, final=final)
|
python
|
def parse_config_file(path: str, final: bool = True) -> None:
"""Parses global options from a config file.
See `OptionParser.parse_config_file`.
"""
return options.parse_config_file(path, final=final)
|
[
"def",
"parse_config_file",
"(",
"path",
":",
"str",
",",
"final",
":",
"bool",
"=",
"True",
")",
"->",
"None",
":",
"return",
"options",
".",
"parse_config_file",
"(",
"path",
",",
"final",
"=",
"final",
")"
] |
Parses global options from a config file.
See `OptionParser.parse_config_file`.
|
[
"Parses",
"global",
"options",
"from",
"a",
"config",
"file",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L701-L706
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
OptionParser.items
|
def items(self) -> Iterable[Tuple[str, Any]]:
"""An iterable of (name, value) pairs.
.. versionadded:: 3.1
"""
return [(opt.name, opt.value()) for name, opt in self._options.items()]
|
python
|
def items(self) -> Iterable[Tuple[str, Any]]:
"""An iterable of (name, value) pairs.
.. versionadded:: 3.1
"""
return [(opt.name, opt.value()) for name, opt in self._options.items()]
|
[
"def",
"items",
"(",
"self",
")",
"->",
"Iterable",
"[",
"Tuple",
"[",
"str",
",",
"Any",
"]",
"]",
":",
"return",
"[",
"(",
"opt",
".",
"name",
",",
"opt",
".",
"value",
"(",
")",
")",
"for",
"name",
",",
"opt",
"in",
"self",
".",
"_options",
".",
"items",
"(",
")",
"]"
] |
An iterable of (name, value) pairs.
.. versionadded:: 3.1
|
[
"An",
"iterable",
"of",
"(",
"name",
"value",
")",
"pairs",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L166-L171
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
OptionParser.groups
|
def groups(self) -> Set[str]:
"""The set of option-groups created by ``define``.
.. versionadded:: 3.1
"""
return set(opt.group_name for opt in self._options.values())
|
python
|
def groups(self) -> Set[str]:
"""The set of option-groups created by ``define``.
.. versionadded:: 3.1
"""
return set(opt.group_name for opt in self._options.values())
|
[
"def",
"groups",
"(",
"self",
")",
"->",
"Set",
"[",
"str",
"]",
":",
"return",
"set",
"(",
"opt",
".",
"group_name",
"for",
"opt",
"in",
"self",
".",
"_options",
".",
"values",
"(",
")",
")"
] |
The set of option-groups created by ``define``.
.. versionadded:: 3.1
|
[
"The",
"set",
"of",
"option",
"-",
"groups",
"created",
"by",
"define",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L173-L178
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
OptionParser.group_dict
|
def group_dict(self, group: str) -> Dict[str, Any]:
"""The names and values of options in a group.
Useful for copying options into Application settings::
from tornado.options import define, parse_command_line, options
define('template_path', group='application')
define('static_path', group='application')
parse_command_line()
application = Application(
handlers, **options.group_dict('application'))
.. versionadded:: 3.1
"""
return dict(
(opt.name, opt.value())
for name, opt in self._options.items()
if not group or group == opt.group_name
)
|
python
|
def group_dict(self, group: str) -> Dict[str, Any]:
"""The names and values of options in a group.
Useful for copying options into Application settings::
from tornado.options import define, parse_command_line, options
define('template_path', group='application')
define('static_path', group='application')
parse_command_line()
application = Application(
handlers, **options.group_dict('application'))
.. versionadded:: 3.1
"""
return dict(
(opt.name, opt.value())
for name, opt in self._options.items()
if not group or group == opt.group_name
)
|
[
"def",
"group_dict",
"(",
"self",
",",
"group",
":",
"str",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"return",
"dict",
"(",
"(",
"opt",
".",
"name",
",",
"opt",
".",
"value",
"(",
")",
")",
"for",
"name",
",",
"opt",
"in",
"self",
".",
"_options",
".",
"items",
"(",
")",
"if",
"not",
"group",
"or",
"group",
"==",
"opt",
".",
"group_name",
")"
] |
The names and values of options in a group.
Useful for copying options into Application settings::
from tornado.options import define, parse_command_line, options
define('template_path', group='application')
define('static_path', group='application')
parse_command_line()
application = Application(
handlers, **options.group_dict('application'))
.. versionadded:: 3.1
|
[
"The",
"names",
"and",
"values",
"of",
"options",
"in",
"a",
"group",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L180-L201
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
OptionParser.as_dict
|
def as_dict(self) -> Dict[str, Any]:
"""The names and values of all options.
.. versionadded:: 3.1
"""
return dict((opt.name, opt.value()) for name, opt in self._options.items())
|
python
|
def as_dict(self) -> Dict[str, Any]:
"""The names and values of all options.
.. versionadded:: 3.1
"""
return dict((opt.name, opt.value()) for name, opt in self._options.items())
|
[
"def",
"as_dict",
"(",
"self",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"return",
"dict",
"(",
"(",
"opt",
".",
"name",
",",
"opt",
".",
"value",
"(",
")",
")",
"for",
"name",
",",
"opt",
"in",
"self",
".",
"_options",
".",
"items",
"(",
")",
")"
] |
The names and values of all options.
.. versionadded:: 3.1
|
[
"The",
"names",
"and",
"values",
"of",
"all",
"options",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L203-L208
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
OptionParser.define
|
def define(
self,
name: str,
default: Any = None,
type: type = None,
help: str = None,
metavar: str = None,
multiple: bool = False,
group: str = None,
callback: Callable[[Any], None] = None,
) -> None:
"""Defines a new command line option.
``type`` can be any of `str`, `int`, `float`, `bool`,
`~datetime.datetime`, or `~datetime.timedelta`. If no ``type``
is given but a ``default`` is, ``type`` is the type of
``default``. Otherwise, ``type`` defaults to `str`.
If ``multiple`` is True, the option value is a list of ``type``
instead of an instance of ``type``.
``help`` and ``metavar`` are used to construct the
automatically generated command line help string. The help
message is formatted like::
--name=METAVAR help string
``group`` is used to group the defined options in logical
groups. By default, command line options are grouped by the
file in which they are defined.
Command line option names must be unique globally.
If a ``callback`` is given, it will be run with the new value whenever
the option is changed. This can be used to combine command-line
and file-based options::
define("config", type=str, help="path to config file",
callback=lambda path: parse_config_file(path, final=False))
With this definition, options in the file specified by ``--config`` will
override options set earlier on the command line, but can be overridden
by later flags.
"""
normalized = self._normalize_name(name)
if normalized in self._options:
raise Error(
"Option %r already defined in %s"
% (normalized, self._options[normalized].file_name)
)
frame = sys._getframe(0)
options_file = frame.f_code.co_filename
# Can be called directly, or through top level define() fn, in which
# case, step up above that frame to look for real caller.
if (
frame.f_back.f_code.co_filename == options_file
and frame.f_back.f_code.co_name == "define"
):
frame = frame.f_back
file_name = frame.f_back.f_code.co_filename
if file_name == options_file:
file_name = ""
if type is None:
if not multiple and default is not None:
type = default.__class__
else:
type = str
if group:
group_name = group # type: Optional[str]
else:
group_name = file_name
option = _Option(
name,
file_name=file_name,
default=default,
type=type,
help=help,
metavar=metavar,
multiple=multiple,
group_name=group_name,
callback=callback,
)
self._options[normalized] = option
|
python
|
def define(
self,
name: str,
default: Any = None,
type: type = None,
help: str = None,
metavar: str = None,
multiple: bool = False,
group: str = None,
callback: Callable[[Any], None] = None,
) -> None:
"""Defines a new command line option.
``type`` can be any of `str`, `int`, `float`, `bool`,
`~datetime.datetime`, or `~datetime.timedelta`. If no ``type``
is given but a ``default`` is, ``type`` is the type of
``default``. Otherwise, ``type`` defaults to `str`.
If ``multiple`` is True, the option value is a list of ``type``
instead of an instance of ``type``.
``help`` and ``metavar`` are used to construct the
automatically generated command line help string. The help
message is formatted like::
--name=METAVAR help string
``group`` is used to group the defined options in logical
groups. By default, command line options are grouped by the
file in which they are defined.
Command line option names must be unique globally.
If a ``callback`` is given, it will be run with the new value whenever
the option is changed. This can be used to combine command-line
and file-based options::
define("config", type=str, help="path to config file",
callback=lambda path: parse_config_file(path, final=False))
With this definition, options in the file specified by ``--config`` will
override options set earlier on the command line, but can be overridden
by later flags.
"""
normalized = self._normalize_name(name)
if normalized in self._options:
raise Error(
"Option %r already defined in %s"
% (normalized, self._options[normalized].file_name)
)
frame = sys._getframe(0)
options_file = frame.f_code.co_filename
# Can be called directly, or through top level define() fn, in which
# case, step up above that frame to look for real caller.
if (
frame.f_back.f_code.co_filename == options_file
and frame.f_back.f_code.co_name == "define"
):
frame = frame.f_back
file_name = frame.f_back.f_code.co_filename
if file_name == options_file:
file_name = ""
if type is None:
if not multiple and default is not None:
type = default.__class__
else:
type = str
if group:
group_name = group # type: Optional[str]
else:
group_name = file_name
option = _Option(
name,
file_name=file_name,
default=default,
type=type,
help=help,
metavar=metavar,
multiple=multiple,
group_name=group_name,
callback=callback,
)
self._options[normalized] = option
|
[
"def",
"define",
"(",
"self",
",",
"name",
":",
"str",
",",
"default",
":",
"Any",
"=",
"None",
",",
"type",
":",
"type",
"=",
"None",
",",
"help",
":",
"str",
"=",
"None",
",",
"metavar",
":",
"str",
"=",
"None",
",",
"multiple",
":",
"bool",
"=",
"False",
",",
"group",
":",
"str",
"=",
"None",
",",
"callback",
":",
"Callable",
"[",
"[",
"Any",
"]",
",",
"None",
"]",
"=",
"None",
",",
")",
"->",
"None",
":",
"normalized",
"=",
"self",
".",
"_normalize_name",
"(",
"name",
")",
"if",
"normalized",
"in",
"self",
".",
"_options",
":",
"raise",
"Error",
"(",
"\"Option %r already defined in %s\"",
"%",
"(",
"normalized",
",",
"self",
".",
"_options",
"[",
"normalized",
"]",
".",
"file_name",
")",
")",
"frame",
"=",
"sys",
".",
"_getframe",
"(",
"0",
")",
"options_file",
"=",
"frame",
".",
"f_code",
".",
"co_filename",
"# Can be called directly, or through top level define() fn, in which",
"# case, step up above that frame to look for real caller.",
"if",
"(",
"frame",
".",
"f_back",
".",
"f_code",
".",
"co_filename",
"==",
"options_file",
"and",
"frame",
".",
"f_back",
".",
"f_code",
".",
"co_name",
"==",
"\"define\"",
")",
":",
"frame",
"=",
"frame",
".",
"f_back",
"file_name",
"=",
"frame",
".",
"f_back",
".",
"f_code",
".",
"co_filename",
"if",
"file_name",
"==",
"options_file",
":",
"file_name",
"=",
"\"\"",
"if",
"type",
"is",
"None",
":",
"if",
"not",
"multiple",
"and",
"default",
"is",
"not",
"None",
":",
"type",
"=",
"default",
".",
"__class__",
"else",
":",
"type",
"=",
"str",
"if",
"group",
":",
"group_name",
"=",
"group",
"# type: Optional[str]",
"else",
":",
"group_name",
"=",
"file_name",
"option",
"=",
"_Option",
"(",
"name",
",",
"file_name",
"=",
"file_name",
",",
"default",
"=",
"default",
",",
"type",
"=",
"type",
",",
"help",
"=",
"help",
",",
"metavar",
"=",
"metavar",
",",
"multiple",
"=",
"multiple",
",",
"group_name",
"=",
"group_name",
",",
"callback",
"=",
"callback",
",",
")",
"self",
".",
"_options",
"[",
"normalized",
"]",
"=",
"option"
] |
Defines a new command line option.
``type`` can be any of `str`, `int`, `float`, `bool`,
`~datetime.datetime`, or `~datetime.timedelta`. If no ``type``
is given but a ``default`` is, ``type`` is the type of
``default``. Otherwise, ``type`` defaults to `str`.
If ``multiple`` is True, the option value is a list of ``type``
instead of an instance of ``type``.
``help`` and ``metavar`` are used to construct the
automatically generated command line help string. The help
message is formatted like::
--name=METAVAR help string
``group`` is used to group the defined options in logical
groups. By default, command line options are grouped by the
file in which they are defined.
Command line option names must be unique globally.
If a ``callback`` is given, it will be run with the new value whenever
the option is changed. This can be used to combine command-line
and file-based options::
define("config", type=str, help="path to config file",
callback=lambda path: parse_config_file(path, final=False))
With this definition, options in the file specified by ``--config`` will
override options set earlier on the command line, but can be overridden
by later flags.
|
[
"Defines",
"a",
"new",
"command",
"line",
"option",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L210-L295
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
OptionParser.parse_command_line
|
def parse_command_line(
self, args: List[str] = None, final: bool = True
) -> List[str]:
"""Parses all options given on the command line (defaults to
`sys.argv`).
Options look like ``--option=value`` and are parsed according
to their ``type``. For boolean options, ``--option`` is
equivalent to ``--option=true``
If the option has ``multiple=True``, comma-separated values
are accepted. For multi-value integer options, the syntax
``x:y`` is also accepted and equivalent to ``range(x, y)``.
Note that ``args[0]`` is ignored since it is the program name
in `sys.argv`.
We return a list of all arguments that are not parsed as options.
If ``final`` is ``False``, parse callbacks will not be run.
This is useful for applications that wish to combine configurations
from multiple sources.
"""
if args is None:
args = sys.argv
remaining = [] # type: List[str]
for i in range(1, len(args)):
# All things after the last option are command line arguments
if not args[i].startswith("-"):
remaining = args[i:]
break
if args[i] == "--":
remaining = args[i + 1 :]
break
arg = args[i].lstrip("-")
name, equals, value = arg.partition("=")
name = self._normalize_name(name)
if name not in self._options:
self.print_help()
raise Error("Unrecognized command line option: %r" % name)
option = self._options[name]
if not equals:
if option.type == bool:
value = "true"
else:
raise Error("Option %r requires a value" % name)
option.parse(value)
if final:
self.run_parse_callbacks()
return remaining
|
python
|
def parse_command_line(
self, args: List[str] = None, final: bool = True
) -> List[str]:
"""Parses all options given on the command line (defaults to
`sys.argv`).
Options look like ``--option=value`` and are parsed according
to their ``type``. For boolean options, ``--option`` is
equivalent to ``--option=true``
If the option has ``multiple=True``, comma-separated values
are accepted. For multi-value integer options, the syntax
``x:y`` is also accepted and equivalent to ``range(x, y)``.
Note that ``args[0]`` is ignored since it is the program name
in `sys.argv`.
We return a list of all arguments that are not parsed as options.
If ``final`` is ``False``, parse callbacks will not be run.
This is useful for applications that wish to combine configurations
from multiple sources.
"""
if args is None:
args = sys.argv
remaining = [] # type: List[str]
for i in range(1, len(args)):
# All things after the last option are command line arguments
if not args[i].startswith("-"):
remaining = args[i:]
break
if args[i] == "--":
remaining = args[i + 1 :]
break
arg = args[i].lstrip("-")
name, equals, value = arg.partition("=")
name = self._normalize_name(name)
if name not in self._options:
self.print_help()
raise Error("Unrecognized command line option: %r" % name)
option = self._options[name]
if not equals:
if option.type == bool:
value = "true"
else:
raise Error("Option %r requires a value" % name)
option.parse(value)
if final:
self.run_parse_callbacks()
return remaining
|
[
"def",
"parse_command_line",
"(",
"self",
",",
"args",
":",
"List",
"[",
"str",
"]",
"=",
"None",
",",
"final",
":",
"bool",
"=",
"True",
")",
"->",
"List",
"[",
"str",
"]",
":",
"if",
"args",
"is",
"None",
":",
"args",
"=",
"sys",
".",
"argv",
"remaining",
"=",
"[",
"]",
"# type: List[str]",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"args",
")",
")",
":",
"# All things after the last option are command line arguments",
"if",
"not",
"args",
"[",
"i",
"]",
".",
"startswith",
"(",
"\"-\"",
")",
":",
"remaining",
"=",
"args",
"[",
"i",
":",
"]",
"break",
"if",
"args",
"[",
"i",
"]",
"==",
"\"--\"",
":",
"remaining",
"=",
"args",
"[",
"i",
"+",
"1",
":",
"]",
"break",
"arg",
"=",
"args",
"[",
"i",
"]",
".",
"lstrip",
"(",
"\"-\"",
")",
"name",
",",
"equals",
",",
"value",
"=",
"arg",
".",
"partition",
"(",
"\"=\"",
")",
"name",
"=",
"self",
".",
"_normalize_name",
"(",
"name",
")",
"if",
"name",
"not",
"in",
"self",
".",
"_options",
":",
"self",
".",
"print_help",
"(",
")",
"raise",
"Error",
"(",
"\"Unrecognized command line option: %r\"",
"%",
"name",
")",
"option",
"=",
"self",
".",
"_options",
"[",
"name",
"]",
"if",
"not",
"equals",
":",
"if",
"option",
".",
"type",
"==",
"bool",
":",
"value",
"=",
"\"true\"",
"else",
":",
"raise",
"Error",
"(",
"\"Option %r requires a value\"",
"%",
"name",
")",
"option",
".",
"parse",
"(",
"value",
")",
"if",
"final",
":",
"self",
".",
"run_parse_callbacks",
"(",
")",
"return",
"remaining"
] |
Parses all options given on the command line (defaults to
`sys.argv`).
Options look like ``--option=value`` and are parsed according
to their ``type``. For boolean options, ``--option`` is
equivalent to ``--option=true``
If the option has ``multiple=True``, comma-separated values
are accepted. For multi-value integer options, the syntax
``x:y`` is also accepted and equivalent to ``range(x, y)``.
Note that ``args[0]`` is ignored since it is the program name
in `sys.argv`.
We return a list of all arguments that are not parsed as options.
If ``final`` is ``False``, parse callbacks will not be run.
This is useful for applications that wish to combine configurations
from multiple sources.
|
[
"Parses",
"all",
"options",
"given",
"on",
"the",
"command",
"line",
"(",
"defaults",
"to",
"sys",
".",
"argv",
")",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L297-L349
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
OptionParser.parse_config_file
|
def parse_config_file(self, path: str, final: bool = True) -> None:
"""Parses and loads the config file at the given path.
The config file contains Python code that will be executed (so
it is **not safe** to use untrusted config files). Anything in
the global namespace that matches a defined option will be
used to set that option's value.
Options may either be the specified type for the option or
strings (in which case they will be parsed the same way as in
`.parse_command_line`)
Example (using the options defined in the top-level docs of
this module)::
port = 80
mysql_host = 'mydb.example.com:3306'
# Both lists and comma-separated strings are allowed for
# multiple=True.
memcache_hosts = ['cache1.example.com:11011',
'cache2.example.com:11011']
memcache_hosts = 'cache1.example.com:11011,cache2.example.com:11011'
If ``final`` is ``False``, parse callbacks will not be run.
This is useful for applications that wish to combine configurations
from multiple sources.
.. note::
`tornado.options` is primarily a command-line library.
Config file support is provided for applications that wish
to use it, but applications that prefer config files may
wish to look at other libraries instead.
.. versionchanged:: 4.1
Config files are now always interpreted as utf-8 instead of
the system default encoding.
.. versionchanged:: 4.4
The special variable ``__file__`` is available inside config
files, specifying the absolute path to the config file itself.
.. versionchanged:: 5.1
Added the ability to set options via strings in config files.
"""
config = {"__file__": os.path.abspath(path)}
with open(path, "rb") as f:
exec_in(native_str(f.read()), config, config)
for name in config:
normalized = self._normalize_name(name)
if normalized in self._options:
option = self._options[normalized]
if option.multiple:
if not isinstance(config[name], (list, str)):
raise Error(
"Option %r is required to be a list of %s "
"or a comma-separated string"
% (option.name, option.type.__name__)
)
if type(config[name]) == str and option.type != str:
option.parse(config[name])
else:
option.set(config[name])
if final:
self.run_parse_callbacks()
|
python
|
def parse_config_file(self, path: str, final: bool = True) -> None:
"""Parses and loads the config file at the given path.
The config file contains Python code that will be executed (so
it is **not safe** to use untrusted config files). Anything in
the global namespace that matches a defined option will be
used to set that option's value.
Options may either be the specified type for the option or
strings (in which case they will be parsed the same way as in
`.parse_command_line`)
Example (using the options defined in the top-level docs of
this module)::
port = 80
mysql_host = 'mydb.example.com:3306'
# Both lists and comma-separated strings are allowed for
# multiple=True.
memcache_hosts = ['cache1.example.com:11011',
'cache2.example.com:11011']
memcache_hosts = 'cache1.example.com:11011,cache2.example.com:11011'
If ``final`` is ``False``, parse callbacks will not be run.
This is useful for applications that wish to combine configurations
from multiple sources.
.. note::
`tornado.options` is primarily a command-line library.
Config file support is provided for applications that wish
to use it, but applications that prefer config files may
wish to look at other libraries instead.
.. versionchanged:: 4.1
Config files are now always interpreted as utf-8 instead of
the system default encoding.
.. versionchanged:: 4.4
The special variable ``__file__`` is available inside config
files, specifying the absolute path to the config file itself.
.. versionchanged:: 5.1
Added the ability to set options via strings in config files.
"""
config = {"__file__": os.path.abspath(path)}
with open(path, "rb") as f:
exec_in(native_str(f.read()), config, config)
for name in config:
normalized = self._normalize_name(name)
if normalized in self._options:
option = self._options[normalized]
if option.multiple:
if not isinstance(config[name], (list, str)):
raise Error(
"Option %r is required to be a list of %s "
"or a comma-separated string"
% (option.name, option.type.__name__)
)
if type(config[name]) == str and option.type != str:
option.parse(config[name])
else:
option.set(config[name])
if final:
self.run_parse_callbacks()
|
[
"def",
"parse_config_file",
"(",
"self",
",",
"path",
":",
"str",
",",
"final",
":",
"bool",
"=",
"True",
")",
"->",
"None",
":",
"config",
"=",
"{",
"\"__file__\"",
":",
"os",
".",
"path",
".",
"abspath",
"(",
"path",
")",
"}",
"with",
"open",
"(",
"path",
",",
"\"rb\"",
")",
"as",
"f",
":",
"exec_in",
"(",
"native_str",
"(",
"f",
".",
"read",
"(",
")",
")",
",",
"config",
",",
"config",
")",
"for",
"name",
"in",
"config",
":",
"normalized",
"=",
"self",
".",
"_normalize_name",
"(",
"name",
")",
"if",
"normalized",
"in",
"self",
".",
"_options",
":",
"option",
"=",
"self",
".",
"_options",
"[",
"normalized",
"]",
"if",
"option",
".",
"multiple",
":",
"if",
"not",
"isinstance",
"(",
"config",
"[",
"name",
"]",
",",
"(",
"list",
",",
"str",
")",
")",
":",
"raise",
"Error",
"(",
"\"Option %r is required to be a list of %s \"",
"\"or a comma-separated string\"",
"%",
"(",
"option",
".",
"name",
",",
"option",
".",
"type",
".",
"__name__",
")",
")",
"if",
"type",
"(",
"config",
"[",
"name",
"]",
")",
"==",
"str",
"and",
"option",
".",
"type",
"!=",
"str",
":",
"option",
".",
"parse",
"(",
"config",
"[",
"name",
"]",
")",
"else",
":",
"option",
".",
"set",
"(",
"config",
"[",
"name",
"]",
")",
"if",
"final",
":",
"self",
".",
"run_parse_callbacks",
"(",
")"
] |
Parses and loads the config file at the given path.
The config file contains Python code that will be executed (so
it is **not safe** to use untrusted config files). Anything in
the global namespace that matches a defined option will be
used to set that option's value.
Options may either be the specified type for the option or
strings (in which case they will be parsed the same way as in
`.parse_command_line`)
Example (using the options defined in the top-level docs of
this module)::
port = 80
mysql_host = 'mydb.example.com:3306'
# Both lists and comma-separated strings are allowed for
# multiple=True.
memcache_hosts = ['cache1.example.com:11011',
'cache2.example.com:11011']
memcache_hosts = 'cache1.example.com:11011,cache2.example.com:11011'
If ``final`` is ``False``, parse callbacks will not be run.
This is useful for applications that wish to combine configurations
from multiple sources.
.. note::
`tornado.options` is primarily a command-line library.
Config file support is provided for applications that wish
to use it, but applications that prefer config files may
wish to look at other libraries instead.
.. versionchanged:: 4.1
Config files are now always interpreted as utf-8 instead of
the system default encoding.
.. versionchanged:: 4.4
The special variable ``__file__`` is available inside config
files, specifying the absolute path to the config file itself.
.. versionchanged:: 5.1
Added the ability to set options via strings in config files.
|
[
"Parses",
"and",
"loads",
"the",
"config",
"file",
"at",
"the",
"given",
"path",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L351-L418
|
train
|
tornadoweb/tornado
|
tornado/options.py
|
OptionParser.print_help
|
def print_help(self, file: TextIO = None) -> None:
"""Prints all the command line options to stderr (or another file)."""
if file is None:
file = sys.stderr
print("Usage: %s [OPTIONS]" % sys.argv[0], file=file)
print("\nOptions:\n", file=file)
by_group = {} # type: Dict[str, List[_Option]]
for option in self._options.values():
by_group.setdefault(option.group_name, []).append(option)
for filename, o in sorted(by_group.items()):
if filename:
print("\n%s options:\n" % os.path.normpath(filename), file=file)
o.sort(key=lambda option: option.name)
for option in o:
# Always print names with dashes in a CLI context.
prefix = self._normalize_name(option.name)
if option.metavar:
prefix += "=" + option.metavar
description = option.help or ""
if option.default is not None and option.default != "":
description += " (default %s)" % option.default
lines = textwrap.wrap(description, 79 - 35)
if len(prefix) > 30 or len(lines) == 0:
lines.insert(0, "")
print(" --%-30s %s" % (prefix, lines[0]), file=file)
for line in lines[1:]:
print("%-34s %s" % (" ", line), file=file)
print(file=file)
|
python
|
def print_help(self, file: TextIO = None) -> None:
"""Prints all the command line options to stderr (or another file)."""
if file is None:
file = sys.stderr
print("Usage: %s [OPTIONS]" % sys.argv[0], file=file)
print("\nOptions:\n", file=file)
by_group = {} # type: Dict[str, List[_Option]]
for option in self._options.values():
by_group.setdefault(option.group_name, []).append(option)
for filename, o in sorted(by_group.items()):
if filename:
print("\n%s options:\n" % os.path.normpath(filename), file=file)
o.sort(key=lambda option: option.name)
for option in o:
# Always print names with dashes in a CLI context.
prefix = self._normalize_name(option.name)
if option.metavar:
prefix += "=" + option.metavar
description = option.help or ""
if option.default is not None and option.default != "":
description += " (default %s)" % option.default
lines = textwrap.wrap(description, 79 - 35)
if len(prefix) > 30 or len(lines) == 0:
lines.insert(0, "")
print(" --%-30s %s" % (prefix, lines[0]), file=file)
for line in lines[1:]:
print("%-34s %s" % (" ", line), file=file)
print(file=file)
|
[
"def",
"print_help",
"(",
"self",
",",
"file",
":",
"TextIO",
"=",
"None",
")",
"->",
"None",
":",
"if",
"file",
"is",
"None",
":",
"file",
"=",
"sys",
".",
"stderr",
"print",
"(",
"\"Usage: %s [OPTIONS]\"",
"%",
"sys",
".",
"argv",
"[",
"0",
"]",
",",
"file",
"=",
"file",
")",
"print",
"(",
"\"\\nOptions:\\n\"",
",",
"file",
"=",
"file",
")",
"by_group",
"=",
"{",
"}",
"# type: Dict[str, List[_Option]]",
"for",
"option",
"in",
"self",
".",
"_options",
".",
"values",
"(",
")",
":",
"by_group",
".",
"setdefault",
"(",
"option",
".",
"group_name",
",",
"[",
"]",
")",
".",
"append",
"(",
"option",
")",
"for",
"filename",
",",
"o",
"in",
"sorted",
"(",
"by_group",
".",
"items",
"(",
")",
")",
":",
"if",
"filename",
":",
"print",
"(",
"\"\\n%s options:\\n\"",
"%",
"os",
".",
"path",
".",
"normpath",
"(",
"filename",
")",
",",
"file",
"=",
"file",
")",
"o",
".",
"sort",
"(",
"key",
"=",
"lambda",
"option",
":",
"option",
".",
"name",
")",
"for",
"option",
"in",
"o",
":",
"# Always print names with dashes in a CLI context.",
"prefix",
"=",
"self",
".",
"_normalize_name",
"(",
"option",
".",
"name",
")",
"if",
"option",
".",
"metavar",
":",
"prefix",
"+=",
"\"=\"",
"+",
"option",
".",
"metavar",
"description",
"=",
"option",
".",
"help",
"or",
"\"\"",
"if",
"option",
".",
"default",
"is",
"not",
"None",
"and",
"option",
".",
"default",
"!=",
"\"\"",
":",
"description",
"+=",
"\" (default %s)\"",
"%",
"option",
".",
"default",
"lines",
"=",
"textwrap",
".",
"wrap",
"(",
"description",
",",
"79",
"-",
"35",
")",
"if",
"len",
"(",
"prefix",
")",
">",
"30",
"or",
"len",
"(",
"lines",
")",
"==",
"0",
":",
"lines",
".",
"insert",
"(",
"0",
",",
"\"\"",
")",
"print",
"(",
"\" --%-30s %s\"",
"%",
"(",
"prefix",
",",
"lines",
"[",
"0",
"]",
")",
",",
"file",
"=",
"file",
")",
"for",
"line",
"in",
"lines",
"[",
"1",
":",
"]",
":",
"print",
"(",
"\"%-34s %s\"",
"%",
"(",
"\" \"",
",",
"line",
")",
",",
"file",
"=",
"file",
")",
"print",
"(",
"file",
"=",
"file",
")"
] |
Prints all the command line options to stderr (or another file).
|
[
"Prints",
"all",
"the",
"command",
"line",
"options",
"to",
"stderr",
"(",
"or",
"another",
"file",
")",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/options.py#L420-L448
|
train
|
tornadoweb/tornado
|
demos/blog/blog.py
|
BaseHandler.row_to_obj
|
def row_to_obj(self, row, cur):
"""Convert a SQL row to an object supporting dict and attribute access."""
obj = tornado.util.ObjectDict()
for val, desc in zip(row, cur.description):
obj[desc.name] = val
return obj
|
python
|
def row_to_obj(self, row, cur):
"""Convert a SQL row to an object supporting dict and attribute access."""
obj = tornado.util.ObjectDict()
for val, desc in zip(row, cur.description):
obj[desc.name] = val
return obj
|
[
"def",
"row_to_obj",
"(",
"self",
",",
"row",
",",
"cur",
")",
":",
"obj",
"=",
"tornado",
".",
"util",
".",
"ObjectDict",
"(",
")",
"for",
"val",
",",
"desc",
"in",
"zip",
"(",
"row",
",",
"cur",
".",
"description",
")",
":",
"obj",
"[",
"desc",
".",
"name",
"]",
"=",
"val",
"return",
"obj"
] |
Convert a SQL row to an object supporting dict and attribute access.
|
[
"Convert",
"a",
"SQL",
"row",
"to",
"an",
"object",
"supporting",
"dict",
"and",
"attribute",
"access",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/demos/blog/blog.py#L84-L89
|
train
|
tornadoweb/tornado
|
demos/blog/blog.py
|
BaseHandler.execute
|
async def execute(self, stmt, *args):
"""Execute a SQL statement.
Must be called with ``await self.execute(...)``
"""
with (await self.application.db.cursor()) as cur:
await cur.execute(stmt, args)
|
python
|
async def execute(self, stmt, *args):
"""Execute a SQL statement.
Must be called with ``await self.execute(...)``
"""
with (await self.application.db.cursor()) as cur:
await cur.execute(stmt, args)
|
[
"async",
"def",
"execute",
"(",
"self",
",",
"stmt",
",",
"*",
"args",
")",
":",
"with",
"(",
"await",
"self",
".",
"application",
".",
"db",
".",
"cursor",
"(",
")",
")",
"as",
"cur",
":",
"await",
"cur",
".",
"execute",
"(",
"stmt",
",",
"args",
")"
] |
Execute a SQL statement.
Must be called with ``await self.execute(...)``
|
[
"Execute",
"a",
"SQL",
"statement",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/demos/blog/blog.py#L91-L97
|
train
|
tornadoweb/tornado
|
demos/blog/blog.py
|
BaseHandler.query
|
async def query(self, stmt, *args):
"""Query for a list of results.
Typical usage::
results = await self.query(...)
Or::
for row in await self.query(...)
"""
with (await self.application.db.cursor()) as cur:
await cur.execute(stmt, args)
return [self.row_to_obj(row, cur) for row in await cur.fetchall()]
|
python
|
async def query(self, stmt, *args):
"""Query for a list of results.
Typical usage::
results = await self.query(...)
Or::
for row in await self.query(...)
"""
with (await self.application.db.cursor()) as cur:
await cur.execute(stmt, args)
return [self.row_to_obj(row, cur) for row in await cur.fetchall()]
|
[
"async",
"def",
"query",
"(",
"self",
",",
"stmt",
",",
"*",
"args",
")",
":",
"with",
"(",
"await",
"self",
".",
"application",
".",
"db",
".",
"cursor",
"(",
")",
")",
"as",
"cur",
":",
"await",
"cur",
".",
"execute",
"(",
"stmt",
",",
"args",
")",
"return",
"[",
"self",
".",
"row_to_obj",
"(",
"row",
",",
"cur",
")",
"for",
"row",
"in",
"await",
"cur",
".",
"fetchall",
"(",
")",
"]"
] |
Query for a list of results.
Typical usage::
results = await self.query(...)
Or::
for row in await self.query(...)
|
[
"Query",
"for",
"a",
"list",
"of",
"results",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/demos/blog/blog.py#L99-L112
|
train
|
tornadoweb/tornado
|
demos/blog/blog.py
|
BaseHandler.queryone
|
async def queryone(self, stmt, *args):
"""Query for exactly one result.
Raises NoResultError if there are no results, or ValueError if
there are more than one.
"""
results = await self.query(stmt, *args)
if len(results) == 0:
raise NoResultError()
elif len(results) > 1:
raise ValueError("Expected 1 result, got %d" % len(results))
return results[0]
|
python
|
async def queryone(self, stmt, *args):
"""Query for exactly one result.
Raises NoResultError if there are no results, or ValueError if
there are more than one.
"""
results = await self.query(stmt, *args)
if len(results) == 0:
raise NoResultError()
elif len(results) > 1:
raise ValueError("Expected 1 result, got %d" % len(results))
return results[0]
|
[
"async",
"def",
"queryone",
"(",
"self",
",",
"stmt",
",",
"*",
"args",
")",
":",
"results",
"=",
"await",
"self",
".",
"query",
"(",
"stmt",
",",
"*",
"args",
")",
"if",
"len",
"(",
"results",
")",
"==",
"0",
":",
"raise",
"NoResultError",
"(",
")",
"elif",
"len",
"(",
"results",
")",
">",
"1",
":",
"raise",
"ValueError",
"(",
"\"Expected 1 result, got %d\"",
"%",
"len",
"(",
"results",
")",
")",
"return",
"results",
"[",
"0",
"]"
] |
Query for exactly one result.
Raises NoResultError if there are no results, or ValueError if
there are more than one.
|
[
"Query",
"for",
"exactly",
"one",
"result",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/demos/blog/blog.py#L114-L125
|
train
|
tornadoweb/tornado
|
tornado/tcpserver.py
|
TCPServer.listen
|
def listen(self, port: int, address: str = "") -> None:
"""Starts accepting connections on the given port.
This method may be called more than once to listen on multiple ports.
`listen` takes effect immediately; it is not necessary to call
`TCPServer.start` afterwards. It is, however, necessary to start
the `.IOLoop`.
"""
sockets = bind_sockets(port, address=address)
self.add_sockets(sockets)
|
python
|
def listen(self, port: int, address: str = "") -> None:
"""Starts accepting connections on the given port.
This method may be called more than once to listen on multiple ports.
`listen` takes effect immediately; it is not necessary to call
`TCPServer.start` afterwards. It is, however, necessary to start
the `.IOLoop`.
"""
sockets = bind_sockets(port, address=address)
self.add_sockets(sockets)
|
[
"def",
"listen",
"(",
"self",
",",
"port",
":",
"int",
",",
"address",
":",
"str",
"=",
"\"\"",
")",
"->",
"None",
":",
"sockets",
"=",
"bind_sockets",
"(",
"port",
",",
"address",
"=",
"address",
")",
"self",
".",
"add_sockets",
"(",
"sockets",
")"
] |
Starts accepting connections on the given port.
This method may be called more than once to listen on multiple ports.
`listen` takes effect immediately; it is not necessary to call
`TCPServer.start` afterwards. It is, however, necessary to start
the `.IOLoop`.
|
[
"Starts",
"accepting",
"connections",
"on",
"the",
"given",
"port",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/tcpserver.py#L143-L152
|
train
|
tornadoweb/tornado
|
tornado/tcpserver.py
|
TCPServer.add_sockets
|
def add_sockets(self, sockets: Iterable[socket.socket]) -> None:
"""Makes this server start accepting connections on the given sockets.
The ``sockets`` parameter is a list of socket objects such as
those returned by `~tornado.netutil.bind_sockets`.
`add_sockets` is typically used in combination with that
method and `tornado.process.fork_processes` to provide greater
control over the initialization of a multi-process server.
"""
for sock in sockets:
self._sockets[sock.fileno()] = sock
self._handlers[sock.fileno()] = add_accept_handler(
sock, self._handle_connection
)
|
python
|
def add_sockets(self, sockets: Iterable[socket.socket]) -> None:
"""Makes this server start accepting connections on the given sockets.
The ``sockets`` parameter is a list of socket objects such as
those returned by `~tornado.netutil.bind_sockets`.
`add_sockets` is typically used in combination with that
method and `tornado.process.fork_processes` to provide greater
control over the initialization of a multi-process server.
"""
for sock in sockets:
self._sockets[sock.fileno()] = sock
self._handlers[sock.fileno()] = add_accept_handler(
sock, self._handle_connection
)
|
[
"def",
"add_sockets",
"(",
"self",
",",
"sockets",
":",
"Iterable",
"[",
"socket",
".",
"socket",
"]",
")",
"->",
"None",
":",
"for",
"sock",
"in",
"sockets",
":",
"self",
".",
"_sockets",
"[",
"sock",
".",
"fileno",
"(",
")",
"]",
"=",
"sock",
"self",
".",
"_handlers",
"[",
"sock",
".",
"fileno",
"(",
")",
"]",
"=",
"add_accept_handler",
"(",
"sock",
",",
"self",
".",
"_handle_connection",
")"
] |
Makes this server start accepting connections on the given sockets.
The ``sockets`` parameter is a list of socket objects such as
those returned by `~tornado.netutil.bind_sockets`.
`add_sockets` is typically used in combination with that
method and `tornado.process.fork_processes` to provide greater
control over the initialization of a multi-process server.
|
[
"Makes",
"this",
"server",
"start",
"accepting",
"connections",
"on",
"the",
"given",
"sockets",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/tcpserver.py#L154-L167
|
train
|
tornadoweb/tornado
|
tornado/tcpserver.py
|
TCPServer.bind
|
def bind(
self,
port: int,
address: str = None,
family: socket.AddressFamily = socket.AF_UNSPEC,
backlog: int = 128,
reuse_port: bool = False,
) -> None:
"""Binds this server to the given port on the given address.
To start the server, call `start`. If you want to run this server
in a single process, you can call `listen` as a shortcut to the
sequence of `bind` and `start` calls.
Address may be either an IP address or hostname. If it's a hostname,
the server will listen on all IP addresses associated with the
name. Address may be an empty string or None to listen on all
available interfaces. Family may be set to either `socket.AF_INET`
or `socket.AF_INET6` to restrict to IPv4 or IPv6 addresses, otherwise
both will be used if available.
The ``backlog`` argument has the same meaning as for
`socket.listen <socket.socket.listen>`. The ``reuse_port`` argument
has the same meaning as for `.bind_sockets`.
This method may be called multiple times prior to `start` to listen
on multiple ports or interfaces.
.. versionchanged:: 4.4
Added the ``reuse_port`` argument.
"""
sockets = bind_sockets(
port, address=address, family=family, backlog=backlog, reuse_port=reuse_port
)
if self._started:
self.add_sockets(sockets)
else:
self._pending_sockets.extend(sockets)
|
python
|
def bind(
self,
port: int,
address: str = None,
family: socket.AddressFamily = socket.AF_UNSPEC,
backlog: int = 128,
reuse_port: bool = False,
) -> None:
"""Binds this server to the given port on the given address.
To start the server, call `start`. If you want to run this server
in a single process, you can call `listen` as a shortcut to the
sequence of `bind` and `start` calls.
Address may be either an IP address or hostname. If it's a hostname,
the server will listen on all IP addresses associated with the
name. Address may be an empty string or None to listen on all
available interfaces. Family may be set to either `socket.AF_INET`
or `socket.AF_INET6` to restrict to IPv4 or IPv6 addresses, otherwise
both will be used if available.
The ``backlog`` argument has the same meaning as for
`socket.listen <socket.socket.listen>`. The ``reuse_port`` argument
has the same meaning as for `.bind_sockets`.
This method may be called multiple times prior to `start` to listen
on multiple ports or interfaces.
.. versionchanged:: 4.4
Added the ``reuse_port`` argument.
"""
sockets = bind_sockets(
port, address=address, family=family, backlog=backlog, reuse_port=reuse_port
)
if self._started:
self.add_sockets(sockets)
else:
self._pending_sockets.extend(sockets)
|
[
"def",
"bind",
"(",
"self",
",",
"port",
":",
"int",
",",
"address",
":",
"str",
"=",
"None",
",",
"family",
":",
"socket",
".",
"AddressFamily",
"=",
"socket",
".",
"AF_UNSPEC",
",",
"backlog",
":",
"int",
"=",
"128",
",",
"reuse_port",
":",
"bool",
"=",
"False",
",",
")",
"->",
"None",
":",
"sockets",
"=",
"bind_sockets",
"(",
"port",
",",
"address",
"=",
"address",
",",
"family",
"=",
"family",
",",
"backlog",
"=",
"backlog",
",",
"reuse_port",
"=",
"reuse_port",
")",
"if",
"self",
".",
"_started",
":",
"self",
".",
"add_sockets",
"(",
"sockets",
")",
"else",
":",
"self",
".",
"_pending_sockets",
".",
"extend",
"(",
"sockets",
")"
] |
Binds this server to the given port on the given address.
To start the server, call `start`. If you want to run this server
in a single process, you can call `listen` as a shortcut to the
sequence of `bind` and `start` calls.
Address may be either an IP address or hostname. If it's a hostname,
the server will listen on all IP addresses associated with the
name. Address may be an empty string or None to listen on all
available interfaces. Family may be set to either `socket.AF_INET`
or `socket.AF_INET6` to restrict to IPv4 or IPv6 addresses, otherwise
both will be used if available.
The ``backlog`` argument has the same meaning as for
`socket.listen <socket.socket.listen>`. The ``reuse_port`` argument
has the same meaning as for `.bind_sockets`.
This method may be called multiple times prior to `start` to listen
on multiple ports or interfaces.
.. versionchanged:: 4.4
Added the ``reuse_port`` argument.
|
[
"Binds",
"this",
"server",
"to",
"the",
"given",
"port",
"on",
"the",
"given",
"address",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/tcpserver.py#L173-L210
|
train
|
tornadoweb/tornado
|
tornado/tcpserver.py
|
TCPServer.start
|
def start(self, num_processes: Optional[int] = 1, max_restarts: int = None) -> None:
"""Starts this server in the `.IOLoop`.
By default, we run the server in this process and do not fork any
additional child process.
If num_processes is ``None`` or <= 0, we detect the number of cores
available on this machine and fork that number of child
processes. If num_processes is given and > 1, we fork that
specific number of sub-processes.
Since we use processes and not threads, there is no shared memory
between any server code.
Note that multiple processes are not compatible with the autoreload
module (or the ``autoreload=True`` option to `tornado.web.Application`
which defaults to True when ``debug=True``).
When using multiple processes, no IOLoops can be created or
referenced until after the call to ``TCPServer.start(n)``.
Values of ``num_processes`` other than 1 are not supported on Windows.
The ``max_restarts`` argument is passed to `.fork_processes`.
.. versionchanged:: 6.0
Added ``max_restarts`` argument.
"""
assert not self._started
self._started = True
if num_processes != 1:
process.fork_processes(num_processes, max_restarts)
sockets = self._pending_sockets
self._pending_sockets = []
self.add_sockets(sockets)
|
python
|
def start(self, num_processes: Optional[int] = 1, max_restarts: int = None) -> None:
"""Starts this server in the `.IOLoop`.
By default, we run the server in this process and do not fork any
additional child process.
If num_processes is ``None`` or <= 0, we detect the number of cores
available on this machine and fork that number of child
processes. If num_processes is given and > 1, we fork that
specific number of sub-processes.
Since we use processes and not threads, there is no shared memory
between any server code.
Note that multiple processes are not compatible with the autoreload
module (or the ``autoreload=True`` option to `tornado.web.Application`
which defaults to True when ``debug=True``).
When using multiple processes, no IOLoops can be created or
referenced until after the call to ``TCPServer.start(n)``.
Values of ``num_processes`` other than 1 are not supported on Windows.
The ``max_restarts`` argument is passed to `.fork_processes`.
.. versionchanged:: 6.0
Added ``max_restarts`` argument.
"""
assert not self._started
self._started = True
if num_processes != 1:
process.fork_processes(num_processes, max_restarts)
sockets = self._pending_sockets
self._pending_sockets = []
self.add_sockets(sockets)
|
[
"def",
"start",
"(",
"self",
",",
"num_processes",
":",
"Optional",
"[",
"int",
"]",
"=",
"1",
",",
"max_restarts",
":",
"int",
"=",
"None",
")",
"->",
"None",
":",
"assert",
"not",
"self",
".",
"_started",
"self",
".",
"_started",
"=",
"True",
"if",
"num_processes",
"!=",
"1",
":",
"process",
".",
"fork_processes",
"(",
"num_processes",
",",
"max_restarts",
")",
"sockets",
"=",
"self",
".",
"_pending_sockets",
"self",
".",
"_pending_sockets",
"=",
"[",
"]",
"self",
".",
"add_sockets",
"(",
"sockets",
")"
] |
Starts this server in the `.IOLoop`.
By default, we run the server in this process and do not fork any
additional child process.
If num_processes is ``None`` or <= 0, we detect the number of cores
available on this machine and fork that number of child
processes. If num_processes is given and > 1, we fork that
specific number of sub-processes.
Since we use processes and not threads, there is no shared memory
between any server code.
Note that multiple processes are not compatible with the autoreload
module (or the ``autoreload=True`` option to `tornado.web.Application`
which defaults to True when ``debug=True``).
When using multiple processes, no IOLoops can be created or
referenced until after the call to ``TCPServer.start(n)``.
Values of ``num_processes`` other than 1 are not supported on Windows.
The ``max_restarts`` argument is passed to `.fork_processes`.
.. versionchanged:: 6.0
Added ``max_restarts`` argument.
|
[
"Starts",
"this",
"server",
"in",
"the",
".",
"IOLoop",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/tcpserver.py#L212-L246
|
train
|
tornadoweb/tornado
|
tornado/tcpserver.py
|
TCPServer.stop
|
def stop(self) -> None:
"""Stops listening for new connections.
Requests currently in progress may still continue after the
server is stopped.
"""
if self._stopped:
return
self._stopped = True
for fd, sock in self._sockets.items():
assert sock.fileno() == fd
# Unregister socket from IOLoop
self._handlers.pop(fd)()
sock.close()
|
python
|
def stop(self) -> None:
"""Stops listening for new connections.
Requests currently in progress may still continue after the
server is stopped.
"""
if self._stopped:
return
self._stopped = True
for fd, sock in self._sockets.items():
assert sock.fileno() == fd
# Unregister socket from IOLoop
self._handlers.pop(fd)()
sock.close()
|
[
"def",
"stop",
"(",
"self",
")",
"->",
"None",
":",
"if",
"self",
".",
"_stopped",
":",
"return",
"self",
".",
"_stopped",
"=",
"True",
"for",
"fd",
",",
"sock",
"in",
"self",
".",
"_sockets",
".",
"items",
"(",
")",
":",
"assert",
"sock",
".",
"fileno",
"(",
")",
"==",
"fd",
"# Unregister socket from IOLoop",
"self",
".",
"_handlers",
".",
"pop",
"(",
"fd",
")",
"(",
")",
"sock",
".",
"close",
"(",
")"
] |
Stops listening for new connections.
Requests currently in progress may still continue after the
server is stopped.
|
[
"Stops",
"listening",
"for",
"new",
"connections",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/tcpserver.py#L248-L261
|
train
|
tornadoweb/tornado
|
tornado/queues.py
|
Queue.put
|
def put(
self, item: _T, timeout: Union[float, datetime.timedelta] = None
) -> "Future[None]":
"""Put an item into the queue, perhaps waiting until there is room.
Returns a Future, which raises `tornado.util.TimeoutError` after a
timeout.
``timeout`` may be a number denoting a time (on the same
scale as `tornado.ioloop.IOLoop.time`, normally `time.time`), or a
`datetime.timedelta` object for a deadline relative to the
current time.
"""
future = Future() # type: Future[None]
try:
self.put_nowait(item)
except QueueFull:
self._putters.append((item, future))
_set_timeout(future, timeout)
else:
future.set_result(None)
return future
|
python
|
def put(
self, item: _T, timeout: Union[float, datetime.timedelta] = None
) -> "Future[None]":
"""Put an item into the queue, perhaps waiting until there is room.
Returns a Future, which raises `tornado.util.TimeoutError` after a
timeout.
``timeout`` may be a number denoting a time (on the same
scale as `tornado.ioloop.IOLoop.time`, normally `time.time`), or a
`datetime.timedelta` object for a deadline relative to the
current time.
"""
future = Future() # type: Future[None]
try:
self.put_nowait(item)
except QueueFull:
self._putters.append((item, future))
_set_timeout(future, timeout)
else:
future.set_result(None)
return future
|
[
"def",
"put",
"(",
"self",
",",
"item",
":",
"_T",
",",
"timeout",
":",
"Union",
"[",
"float",
",",
"datetime",
".",
"timedelta",
"]",
"=",
"None",
")",
"->",
"\"Future[None]\"",
":",
"future",
"=",
"Future",
"(",
")",
"# type: Future[None]",
"try",
":",
"self",
".",
"put_nowait",
"(",
"item",
")",
"except",
"QueueFull",
":",
"self",
".",
"_putters",
".",
"append",
"(",
"(",
"item",
",",
"future",
")",
")",
"_set_timeout",
"(",
"future",
",",
"timeout",
")",
"else",
":",
"future",
".",
"set_result",
"(",
"None",
")",
"return",
"future"
] |
Put an item into the queue, perhaps waiting until there is room.
Returns a Future, which raises `tornado.util.TimeoutError` after a
timeout.
``timeout`` may be a number denoting a time (on the same
scale as `tornado.ioloop.IOLoop.time`, normally `time.time`), or a
`datetime.timedelta` object for a deadline relative to the
current time.
|
[
"Put",
"an",
"item",
"into",
"the",
"queue",
"perhaps",
"waiting",
"until",
"there",
"is",
"room",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/queues.py#L186-L207
|
train
|
tornadoweb/tornado
|
tornado/queues.py
|
Queue.put_nowait
|
def put_nowait(self, item: _T) -> None:
"""Put an item into the queue without blocking.
If no free slot is immediately available, raise `QueueFull`.
"""
self._consume_expired()
if self._getters:
assert self.empty(), "queue non-empty, why are getters waiting?"
getter = self._getters.popleft()
self.__put_internal(item)
future_set_result_unless_cancelled(getter, self._get())
elif self.full():
raise QueueFull
else:
self.__put_internal(item)
|
python
|
def put_nowait(self, item: _T) -> None:
"""Put an item into the queue without blocking.
If no free slot is immediately available, raise `QueueFull`.
"""
self._consume_expired()
if self._getters:
assert self.empty(), "queue non-empty, why are getters waiting?"
getter = self._getters.popleft()
self.__put_internal(item)
future_set_result_unless_cancelled(getter, self._get())
elif self.full():
raise QueueFull
else:
self.__put_internal(item)
|
[
"def",
"put_nowait",
"(",
"self",
",",
"item",
":",
"_T",
")",
"->",
"None",
":",
"self",
".",
"_consume_expired",
"(",
")",
"if",
"self",
".",
"_getters",
":",
"assert",
"self",
".",
"empty",
"(",
")",
",",
"\"queue non-empty, why are getters waiting?\"",
"getter",
"=",
"self",
".",
"_getters",
".",
"popleft",
"(",
")",
"self",
".",
"__put_internal",
"(",
"item",
")",
"future_set_result_unless_cancelled",
"(",
"getter",
",",
"self",
".",
"_get",
"(",
")",
")",
"elif",
"self",
".",
"full",
"(",
")",
":",
"raise",
"QueueFull",
"else",
":",
"self",
".",
"__put_internal",
"(",
"item",
")"
] |
Put an item into the queue without blocking.
If no free slot is immediately available, raise `QueueFull`.
|
[
"Put",
"an",
"item",
"into",
"the",
"queue",
"without",
"blocking",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/queues.py#L209-L223
|
train
|
tornadoweb/tornado
|
tornado/queues.py
|
Queue.get
|
def get(self, timeout: Union[float, datetime.timedelta] = None) -> Awaitable[_T]:
"""Remove and return an item from the queue.
Returns an awaitable which resolves once an item is available, or raises
`tornado.util.TimeoutError` after a timeout.
``timeout`` may be a number denoting a time (on the same
scale as `tornado.ioloop.IOLoop.time`, normally `time.time`), or a
`datetime.timedelta` object for a deadline relative to the
current time.
.. note::
The ``timeout`` argument of this method differs from that
of the standard library's `queue.Queue.get`. That method
interprets numeric values as relative timeouts; this one
interprets them as absolute deadlines and requires
``timedelta`` objects for relative timeouts (consistent
with other timeouts in Tornado).
"""
future = Future() # type: Future[_T]
try:
future.set_result(self.get_nowait())
except QueueEmpty:
self._getters.append(future)
_set_timeout(future, timeout)
return future
|
python
|
def get(self, timeout: Union[float, datetime.timedelta] = None) -> Awaitable[_T]:
"""Remove and return an item from the queue.
Returns an awaitable which resolves once an item is available, or raises
`tornado.util.TimeoutError` after a timeout.
``timeout`` may be a number denoting a time (on the same
scale as `tornado.ioloop.IOLoop.time`, normally `time.time`), or a
`datetime.timedelta` object for a deadline relative to the
current time.
.. note::
The ``timeout`` argument of this method differs from that
of the standard library's `queue.Queue.get`. That method
interprets numeric values as relative timeouts; this one
interprets them as absolute deadlines and requires
``timedelta`` objects for relative timeouts (consistent
with other timeouts in Tornado).
"""
future = Future() # type: Future[_T]
try:
future.set_result(self.get_nowait())
except QueueEmpty:
self._getters.append(future)
_set_timeout(future, timeout)
return future
|
[
"def",
"get",
"(",
"self",
",",
"timeout",
":",
"Union",
"[",
"float",
",",
"datetime",
".",
"timedelta",
"]",
"=",
"None",
")",
"->",
"Awaitable",
"[",
"_T",
"]",
":",
"future",
"=",
"Future",
"(",
")",
"# type: Future[_T]",
"try",
":",
"future",
".",
"set_result",
"(",
"self",
".",
"get_nowait",
"(",
")",
")",
"except",
"QueueEmpty",
":",
"self",
".",
"_getters",
".",
"append",
"(",
"future",
")",
"_set_timeout",
"(",
"future",
",",
"timeout",
")",
"return",
"future"
] |
Remove and return an item from the queue.
Returns an awaitable which resolves once an item is available, or raises
`tornado.util.TimeoutError` after a timeout.
``timeout`` may be a number denoting a time (on the same
scale as `tornado.ioloop.IOLoop.time`, normally `time.time`), or a
`datetime.timedelta` object for a deadline relative to the
current time.
.. note::
The ``timeout`` argument of this method differs from that
of the standard library's `queue.Queue.get`. That method
interprets numeric values as relative timeouts; this one
interprets them as absolute deadlines and requires
``timedelta`` objects for relative timeouts (consistent
with other timeouts in Tornado).
|
[
"Remove",
"and",
"return",
"an",
"item",
"from",
"the",
"queue",
"."
] |
b8b481770bcdb333a69afde5cce7eaa449128326
|
https://github.com/tornadoweb/tornado/blob/b8b481770bcdb333a69afde5cce7eaa449128326/tornado/queues.py#L225-L252
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.