back to Claude Sonnet 3.5 - Fill-in summary
Claude Sonnet 3.5 - Fill-in: tornado
Pytest Summary for test test
| status | count |
|---|---|
| failed | 7 |
| total | 7 |
| collected | 7 |
| passed | 0 |
Failed pytests:
autoreload_test.py::AutoreloadTest::test_reload
autoreload_test.py::AutoreloadTest::test_reload
self =def test_reload(self): main = """\ import sys # In module mode, the path is set to the parent directory and we can import testapp. try: import testapp except ImportError: print("import testapp failed") else: print("import testapp succeeded") spec = getattr(sys.modules[__name__], '__spec__', None) print(f"Starting {__name__=}, __spec__.name={getattr(spec, 'name', None)}") exec(open("run_twice_magic.py").read()) """ # Create temporary test application self.write_files( { "testapp": { "__init__.py": "", "__main__.py": main, }, } ) # The autoreload wrapper should support all the same modes as the python interpreter. # The wrapper itself should have no effect on this test so we try all modes with and # without it. for wrapper in [False, True]: with self.subTest(wrapper=wrapper): with self.subTest(mode="module"): if wrapper: base_args = [sys.executable, "-m", "tornado.autoreload"] else: base_args = [sys.executable] # In module mode, the path is set to the parent directory and we can import # testapp. Also, the __spec__.name is set to the fully qualified module name. > out = self.run_subprocess(base_args + ["-m", "testapp"]) tornado/test/autoreload_test.py:142: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ tornado/test/autoreload_test.py:100: in run_subprocess self.assertEqual(p.returncode, 0) E AssertionError: 1 != 0
autoreload_test.py::AutoreloadTest::test_reload_wrapper_args
autoreload_test.py::AutoreloadTest::test_reload_wrapper_args
self =def test_reload_wrapper_args(self): main = """\ import os import sys print(os.path.basename(sys.argv[0])) print(f'argv={sys.argv[1:]}') exec(open("run_twice_magic.py").read()) """ # Create temporary test application self.write_files({"main.py": main}) # Make sure the tornado module under test is available to the test # application > out = self.run_subprocess( [ sys.executable, "-m", "tornado.autoreload", "main.py", "arg1", "--arg2", "-m", "arg3", ], ) tornado/test/autoreload_test.py:229: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ tornado/test/autoreload_test.py:100: in run_subprocess self.assertEqual(p.returncode, 0) E AssertionError: 1 != 0
autoreload_test.py::AutoreloadTest::test_reload_wrapper_preservation
autoreload_test.py::AutoreloadTest::test_reload_wrapper_preservation
self =def test_reload_wrapper_preservation(self): # This test verifies that when `python -m tornado.autoreload` # is used on an application that also has an internal # autoreload, the reload wrapper is preserved on restart. main = """\ import sys # This import will fail if path is not set up correctly import testapp if 'tornado.autoreload' not in sys.modules: raise Exception('started without autoreload wrapper') print('Starting') exec(open("run_twice_magic.py").read()) """ self.write_files( { "testapp": { "__init__.py": "", "__main__.py": main, }, } ) > out = self.run_subprocess( [sys.executable, "-m", "tornado.autoreload", "-m", "testapp"] ) tornado/test/autoreload_test.py:210: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ tornado/test/autoreload_test.py:100: in run_subprocess self.assertEqual(p.returncode, 0) E AssertionError: 1 != 0
autoreload_test.py::AutoreloadTest::test_reload_wrapper_until_success
autoreload_test.py::AutoreloadTest::test_reload_wrapper_until_success
self =def test_reload_wrapper_until_success(self): main = """\ import os import sys if "TESTAPP_STARTED" in os.environ: print("exiting cleanly") sys.exit(0) else: print("reloading") exec(open("run_twice_magic.py").read()) """ # Create temporary test application self.write_files({"main.py": main}) > out = self.run_subprocess( [sys.executable, "-m", "tornado.autoreload", "--until-success", "main.py"] ) tornado/test/autoreload_test.py:260: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ tornado/test/autoreload_test.py:100: in run_subprocess self.assertEqual(p.returncode, 0) E AssertionError: 1 != 0
import_test.py::ImportTest::test_import_aliases
import_test.py::ImportTest::test_import_aliases
self =def test_import_aliases(self): # Ensure we don't delete formerly-documented aliases accidentally. import tornado import asyncio > self.assertIs(tornado.ioloop.TimeoutError, tornado.util.TimeoutError) tornado/test/import_test.py:63: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ tornado/__init__.py:66: in __getattr__ return importlib.import_module("." + name, __name__) /usr/lib/python3.10/importlib/__init__.py:126: in import_module return _bootstrap._gcd_import(name[level:], package, level) :1050: in _gcd_import ??? :1027: in _find_and_load ??? :1006: in _find_and_load_unlocked ??? :688: in _load_unlocked ??? :883: in exec_module ??? :241: in _call_with_frames_removed ??? _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ """An I/O event loop for non-blocking sockets. In Tornado 6.0, `.IOLoop` is a wrapper around the `asyncio` event loop, with a slightly different interface. The `.IOLoop` interface is now provided primarily for backwards compatibility; new code should generally use the `asyncio` event loop interface directly. The `IOLoop.current` class method provides the `IOLoop` instance corresponding to the running `asyncio` event loop. """ import asyncio import concurrent.futures import datetime import functools import numbers import os import sys import time import math import random import warnings from typing import Optional from inspect import isawaitable > from tornado.concurrent import Future, is_future, chain_future, future_set_exc_info, future_add_done_callback E File "/testbed/tornado/concurrent.py", line 36 E dummy_executor = DummyExecutor() E IndentationError: expected an indented block after 'if' statement on line 33 tornado/ioloop.py:23: IndentationError
import_test.py::ImportTest::test_import_everything
import_test.py::ImportTest::test_import_everything
self =def test_import_everything(self): # Test that all Tornado modules can be imported without side effects, # specifically without initializing the default asyncio event loop. # Since we can't tell which modules may have already beein imported # in our process, do it in a subprocess for a clean slate. proc = subprocess.Popen([sys.executable], stdin=subprocess.PIPE) proc.communicate(_import_everything) > self.assertEqual(proc.returncode, 0) E AssertionError: 1 != 0 tornado/test/import_test.py:50: AssertionError
import_test.py::ImportTest::test_lazy_import
import_test.py::ImportTest::test_lazy_import
self =def test_lazy_import(self): # Test that submodules can be referenced lazily after "import tornado" proc = subprocess.Popen([sys.executable], stdin=subprocess.PIPE) proc.communicate(_import_lazy) > self.assertEqual(proc.returncode, 0) E AssertionError: 1 != 0 tornado/test/import_test.py:56: AssertionError
Patch diff
diff --git a/tornado/auth.py b/tornado/auth.py
index bbf6ea3c..2db942d1 100644
--- a/tornado/auth.py
+++ b/tornado/auth.py
@@ -102,7 +102,40 @@ class OpenIdMixin(object):
longer returns an awaitable object. It is now an ordinary
synchronous function.
"""
- pass
+ callback_uri = callback_uri or self.request.uri
+ args = {
+ 'openid.ns': 'http://specs.openid.net/auth/2.0',
+ 'openid.claimed_id': 'http://specs.openid.net/auth/2.0/identifier_select',
+ 'openid.identity': 'http://specs.openid.net/auth/2.0/identifier_select',
+ 'openid.return_to': callback_uri,
+ 'openid.realm': self.request.protocol + '://' + self.request.host + '/',
+ 'openid.mode': 'checkid_setup',
+ }
+ if ax_attrs:
+ args.update({
+ 'openid.ns.ax': 'http://openid.net/srv/ax/1.0',
+ 'openid.ax.mode': 'fetch_request',
+ })
+ ax_attrs = set(ax_attrs)
+ required = []
+ if 'name' in ax_attrs:
+ ax_attrs -= set(['name', 'firstname', 'fullname', 'lastname'])
+ required.extend(['firstname', 'fullname', 'lastname'])
+ args.update({
+ 'openid.ax.type.firstname': 'http://axschema.org/namePerson/first',
+ 'openid.ax.type.fullname': 'http://axschema.org/namePerson',
+ 'openid.ax.type.lastname': 'http://axschema.org/namePerson/last',
+ })
+ known_attrs = {
+ 'email': 'http://axschema.org/contact/email',
+ 'language': 'http://axschema.org/pref/language',
+ 'username': 'http://axschema.org/namePerson/friendly',
+ }
+ for name in ax_attrs:
+ args['openid.ax.type.' + name] = known_attrs[name]
+ required.append(name)
+ args['openid.ax.required'] = ','.join(required)
+ self.redirect(self._OPENID_ENDPOINT + '?' + urllib.parse.urlencode(args))
async def get_authenticated_user(self, http_client: Optional[httpclient
.AsyncHTTPClient]=None) ->Dict[str, Any]:
@@ -121,7 +154,14 @@ class OpenIdMixin(object):
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
- pass
+ # Verify the OpenID response via direct request to the OP
+ args = dict((k, v[-1]) for k, v in self.request.arguments.items())
+ args['openid.mode'] = 'check_authentication'
+ url = self._OPENID_ENDPOINT
+ 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)
def get_auth_http_client(self) ->httpclient.AsyncHTTPClient:
"""Returns the `.AsyncHTTPClient` instance to be used for auth requests.
@@ -129,7 +169,7 @@ class OpenIdMixin(object):
May be overridden by subclasses to use an HTTP client other than
the default.
"""
- pass
+ return httpclient.AsyncHTTPClient()
class OAuthMixin(object):
@@ -179,7 +219,44 @@ class OAuthMixin(object):
awaitable object instead.
"""
- pass
+ if callback_uri and getattr(self, '_OAUTH_NO_CALLBACKS', False):
+ raise Exception('This service does not support callback_uri')
+ http_client = http_client or self.get_auth_http_client()
+ if getattr(self, '_OAUTH_VERSION', '1.0a') == '1.0a':
+ response = await http_client.fetch(
+ self._OAUTH_REQUEST_TOKEN_URL,
+ auth_username=self._OAUTH_CONSUMER_KEY,
+ auth_password=self._OAUTH_CONSUMER_SECRET)
+ request_token = parse_qs_bytes(escape.native_str(response.body))
+ self.set_secure_cookie('_oauth_request_token',
+ request_token['oauth_token'][0] +
+ b'|' + request_token['oauth_token_secret'][0])
+ else:
+ request_token = {}
+ args = {
+ 'oauth_consumer_key': self._OAUTH_CONSUMER_KEY,
+ 'oauth_token': request_token.get('oauth_token', [''])[0],
+ 'oauth_signature_method': 'HMAC-SHA1',
+ 'oauth_timestamp': str(int(time.time())),
+ 'oauth_nonce': uuid.uuid4().hex,
+ 'oauth_version': '1.0',
+ }
+ if callback_uri:
+ args['oauth_callback'] = callback_uri
+ if extra_params:
+ args.update(extra_params)
+ if getattr(self, '_OAUTH_VERSION', '1.0a') == '1.0a':
+ signature = _oauth10a_signature(
+ self._OAUTH_CONSUMER_SECRET,
+ 'GET', self._OAUTH_AUTHORIZE_URL, args,
+ request_token.get('oauth_token_secret', [''])[0])
+ else:
+ signature = _oauth_signature(
+ self._OAUTH_CONSUMER_SECRET,
+ 'GET', self._OAUTH_AUTHORIZE_URL, args)
+ args['oauth_signature'] = signature
+ url = self._OAUTH_AUTHORIZE_URL + '?' + urllib.parse.urlencode(args)
+ self.redirect(url)
async def get_authenticated_user(self, http_client: Optional[httpclient
.AsyncHTTPClient]=None) ->Dict[str, Any]:
@@ -198,14 +275,31 @@ class OAuthMixin(object):
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
- pass
+ request_key = self.get_argument('oauth_token')
+ oauth_verifier = self.get_argument('oauth_verifier', None)
+ request_cookie = self.get_secure_cookie('_oauth_request_token')
+ if not request_cookie:
+ raise AuthError('Missing OAuth request token cookie')
+ request_token, request_secret = request_cookie.split(b'|')
+ if request_token != request_key:
+ raise AuthError('Request token does not match')
+ http_client = http_client or self.get_auth_http_client()
+ access_token = await self._oauth_get_access_token(http_client,
+ request_token,
+ request_secret,
+ oauth_verifier)
+ user = await self._oauth_get_user(access_token, http_client)
+ if not user:
+ raise AuthError('Error getting user')
+ user.update(access_token)
+ return user
def _oauth_consumer_token(self) ->Dict[str, Any]:
"""Subclasses must override this to return their OAuth consumer keys.
The return value should be a `dict` with keys ``key`` and ``secret``.
"""
- pass
+ raise NotImplementedError()
async def _oauth_get_user_future(self, access_token: Dict[str, Any]
) ->Dict[str, Any]:
@@ -238,7 +332,30 @@ class OAuthMixin(object):
parameters should include all POST arguments and query string arguments
that will be sent with the request.
"""
- pass
+ consumer_token = self._oauth_consumer_token()
+ base_args = dict(
+ oauth_consumer_key=consumer_token['key'],
+ oauth_token=access_token['key'],
+ oauth_signature_method='HMAC-SHA1',
+ oauth_timestamp=str(int(time.time())),
+ oauth_nonce=uuid.uuid4().hex,
+ oauth_version='1.0',
+ )
+ args = {}
+ args.update(base_args)
+ args.update(parameters)
+ if getattr(self, '_OAUTH_VERSION', '1.0a') == '1.0a':
+ signature = _oauth10a_signature(
+ consumer_token['secret'],
+ method, url, args,
+ access_token['secret'])
+ else:
+ signature = _oauth_signature(
+ consumer_token['secret'],
+ method, url, args,
+ access_token.get('secret'))
+ base_args['oauth_signature'] = signature
+ return base_args
def get_auth_http_client(self) ->httpclient.AsyncHTTPClient:
"""Returns the `.AsyncHTTPClient` instance to be used for auth requests.
@@ -246,7 +363,7 @@ class OAuthMixin(object):
May be overridden by subclasses to use an HTTP client other than
the default.
"""
- pass
+ return httpclient.AsyncHTTPClient()
class OAuth2Mixin(object):
@@ -282,7 +399,17 @@ class OAuth2Mixin(object):
The ``client_secret`` argument (which has never had any effect)
is deprecated and will be removed in Tornado 7.0.
"""
- pass
+ args = {
+ 'redirect_uri': redirect_uri,
+ 'client_id': client_id or self.settings['oauth']['key'],
+ 'response_type': response_type,
+ }
+ if scope:
+ args['scope'] = ' '.join(scope)
+ if extra_params:
+ args.update(extra_params)
+ url = self._OAUTH_AUTHORIZE_URL + '?' + urllib.parse.urlencode(args)
+ self.redirect(url)
async def oauth2_request(self, url: str, access_token: Optional[str]=
None, post_args: Optional[Dict[str, Any]]=None, **args: Any) ->Any:
@@ -319,7 +446,19 @@ class OAuth2Mixin(object):
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
- pass
+ 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)
def get_auth_http_client(self) ->httpclient.AsyncHTTPClient:
"""Returns the `.AsyncHTTPClient` instance to be used for auth requests.
@@ -329,7 +468,7 @@ class OAuth2Mixin(object):
.. versionadded:: 4.3
"""
- pass
+ return httpclient.AsyncHTTPClient()
class TwitterMixin(OAuthMixin):
@@ -394,7 +533,13 @@ class TwitterMixin(OAuthMixin):
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
- pass
+ http = self.get_auth_http_client()
+ response = await http.fetch(self._OAUTH_REQUEST_TOKEN_URL)
+ request_token = parse_qs_bytes(escape.native_str(response.body))
+ authorize_url = self._OAUTH_AUTHENTICATE_URL + '?' + urllib.parse.urlencode({
+ 'oauth_token': request_token[b'oauth_token'][0],
+ })
+ self.redirect(authorize_url)
async def twitter_request(self, path: str, access_token: Dict[str, Any],
post_args: Optional[Dict[str, Any]]=None, **args: Any) ->Any:
@@ -439,7 +584,28 @@ class TwitterMixin(OAuthMixin):
The ``callback`` argument was removed. Use the returned
awaitable object instead.
"""
- pass
+ url = self._TWITTER_BASE_URL + path + ".json"
+ 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)
+ headers = {
+ "Authorization": "OAuth " + ",".join(
+ '%s="%s"' % (k, escape.url_escape(v))
+ for k, v in sorted(oauth.items())
+ )
+ }
+ http = self.get_auth_http_client()
+ if post_args is not None:
+ response = await http.fetch(url, method="POST", headers=headers,
+ body=urllib.parse.urlencode(all_args))
+ else:
+ if all_args:
+ url += "?" + urllib.parse.urlencode(all_args)
+ response = await http.fetch(url, headers=headers)
+ return escape.json_decode(response.body)
class GoogleOAuth2Mixin(OAuth2Mixin):
@@ -484,7 +650,7 @@ class GoogleOAuth2Mixin(OAuth2Mixin):
If your credentials are stored differently (e.g. in a db) you can
override this method for custom provision.
"""
- pass
+ return self.settings[self._OAUTH_SETTINGS_KEY]
async def get_authenticated_user(self, redirect_uri: str, code: str,
client_id: Optional[str]=None, client_secret: Optional[str]=None
@@ -542,7 +708,22 @@ class GoogleOAuth2Mixin(OAuth2Mixin):
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
- pass
+ http = self.get_auth_http_client()
+ body = urllib.parse.urlencode({
+ "redirect_uri": redirect_uri,
+ "code": code,
+ "client_id": client_id or self.get_google_oauth_settings()['key'],
+ "client_secret": client_secret or self.get_google_oauth_settings()['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)
class FacebookGraphMixin(OAuth2Mixin):
@@ -603,7 +784,44 @@ class FacebookGraphMixin(OAuth2Mixin):
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
- pass
+ http = self.get_auth_http_client()
+ args = {
+ "redirect_uri": redirect_uri,
+ "code": code,
+ "client_id": client_id,
+ "client_secret": client_secret,
+ }
+
+ response = await http.fetch(
+ self._OAUTH_ACCESS_TOKEN_URL + "?" + urllib.parse.urlencode(args)
+ )
+ args = escape.json_decode(response.body)
+ session = {
+ "access_token": args["access_token"],
+ "expires_in": args.get("expires_in"),
+ }
+
+ 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=extra_fields
+ )
+
+ if user is None:
+ return None
+
+ fieldmap = {}
+ for field in ['id', 'name', 'first_name', 'last_name',
+ 'locale', 'picture', 'link']:
+ fieldmap[field] = user.get(field)
+
+ fieldmap.update(session)
+ return fieldmap
async def facebook_request(self, path: str, access_token: Optional[str]
=None, post_args: Optional[Dict[str, Any]]=None, **args: Any) ->Any:
@@ -657,7 +875,20 @@ class FacebookGraphMixin(OAuth2Mixin):
The ``callback`` argument was removed. Use the returned awaitable object instead.
"""
- pass
+ url = self._FACEBOOK_BASE_URL + path
+ 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)
def _oauth_signature(consumer_token: Dict[str, Any], method: str, url: str,
@@ -667,7 +898,23 @@ def _oauth_signature(consumer_token: Dict[str, Any], method: str, url: str,
See http://oauth.net/core/1.0/#signing_process
"""
- pass
+ 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(consumer_token["secret"])]
+ key_elems.append(escape.utf8(token["secret"] 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:
@@ -677,4 +924,20 @@ def _oauth10a_signature(consumer_token: Dict[str, Any], method: str, url:
See http://oauth.net/core/1.0a/#signing_process
"""
- pass
+ 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(consumer_token["secret"])]
+ key_elems.append(escape.utf8(token["secret"] 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]
diff --git a/tornado/autoreload.py b/tornado/autoreload.py
index 05cda05c..2a2ff1d0 100644
--- a/tornado/autoreload.py
+++ b/tornado/autoreload.py
@@ -66,7 +66,16 @@ def start(check_time: int=500) ->None:
.. versionchanged:: 5.0
The ``io_loop`` argument (deprecated since version 4.1) has been removed.
"""
- pass
+ io_loop = ioloop.IOLoop.current()
+ if io_loop in _io_loops:
+ return
+ _io_loops[io_loop] = True
+ if len(_io_loops) > 1:
+ gen_log.warning("tornado.autoreload started more than once in the same process")
+ modify_times = {}
+ callback = functools.partial(_reload_on_update, modify_times)
+ scheduler = ioloop.PeriodicCallback(callback, check_time)
+ scheduler.start()
def wait() ->None:
@@ -76,7 +85,8 @@ def wait() ->None:
to run the tests again after any source file changes (but see also
the command-line interface in `main`)
"""
- pass
+ io_loop = ioloop.IOLoop.current()
+ io_loop.start()
def watch(filename: str) ->None:
@@ -84,7 +94,7 @@ def watch(filename: str) ->None:
All imported modules are watched by default.
"""
- pass
+ _watched_files.add(os.path.abspath(filename))
def add_reload_hook(fn: Callable[[], None]) ->None:
@@ -94,7 +104,7 @@ def add_reload_hook(fn: Callable[[], None]) ->None:
preferable to set the ``FD_CLOEXEC`` flag (using `fcntl` or
`os.set_inheritable`) instead of using a reload hook to close them.
"""
- pass
+ _reload_hooks.append(fn)
_USAGE = """
@@ -116,7 +126,60 @@ def main() ->None:
can catch import-time problems like syntax errors that would otherwise
prevent the script from reaching its call to `wait`.
"""
- pass
+ global _autoreload_is_main, _original_argv, _original_spec
+ _autoreload_is_main = True
+ _original_argv = sys.argv
+ _original_spec = getattr(sys.modules['__main__'], '__spec__', None)
+
+ if len(sys.argv) >= 3 and sys.argv[1] == "-m":
+ mode = "module"
+ module = sys.argv[2]
+ del sys.argv[1:3]
+ elif len(sys.argv) >= 2:
+ mode = "script"
+ script = sys.argv[1]
+ sys.argv = sys.argv[1:]
+ else:
+ print(_USAGE, file=sys.stderr)
+ sys.exit(1)
+
+ try:
+ if mode == "module":
+ import runpy
+ runpy.run_module(module, run_name="__main__", alter_sys=True)
+ elif mode == "script":
+ with open(script) as f:
+ global __file__
+ __file__ = script
+ # Use globals as our "locals" dictionary so that
+ # something that tries to import __main__ (e.g. the unittest
+ # module) will see the right things.
+ exec(f.read(), globals(), globals())
+ except SystemExit as e:
+ gen_log.info("Script exited with status %s", e.code)
+ except Exception as e:
+ gen_log.warning("Script exited with uncaught exception", exc_info=True)
+ # If an exception occurred at import time, the file with the error
+ # never made it into sys.modules and so we won't know to watch it.
+ # Just to make sure we've covered everything, walk the stack trace
+ # and watch every file.
+ for (filename, lineno, name, line) in traceback.extract_tb(sys.exc_info()[2]):
+ watch(filename)
+ if isinstance(e, SyntaxError):
+ # SyntaxErrors are special: their innermost stack frame is fake
+ # so extract_tb won't see it and we have to get the filename
+ # from the exception object.
+ watch(e.filename)
+ else:
+ gen_log.info("Script exited normally")
+ # restore sys.argv so subsequent executions will include autoreload
+ sys.argv = _original_argv
+
+ if mode == 'module':
+ # runpy did a fake import of the module as __main__, but now it's
+ # no longer in sys.modules. Figure out where it is and watch it.
+ watch(runpy._get_module_details(module)[0])
+ wait()
if __name__ == '__main__':
diff --git a/tornado/concurrent.py b/tornado/concurrent.py
index 16b042a9..4b677490 100644
--- a/tornado/concurrent.py
+++ b/tornado/concurrent.py
@@ -76,7 +76,18 @@ def run_on_executor(*args: Any, **kwargs: Any) ->Callable:
The ``callback`` argument was removed.
"""
- pass
+ def run_on_executor_decorator(func: Callable) ->Callable:
+ @functools.wraps(func)
+ async def wrapper(self, *args, **kwargs):
+ executor = getattr(self, kwargs.pop('executor', 'executor'))
+ return await asyncio.get_event_loop().run_in_executor(
+ executor, functools.partial(func, self, *args, **kwargs))
+ return wrapper
+
+ if len(args) == 1 and callable(args[0]):
+ return run_on_executor_decorator(args[0])
+ else:
+ return run_on_executor_decorator
_NO_RESULT = object()
@@ -94,7 +105,18 @@ def chain_future(a: 'Future[_T]', b: 'Future[_T]') ->None:
`concurrent.futures.Future`.
"""
- pass
+ def copy_result(future):
+ if b.done():
+ return
+ if future.exception() is not None:
+ b.set_exception(future.exception())
+ else:
+ b.set_result(future.result())
+
+ if isinstance(a, Future):
+ future_add_done_callback(a, copy_result)
+ else:
+ a.add_done_callback(copy_result)
def future_set_result_unless_cancelled(future:
@@ -106,7 +128,8 @@ def future_set_result_unless_cancelled(future:
.. versionadded:: 5.0
"""
- pass
+ if not future.cancelled():
+ future.set_result(value)
def future_set_exception_unless_cancelled(future:
@@ -124,7 +147,10 @@ def future_set_exception_unless_cancelled(future:
.. versionadded:: 6.0
"""
- pass
+ if future.cancelled():
+ app_log.error("Exception after Future was cancelled", exc_info=exc)
+ else:
+ future.set_exception(exc)
def future_set_exc_info(future: 'Union[futures.Future[_T], Future[_T]]',
@@ -143,7 +169,13 @@ def future_set_exc_info(future: 'Union[futures.Future[_T], Future[_T]]',
(previously ``asyncio.InvalidStateError`` would be raised)
"""
- pass
+ if not future.cancelled():
+ if hasattr(future, 'set_exc_info'):
+ # Tornado's Future
+ future.set_exc_info(exc_info)
+ else:
+ # asyncio Future
+ future.set_exception(exc_info[1])
def future_add_done_callback(future:
@@ -159,4 +191,7 @@ def future_add_done_callback(future:
.. versionadded:: 5.0
"""
- pass
+ if future.done():
+ callback(future)
+ else:
+ future.add_done_callback(callback)
diff --git a/tornado/curl_httpclient.py b/tornado/curl_httpclient.py
index 548b9c4d..8e6ea8f4 100644
--- a/tornado/curl_httpclient.py
+++ b/tornado/curl_httpclient.py
@@ -27,33 +27,67 @@ class CurlAsyncHTTPClient(AsyncHTTPClient):
"""Called by libcurl when it wants to change the file descriptors
it cares about.
"""
- pass
+ if event == pycurl.POLL_NONE:
+ self.io_loop.remove_handler(fd)
+ else:
+ if event == pycurl.POLL_IN:
+ self.io_loop.add_handler(fd, self._handle_events, self.io_loop.READ)
+ elif event == pycurl.POLL_OUT:
+ self.io_loop.add_handler(fd, self._handle_events, self.io_loop.WRITE)
+ elif event == pycurl.POLL_INOUT:
+ self.io_loop.add_handler(fd, self._handle_events, self.io_loop.READ | self.io_loop.WRITE)
def _set_timeout(self, msecs: int) ->None:
"""Called by libcurl to schedule a timeout."""
- pass
+ if self._timeout is not None:
+ self.io_loop.remove_timeout(self._timeout)
+ self._timeout = self.io_loop.add_timeout(
+ self.io_loop.time() + msecs / 1000.0, self._handle_timeout)
def _handle_events(self, fd: int, events: int) ->None:
"""Called by IOLoop when there is activity on one of our
file descriptors.
"""
- pass
+ action = 0
+ if events & self.io_loop.READ:
+ action |= pycurl.CSELECT_IN
+ if events & self.io_loop.WRITE:
+ action |= pycurl.CSELECT_OUT
+ while True:
+ try:
+ ret, num_handles = self._multi.socket_action(fd, action)
+ except pycurl.error as e:
+ ret = e.args[0]
+ if ret != pycurl.E_CALL_MULTI_PERFORM:
+ break
+ self._finish_pending_requests()
def _handle_timeout(self) ->None:
"""Called by IOLoop when the requested timeout has passed."""
- pass
+ with self.exception_logging():
+ ret, num_handles = self._multi.socket_action(pycurl.SOCKET_TIMEOUT, 0)
+ self._finish_pending_requests()
def _handle_force_timeout(self) ->None:
"""Called by IOLoop periodically to ask libcurl to process any
events it may have forgotten about.
"""
- pass
+ with self.exception_logging():
+ ret, num_handles = self._multi.socket_action(pycurl.SOCKET_TIMEOUT, 0)
+ self._finish_pending_requests()
def _finish_pending_requests(self) ->None:
"""Process any requests that were completed by the last
call to multi.socket_action.
"""
- pass
+ while True:
+ num_q, ok_list, err_list = self._multi.info_read()
+ for curl in ok_list:
+ self._finish_curl(curl)
+ for curl, errnum, errmsg in err_list:
+ self._finish_curl(curl, errnum, errmsg)
+ if num_q == 0:
+ break
class CurlError(HTTPError):
diff --git a/tornado/escape.py b/tornado/escape.py
index 15f61dbe..5de69866 100644
--- a/tornado/escape.py
+++ b/tornado/escape.py
@@ -38,7 +38,9 @@ def xhtml_escape(value: Union[str, bytes]) ->str:
except that single quotes are now escaped as ``'`` instead of
``'`` and performance may be different.
"""
- pass
+ if isinstance(value, bytes):
+ value = value.decode('utf-8')
+ return html.escape(value)
def xhtml_unescape(value: Union[str, bytes]) ->str:
@@ -56,7 +58,9 @@ def xhtml_unescape(value: Union[str, bytes]) ->str:
Some invalid inputs such as surrogates now raise an error, and numeric
references to certain ISO-8859-1 characters are now handled correctly.
"""
- pass
+ if isinstance(value, bytes):
+ value = value.decode('utf-8')
+ return html.unescape(value)
def json_encode(value: Any) ->str:
@@ -66,7 +70,7 @@ def json_encode(value: Any) ->str:
will never contain the character sequence ``</`` which can be problematic
when JSON is embedded in an HTML ``<script>`` tag.
"""
- pass
+ return json.dumps(value).replace("</", "<\\/")
def json_decode(value: Union[str, bytes]) ->Any:
@@ -74,12 +78,14 @@ def json_decode(value: Union[str, bytes]) ->Any:
Supports both `str` and `bytes` inputs. Equvalent to `json.loads`.
"""
- pass
+ if isinstance(value, bytes):
+ value = value.decode('utf-8')
+ return json.loads(value)
def squeeze(value: str) ->str:
"""Replace all sequences of whitespace chars with a single space."""
- pass
+ return ' '.join(value.split())
def url_escape(value: Union[str, bytes], plus: bool=True) ->str:
@@ -97,7 +103,12 @@ def url_escape(value: Union[str, bytes], plus: bool=True) ->str:
.. versionadded:: 3.1
The ``plus`` argument
"""
- pass
+ if isinstance(value, bytes):
+ value = value.decode('utf-8')
+ if plus:
+ return urllib.parse.quote_plus(value)
+ else:
+ return urllib.parse.quote(value)
def url_unescape(value: Union[str, bytes], encoding: Optional[str]='utf-8',
@@ -119,7 +130,17 @@ def url_unescape(value: Union[str, bytes], encoding: Optional[str]='utf-8',
.. versionadded:: 3.1
The ``plus`` argument
"""
- pass
+ if encoding is None:
+ if isinstance(value, str):
+ value = value.encode('utf-8')
+ return urllib.parse.unquote_to_bytes(value)
+ else:
+ if isinstance(value, bytes):
+ value = value.decode(encoding)
+ if plus:
+ return urllib.parse.unquote_plus(value, encoding=encoding)
+ else:
+ return urllib.parse.unquote(value, encoding=encoding)
def parse_qs_bytes(qs: Union[str, bytes], keep_blank_values: bool=False,
@@ -131,7 +152,11 @@ def parse_qs_bytes(qs: Union[str, bytes], keep_blank_values: bool=False,
because it's too painful to keep them as byte strings in
python3 and in practice they're nearly always ascii anyway.
"""
- pass
+ if isinstance(qs, str):
+ qs = qs.encode('latin1')
+ result = urllib.parse.parse_qs(qs, keep_blank_values=keep_blank_values,
+ strict_parsing=strict_parsing, encoding='latin1')
+ return {k: [v.encode('latin1') for v in vs] for k, vs in result.items()}
_UTF8_TYPES = bytes, type(None)
@@ -143,7 +168,9 @@ def utf8(value: Union[None, str, bytes]) ->Optional[bytes]:
If the argument is already a byte string or None, it is returned unchanged.
Otherwise it must be a unicode string and is encoded as utf8.
"""
- pass
+ if value is None or isinstance(value, bytes):
+ return value
+ return value.encode('utf-8')
_TO_UNICODE_TYPES = unicode_type, type(None)
@@ -155,7 +182,9 @@ def to_unicode(value: Union[None, str, bytes]) ->Optional[str]:
If the argument is already a unicode string or None, it is returned
unchanged. Otherwise it must be a byte string and is decoded as utf8.
"""
- pass
+ if value is None or isinstance(value, str):
+ return value
+ return value.decode('utf-8')
_unicode = to_unicode
@@ -168,7 +197,16 @@ def recursive_unicode(obj: Any) ->Any:
Supports lists, tuples, and dictionaries.
"""
- pass
+ if isinstance(obj, dict):
+ return {recursive_unicode(key): recursive_unicode(value) for key, value in obj.items()}
+ elif isinstance(obj, list):
+ return [recursive_unicode(item) for item in obj]
+ elif isinstance(obj, tuple):
+ return tuple(recursive_unicode(item) for item in obj)
+ elif isinstance(obj, bytes):
+ return to_unicode(obj)
+ else:
+ return obj
_URL_RE = re.compile(to_unicode(
@@ -208,4 +246,35 @@ def linkify(text: Union[str, bytes], shorten: bool=False, extra_params:
"mailto"])``. It is very unsafe to include protocols such as
``javascript``.
"""
- pass
+ if isinstance(text, bytes):
+ text = text.decode('utf-8')
+
+ def make_link(m):
+ url = m.group(1)
+ proto = m.group(2)
+
+ if require_protocol and not proto:
+ return url # not protocol, no linkify
+
+ if proto and proto not in permitted_protocols:
+ return url # bad protocol, no linkify
+
+ href = m.group(1)
+ if not proto:
+ href = 'http://' + href # no proto specified, use http
+
+ if callable(extra_params):
+ params = " " + extra_params(href)
+ else:
+ params = " " + extra_params
+
+ # clip long urls. max_len is just an example value
+ max_len = 30
+ if shorten and len(url) > max_len:
+ before_clip = url[:max_len]
+ after_clip = url[max_len:]
+ url = before_clip + "..." + after_clip[-5:]
+
+ return f'<a href="{href}"{params}>{url}</a>'
+
+ return _URL_RE.sub(make_link, text)
diff --git a/tornado/gen.py b/tornado/gen.py
index 19f311cf..b2ae8d08 100644
--- a/tornado/gen.py
+++ b/tornado/gen.py
@@ -140,7 +140,19 @@ def coroutine(func: Union[Callable[..., 'Generator[Any, Any, _T]'],
awaitable object instead.
"""
- pass
+ @functools.wraps(func)
+ def wrapper(*args, **kwargs):
+ future = Future()
+ try:
+ result = func(*args, **kwargs)
+ if isinstance(result, Generator):
+ Runner(asyncio.get_event_loop().run_in_executor, result, future, next(result))
+ else:
+ future_set_result_unless_cancelled(future, result)
+ except Exception as e:
+ future_set_exc_info(future, sys.exc_info())
+ return future
+ return wrapper
def is_coroutine_function(func: Any) ->bool:
@@ -149,7 +161,8 @@ def is_coroutine_function(func: Any) ->bool:
.. versionadded:: 4.5
"""
- pass
+ return (asyncio.iscoroutinefunction(func) or
+ (hasattr(func, '__wrapped__') and asyncio.iscoroutinefunction(func.__wrapped__)))
class Return(Exception):
@@ -253,7 +266,7 @@ class WaitIterator(object):
def done(self) ->bool:
"""Returns True if this iterator has no more results."""
- pass
+ return len(self._unfinished) == 0 and len(self._finished) == 0
def next(self) ->Future:
"""Returns a `.Future` that will yield the next available result.
@@ -261,7 +274,14 @@ class WaitIterator(object):
Note that this `.Future` will not be the same object as any of
the inputs.
"""
- pass
+ if self._finished:
+ return self._return_result(self._finished.popleft())
+ elif self._unfinished:
+ future = Future()
+ self._running_future = future
+ return future
+ else:
+ raise StopIteration()
def _return_result(self, done: Future) ->Future:
"""Called set the returned future's state that of the future
@@ -325,7 +345,29 @@ def multi(children: Union[List[_Yieldable], Dict[Any, _Yieldable]],
other than ``YieldPoint`` and `.Future`.
"""
- pass
+ if isinstance(children, dict):
+ keys = list(children.keys())
+ children_seq = list(children.values())
+ else:
+ keys = None
+ children_seq = children
+
+ children_futures = [convert_yielded(i) for i in children_seq]
+ future = Future()
+
+ def callback(f):
+ try:
+ result_list = f.result()
+ except Exception as e:
+ future.set_exception(e)
+ else:
+ if keys is not None:
+ future_set_result_unless_cancelled(future, dict(zip(keys, result_list)))
+ else:
+ future_set_result_unless_cancelled(future, result_list)
+
+ future_add_done_callback(asyncio.gather(*children_futures), callback)
+ return future
Multi = multi
diff --git a/tornado/http1connection.py b/tornado/http1connection.py
index aa35011f..dff16a6e 100644
--- a/tornado/http1connection.py
+++ b/tornado/http1connection.py
@@ -121,7 +121,30 @@ class HTTP1Connection(httputil.HTTPConnection):
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.
"""
- pass
+ async def _read_response():
+ try:
+ response_start_line = await self.stream.read_until(b"\r\n")
+ start_line = httputil.parse_response_start_line(response_start_line)
+ self._response_start_line = start_line
+
+ headers = await self.stream.read_until(b"\r\n\r\n")
+ headers = httputil.HTTPHeaders.parse(headers)
+
+ await delegate.headers_received(start_line, headers)
+
+ if headers.get("Transfer-Encoding") == "chunked":
+ await self._read_chunked_body(delegate)
+ elif "Content-Length" in headers:
+ content_length = int(headers["Content-Length"])
+ await self._read_fixed_body(delegate, content_length)
+ else:
+ await self._read_body_until_close(delegate)
+
+ return not self.stream.closed()
+ except iostream.StreamClosedError:
+ return False
+
+ return asyncio.ensure_future(_read_response())
def _clear_callbacks(self) ->None:
"""Clears the callback attributes.
@@ -129,7 +152,10 @@ class HTTP1Connection(httputil.HTTPConnection):
This allows the request handler to be garbage collected more
quickly in CPython by breaking up reference cycles.
"""
- pass
+ self._write_callback = None
+ self._write_future = None
+ self._close_callback = None
+ self._body_future = None
def set_close_callback(self, callback: Optional[Callable[[], None]]
) ->None:
@@ -144,7 +170,7 @@ class HTTP1Connection(httputil.HTTPConnection):
after sending its request but before receiving all the
response.
"""
- pass
+ self._close_callback = callback
def detach(self) ->iostream.IOStream:
"""Take control of the underlying stream.
@@ -154,21 +180,24 @@ class HTTP1Connection(httputil.HTTPConnection):
`.HTTPMessageDelegate.headers_received`. Intended for implementing
protocols like websockets that tunnel over an HTTP handshake.
"""
- pass
+ self._clear_callbacks()
+ stream = self.stream
+ self.stream = None
+ return stream
def set_body_timeout(self, timeout: float) ->None:
"""Sets the body timeout for a single request.
Overrides the value from `.HTTP1ConnectionParameters`.
"""
- pass
+ self._body_timeout = timeout
def set_max_body_size(self, max_body_size: int) ->None:
"""Sets the body size limit for a single request.
Overrides the value from `.HTTP1ConnectionParameters`.
"""
- pass
+ self._max_body_size = max_body_size
def write_headers(self, start_line: Union[httputil.RequestStartLine,
httputil.ResponseStartLine], headers: httputil.HTTPHeaders, chunk:
diff --git a/tornado/httpclient.py b/tornado/httpclient.py
index 6069b0be..1adcc7c3 100644
--- a/tornado/httpclient.py
+++ b/tornado/httpclient.py
@@ -98,7 +98,10 @@ class HTTPClient(object):
def close(self) ->None:
"""Closes the HTTPClient, freeing any resources used."""
- pass
+ if not self._closed:
+ self._io_loop.close()
+ self._async_client.close()
+ self._closed = True
def fetch(self, request: Union['HTTPRequest', str], **kwargs: Any
) ->'HTTPResponse':
@@ -111,7 +114,24 @@ class HTTPClient(object):
If an error occurs during the fetch, we raise an `HTTPError` unless
the ``raise_error`` keyword argument is set to False.
"""
- pass
+ if self._closed:
+ raise RuntimeError("HTTP client is closed")
+
+ if isinstance(request, str):
+ request = HTTPRequest(request, **kwargs)
+ elif kwargs:
+ raise ValueError("kwargs can't be used if request is an HTTPRequest object")
+
+ def callback(future):
+ try:
+ result = future.result()
+ except Exception as e:
+ if request.raise_error:
+ raise
+ result = HTTPResponse(request, 599, error=e)
+ return result
+
+ return self._io_loop.run_sync(lambda: self._async_client.fetch(request, raise_error=False)).add_done_callback(callback)
class AsyncHTTPClient(Configurable):
@@ -182,7 +202,10 @@ class AsyncHTTPClient(Configurable):
``close()``.
"""
- pass
+ if self._instance_cache is not None:
+ if self._instance_cache.get(self.io_loop) is self:
+ del self._instance_cache[self.io_loop]
+ self.io_loop.run_sync(self._close_async)
def fetch(self, request: Union[str, 'HTTPRequest'], raise_error: bool=
True, **kwargs: Any) ->'Future[HTTPResponse]':
@@ -214,7 +237,13 @@ class AsyncHTTPClient(Configurable):
`HTTPError` raised when a non-200 response code is used,
instead of suppressing all errors.
"""
- pass
+ if isinstance(request, str):
+ request = HTTPRequest(request, **kwargs)
+ elif kwargs:
+ raise ValueError("kwargs can't be used if request is an HTTPRequest object")
+
+ future = self.io_loop.run_in_executor(None, self._fetch_impl, request, raise_error)
+ return future
@classmethod
def configure(cls, impl: 'Union[None, str, Type[Configurable]]', **
@@ -512,7 +541,8 @@ class HTTPResponse(object):
def rethrow(self) ->None:
"""If there was an error on the request, raise an `HTTPError`."""
- pass
+ if self.error:
+ raise self.error
def __repr__(self) ->str:
args = ','.join('%s=%r' % i for i in sorted(self.__dict__.items()))
diff --git a/tornado/httpserver.py b/tornado/httpserver.py
index 1a203b99..6cd4c488 100644
--- a/tornado/httpserver.py
+++ b/tornado/httpserver.py
@@ -136,7 +136,35 @@ class HTTPServer(TCPServer, Configurable, httputil.HTTPServerConnectionDelegate
"""
def __init__(self, *args: Any, **kwargs: Any) ->None:
- pass
+ # Initialize TCPServer
+ super(HTTPServer, self).__init__()
+
+ # Extract HTTP-specific parameters
+ self.request_callback = args[0] if args else None
+ self.xheaders = kwargs.pop("xheaders", False)
+ self.protocol = kwargs.pop("protocol", None)
+ self.decompress_request = kwargs.pop("decompress_request", False)
+ self.chunk_size = kwargs.pop("chunk_size", 65536)
+ self.max_header_size = kwargs.pop("max_header_size", None)
+ self.idle_connection_timeout = kwargs.pop("idle_connection_timeout", None)
+ self.body_timeout = kwargs.pop("body_timeout", None)
+ self.max_body_size = kwargs.pop("max_body_size", None)
+ self.trusted_downstream = kwargs.pop("trusted_downstream", None)
+
+ # SSL options
+ self.ssl_options = kwargs.pop("ssl_options", None)
+
+ # Connection parameters
+ self.conn_params = HTTP1ConnectionParameters(
+ decompress=self.decompress_request,
+ chunk_size=self.chunk_size,
+ max_header_size=self.max_header_size,
+ header_timeout=self.idle_connection_timeout,
+ max_body_size=self.max_body_size,
+ body_timeout=self.body_timeout,
+ )
+
+ self._connections = set()
async def close_all_connections(self) ->None:
"""Close all open connections and asynchronously wait for them to finish.
@@ -152,7 +180,13 @@ class HTTPServer(TCPServer, Configurable, httputil.HTTPServerConnectionDelegate
Note that this method is a coroutine and must be called with ``await``.
"""
- pass
+ while self._connections:
+ # Make a copy of the set before iterating, as it may be modified
+ # during iteration
+ for conn in list(self._connections):
+ await conn.close()
+ # Allow the event loop to run and process the closed connections
+ await asyncio.sleep(0)
class _CallableAdapter(httputil.HTTPMessageDelegate):
@@ -201,7 +235,28 @@ class _HTTPRequestContext(object):
def _apply_xheaders(self, headers: httputil.HTTPHeaders) ->None:
"""Rewrite the ``remote_ip`` and ``protocol`` fields."""
- pass
+ # Check for X-Real-Ip or X-Forwarded-For headers
+ real_ip = headers.get("X-Real-Ip")
+ forwarded_for = headers.get("X-Forwarded-For")
+
+ if real_ip:
+ self.remote_ip = real_ip
+ elif forwarded_for:
+ # If we have trusted downstream servers, skip them
+ forwarded_ips = [ip.strip() for ip in forwarded_for.split(',')]
+ while forwarded_ips and forwarded_ips[-1] in self.trusted_downstream:
+ forwarded_ips.pop()
+ if forwarded_ips:
+ self.remote_ip = forwarded_ips[-1]
+
+ # Check for X-Scheme or X-Forwarded-Proto headers
+ scheme = headers.get("X-Scheme")
+ proto = headers.get("X-Forwarded-Proto")
+
+ if scheme:
+ self.protocol = scheme
+ elif proto:
+ self.protocol = proto
def _unapply_xheaders(self) ->None:
"""Undo changes from `_apply_xheaders`.
@@ -209,7 +264,8 @@ class _HTTPRequestContext(object):
Xheaders are per-request so they should not leak to the next
request on the same connection.
"""
- pass
+ self.remote_ip = self._orig_remote_ip
+ self.protocol = self._orig_protocol
class _ProxyAdapter(httputil.HTTPMessageDelegate):
diff --git a/tornado/httputil.py b/tornado/httputil.py
index 907aef4e..075e595b 100644
--- a/tornado/httputil.py
+++ b/tornado/httputil.py
@@ -36,7 +36,7 @@ def _normalize_header(name: str) ->str:
>>> _normalize_header("coNtent-TYPE")
'Content-Type'
"""
- pass
+ return "-".join(word.capitalize() for word in name.split("-"))
class HTTPHeaders(collections.abc.MutableMapping):
@@ -97,11 +97,18 @@ class HTTPHeaders(collections.abc.MutableMapping):
def add(self, name: str, value: str) ->None:
"""Adds a new value for the given key."""
- pass
+ norm_name = _normalize_header(name)
+ self._last_key = norm_name
+ if norm_name in self._dict:
+ self._dict[norm_name] = self._dict[norm_name] + ',' + value
+ self._as_list[norm_name].append(value)
+ else:
+ self[norm_name] = value
def get_list(self, name: str) ->List[str]:
"""Returns all values for the given header as a list."""
- pass
+ norm_name = _normalize_header(name)
+ return self._as_list.get(norm_name, [])
def get_all(self) ->Iterable[Tuple[str, str]]:
"""Returns an iterable of all (name, value) pairs.
@@ -109,7 +116,9 @@ class HTTPHeaders(collections.abc.MutableMapping):
If a header has multiple values, multiple pairs will be
returned with the same name.
"""
- pass
+ for name, values in self._as_list.items():
+ for value in values:
+ yield (name, value)
def parse_line(self, line: str) ->None:
"""Updates the dictionary with a single header line.
@@ -119,7 +128,14 @@ class HTTPHeaders(collections.abc.MutableMapping):
>>> h.get('content-type')
'text/html'
"""
- pass
+ if line[0].isspace():
+ # continuation of a multi-line header
+ new_part = ' ' + line.lstrip()
+ self._dict[self._last_key] += new_part
+ self._as_list[self._last_key][-1] += new_part
+ else:
+ name, value = line.split(":", 1)
+ self.add(name, value.strip())
@classmethod
def parse(cls, headers: str) ->'HTTPHeaders':
@@ -135,7 +151,14 @@ class HTTPHeaders(collections.abc.MutableMapping):
mix of `KeyError`, and `ValueError`.
"""
- pass
+ h = cls()
+ for line in headers.splitlines():
+ if line:
+ try:
+ h.parse_line(line)
+ except ValueError:
+ raise HTTPInputError("Malformed header line: %r" % line)
+ return h
def __setitem__(self, name: str, value: str) ->None:
norm_name = _normalize_header(name)
@@ -293,15 +316,25 @@ class HTTPServerRequest(object):
@property
def cookies(self) ->Dict[str, http.cookies.Morsel]:
"""A dictionary of ``http.cookies.Morsel`` objects."""
- pass
+ if not hasattr(self, "_cookies"):
+ self._cookies = http.cookies.SimpleCookie()
+ if "Cookie" in self.headers:
+ try:
+ self._cookies.load(native_str(self.headers["Cookie"]))
+ except http.cookies.CookieError:
+ self._cookies = {}
+ return self._cookies
def full_url(self) ->str:
"""Reconstructs the full URL for this request."""
- pass
+ return "%s://%s%s" % (self.protocol, self.host, self.uri)
def request_time(self) ->float:
"""Returns the amount of time it took for this request to execute."""
- pass
+ if self._finish_time is None:
+ return time.time() - self._start_time
+ else:
+ return self._finish_time - self._start_time
def get_ssl_certificate(self, binary_form: bool=False) ->Union[None,
Dict, bytes]:
@@ -323,7 +356,10 @@ class HTTPServerRequest(object):
details.
http://docs.python.org/library/ssl.html#sslsocket-objects
"""
- pass
+ try:
+ return self.connection.get_ssl_certificate(binary_form)
+ except AttributeError:
+ return None
def __repr__(self) ->str:
attrs = 'protocol', 'host', 'method', 'uri', 'version', 'remote_ip'
@@ -477,7 +513,22 @@ def url_concat(url: str, args: Union[None, Dict[str, str], List[Tuple[str,
>>> url_concat("http://example.com/foo?a=b", [("c", "d"), ("c", "d2")])
'http://example.com/foo?a=b&c=d&c=d2'
"""
- pass
+ if args is None:
+ return url
+
+ if isinstance(args, dict):
+ args = list(args.items())
+
+ # Remove None values
+ args = [(k, v) for k, v in args if v is not None]
+
+ if not args:
+ return url
+
+ if url[-1] not in ('?', '&'):
+ url += '&' if ('?' in url) else '?'
+
+ return url + urlencode(args)
class HTTPFile(ObjectDict):
@@ -525,7 +576,23 @@ def _parse_request_range(range_header: str) ->Optional[Tuple[Optional[int],
[0]: http://greenbytes.de/tech/webdav/draft-ietf-httpbis-p5-range-latest.html#byte.ranges
"""
- pass
+ if not range_header.startswith("bytes="):
+ return None
+ ranges = range_header[6:].split(",")
+ if len(ranges) != 1:
+ return None
+ start, sep, end = ranges[0].partition("-")
+ try:
+ if not start:
+ return (-int(end), None) if end else (None, None)
+ if not end:
+ return (int(start), None)
+ start, end = int(start), int(end)
+ if start > end:
+ return None
+ return (start, end + 1)
+ except ValueError:
+ return None
def _get_content_range(start: Optional[int], end: Optional[int], total: int
@@ -539,7 +606,13 @@ def _get_content_range(start: Optional[int], end: Optional[int], total: int
>>> print(_get_content_range(None, None, 4))
bytes 0-3/4
"""
- pass
+ if start is None:
+ start = 0
+ if end is None:
+ end = total
+ else:
+ end = min(end, total)
+ return f"bytes {start}-{end-1}/{total}"
def parse_body_arguments(content_type: str, body: bytes, arguments: Dict[
@@ -553,7 +626,26 @@ def parse_body_arguments(content_type: str, body: bytes, arguments: Dict[
and ``files`` parameters are dictionaries that will be updated
with the parsed contents.
"""
- pass
+ if content_type.startswith("application/x-www-form-urlencoded"):
+ try:
+ uri_arguments = parse_qs_bytes(body, keep_blank_values=True)
+ except Exception as e:
+ gen_log.warning('Invalid x-www-form-urlencoded body: %s', e)
+ uri_arguments = {}
+ for name, values in uri_arguments.items():
+ if name in arguments:
+ arguments[name].extend(values)
+ else:
+ arguments[name] = values
+ elif content_type.startswith("multipart/form-data"):
+ try:
+ boundary = content_type.split("boundary=")[1].encode("latin1")
+ except IndexError:
+ gen_log.warning("Invalid multipart/form-data")
+ else:
+ parse_multipart_form_data(boundary, body, arguments, files)
+ else:
+ gen_log.warning("Unsupported Content-Type: %s", content_type)
def parse_multipart_form_data(boundary: bytes, data: bytes, arguments: Dict
@@ -569,7 +661,36 @@ def parse_multipart_form_data(boundary: bytes, data: bytes, arguments: Dict
Now recognizes non-ASCII filenames in RFC 2231/5987
(``filename*=``) format.
"""
- pass
+ parts = data.split(b"--" + boundary)
+ for part in parts[1:-1]: # skip preamble and epilogue
+ eoh = part.find(b"\r\n\r\n")
+ if eoh == -1:
+ gen_log.warning("multipart/form-data missing headers")
+ continue
+ headers = HTTPHeaders.parse(part[:eoh].decode("utf-8"))
+ disp_header = headers.get("Content-Disposition", "")
+ disposition, disp_params = _parse_header(disp_header)
+ if disposition != "form-data" or not part.endswith(b"\r\n"):
+ gen_log.warning("Invalid multipart/form-data")
+ continue
+ value = part[eoh + 4:-2]
+ name = disp_params.get("name")
+ if name is None:
+ gen_log.warning("multipart/form-data value missing name")
+ continue
+ name = name.decode("utf-8")
+ filename = disp_params.get("filename")
+ if filename is not None:
+ filename = filename.decode("utf-8")
+ if filename:
+ file = HTTPFile(
+ filename=filename,
+ body=value,
+ content_type=headers.get("Content-Type", "application/unknown"),
+ )
+ files.setdefault(name, []).append(file)
+ else:
+ arguments.setdefault(name, []).append(value)
def format_timestamp(ts: Union[int, float, tuple, time.struct_time,
@@ -584,7 +705,17 @@ def format_timestamp(ts: Union[int, float, tuple, time.struct_time,
>>> format_timestamp(1359312200)
'Sun, 27 Jan 2013 18:43:20 GMT'
"""
- pass
+ if isinstance(ts, (int, float)):
+ time_tuple = time.gmtime(ts)
+ elif isinstance(ts, (tuple, time.struct_time)):
+ time_tuple = ts
+ elif isinstance(ts, datetime.datetime):
+ if ts.tzinfo is not None:
+ ts = ts.astimezone(datetime.timezone.utc).replace(tzinfo=None)
+ time_tuple = ts.utctimetuple()
+ else:
+ raise TypeError("unknown timestamp type: %r" % ts)
+ return email.utils.formatdate(time.mktime(time_tuple), usegmt=True)
RequestStartLine = collections.namedtuple('RequestStartLine', ['method',
@@ -600,7 +731,13 @@ def parse_request_start_line(line: str) ->RequestStartLine:
>>> parse_request_start_line("GET /foo HTTP/1.1")
RequestStartLine(method='GET', path='/foo', version='HTTP/1.1')
"""
- pass
+ try:
+ method, path, version = line.split(" ")
+ except ValueError:
+ raise HTTPInputError("Malformed HTTP request line")
+ if not _http_version_re.match(version):
+ raise HTTPInputError("Malformed HTTP version in HTTP Request-Line")
+ return RequestStartLine(method, path, version)
ResponseStartLine = collections.namedtuple('ResponseStartLine', ['version',
@@ -616,7 +753,15 @@ def parse_response_start_line(line: str) ->ResponseStartLine:
>>> parse_response_start_line("HTTP/1.1 200 OK")
ResponseStartLine(version='HTTP/1.1', code=200, reason='OK')
"""
- pass
+ match = _http_response_line_re.match(line)
+ if not match:
+ raise HTTPInputError("Malformed HTTP response line")
+ version, code, reason = match.groups()
+ try:
+ code = int(code)
+ except ValueError:
+ raise HTTPInputError("Malformed HTTP status code")
+ return ResponseStartLine(version, code, reason)
def _parse_header(line: str) ->Tuple[str, Dict[str, str]]:
@@ -633,7 +778,24 @@ def _parse_header(line: str) ->Tuple[str, Dict[str, str]]:
>>> d['foo']
'b\\\\a"r'
"""
- pass
+ parts = line.split(';')
+ content_type = parts.pop(0).strip()
+ params = {}
+ for part in parts:
+ if '=' not in part:
+ continue
+ key, value = part.split('=', 1)
+ key = key.strip()
+ value = value.strip()
+ if value[0] == value[-1] == '"':
+ value = value[1:-1]
+ value = re.sub(r'\\(.)', r'\1', value)
+ elif key.endswith('*'):
+ encoding, lang, value = value.split("'", 2)
+ value = unquote(value, encoding=encoding)
+ key = key[:-1]
+ params[key] = value
+ return content_type, params
def _encode_header(key: str, pdict: Dict[str, str]) ->str:
@@ -643,7 +805,19 @@ def _encode_header(key: str, pdict: Dict[str, str]) ->str:
... {'client_max_window_bits': 15, 'client_no_context_takeover': None})
'permessage-deflate; client_max_window_bits=15; client_no_context_takeover'
"""
- pass
+ parts = [key]
+ for k, v in pdict.items():
+ if v is None:
+ parts.append(k)
+ elif isinstance(v, int):
+ parts.append("%s=%d" % (k, v))
+ elif isinstance(v, str):
+ if _cookie_params_re.search(v):
+ v = '"%s"' % _cookie_quote(v)
+ parts.append("%s=%s" % (k, v))
+ else:
+ raise ValueError("Unsupported value: %r" % v)
+ return "; ".join(parts)
def encode_username_password(username: Union[str, bytes], password: Union[
@@ -654,7 +828,11 @@ def encode_username_password(username: Union[str, bytes], password: Union[
.. versionadded:: 5.1
"""
- pass
+ if isinstance(username, str):
+ username = username.encode('utf-8')
+ if isinstance(password, str):
+ password = password.encode('utf-8')
+ return b"%s:%s" % (username, password)
_netloc_re = re.compile('^(.+):(\\d+)$')
@@ -667,7 +845,14 @@ def split_host_and_port(netloc: str) ->Tuple[str, Optional[int]]:
.. versionadded:: 4.1
"""
- pass
+ match = _netloc_re.match(netloc)
+ if match:
+ host = match.group(1)
+ port = int(match.group(2))
+ else:
+ host = netloc
+ port = None
+ return (host, port)
def qs_to_qsl(qs: Dict[str, List[AnyStr]]) ->Iterable[Tuple[str, AnyStr]]:
@@ -675,7 +860,9 @@ def qs_to_qsl(qs: Dict[str, List[AnyStr]]) ->Iterable[Tuple[str, AnyStr]]:
.. versionadded:: 5.0
"""
- pass
+ for k, v in qs.items():
+ for x in v:
+ yield (k, x)
_OctalPatt = re.compile('\\\\[0-3][0-7][0-7]')
@@ -690,7 +877,30 @@ def _unquote_cookie(s: str) ->str:
library (http.cookies._unquote) so we don't have to depend on
non-public interfaces.
"""
- pass
+ if len(s) < 2:
+ return s
+ if s[0] != '"' or s[-1] != '"':
+ return s
+
+ s = s[1:-1]
+
+ i = 0
+ n = len(s)
+ res = []
+ while 0 <= i < n:
+ o = s.find('\\', i)
+ if o < 0:
+ res.append(s[i:])
+ break
+ res.append(s[i:o])
+ if o < n - 1:
+ res.append(s[o+1])
+ i = o + 2
+ else:
+ # error condition, char is not escaped
+ res.append('\\')
+ i = o + 1
+ return _nulljoin(res)
def parse_cookie(cookie: str) ->Dict[str, str]:
@@ -704,4 +914,16 @@ def parse_cookie(cookie: str) ->Dict[str, str]:
.. versionadded:: 4.4.2
"""
- pass
+ cookie_dict = {}
+ for chunk in cookie.split(';'):
+ if '=' in chunk:
+ key, val = chunk.split('=', 1)
+ else:
+ # Assume an empty name per
+ # https://bugzilla.mozilla.org/show_bug.cgi?id=169091
+ key, val = '', chunk
+ key, val = key.strip(), val.strip()
+ if key or val:
+ # unquote using Python's algorithm.
+ cookie_dict[key] = _unquote_cookie(val)
+ return cookie_dict
diff --git a/tornado/ioloop.py b/tornado/ioloop.py
index 114f1626..bafcde41 100644
--- a/tornado/ioloop.py
+++ b/tornado/ioloop.py
@@ -18,6 +18,7 @@ import time
import math
import random
import warnings
+from typing import Optional
from inspect import isawaitable
from tornado.concurrent import Future, is_future, chain_future, future_set_exc_info, future_add_done_callback
from tornado.log import app_log
@@ -146,7 +147,8 @@ class IOLoop(Configurable):
.. deprecated:: 5.0
"""
- pass
+ warnings.warn("IOLoop.instance() is deprecated, use IOLoop.current() instead", DeprecationWarning)
+ return IOLoop.current()
def install(self) ->None:
"""Deprecated alias for `make_current()`.
@@ -160,7 +162,8 @@ class IOLoop(Configurable):
.. deprecated:: 5.0
"""
- pass
+ warnings.warn("IOLoop.install() is deprecated, use IOLoop.make_current() instead", DeprecationWarning)
+ self.make_current()
@staticmethod
def clear_instance() ->None:
@@ -176,7 +179,8 @@ class IOLoop(Configurable):
.. deprecated:: 5.0
"""
- pass
+ warnings.warn("IOLoop.clear_instance() is deprecated, use IOLoop.clear_current() instead", DeprecationWarning)
+ IOLoop.clear_current()
@staticmethod
def current(instance: bool=True) ->Optional['IOLoop']:
@@ -203,7 +207,21 @@ class IOLoop(Configurable):
It is deprecated to call ``IOLoop.current()`` when no `asyncio`
event loop is running.
"""
- pass
+ try:
+ loop = asyncio.get_event_loop()
+ except RuntimeError:
+ if not instance:
+ return None
+ warnings.warn("IOLoop.current() called with no running event loop", DeprecationWarning)
+ loop = asyncio.new_event_loop()
+ asyncio.set_event_loop(loop)
+
+ try:
+ return IOLoop._ioloop_for_asyncio[loop]
+ except KeyError:
+ if instance:
+ return IOLoop(loop)
+ return None
def make_current(self) ->None:
"""Makes this the `IOLoop` for the current thread.
@@ -225,7 +243,8 @@ class IOLoop(Configurable):
Setting and clearing the current event loop through Tornado is
deprecated. Use ``asyncio.set_event_loop`` instead if you need this.
"""
- pass
+ warnings.warn("Setting and clearing the current event loop through Tornado is deprecated. Use asyncio.set_event_loop instead.", DeprecationWarning)
+ asyncio.set_event_loop(self.asyncio_loop)
@staticmethod
def clear_current() ->None:
@@ -237,14 +256,19 @@ class IOLoop(Configurable):
This method also clears the current `asyncio` event loop.
.. deprecated:: 6.2
"""
- pass
+ warnings.warn("IOLoop.clear_current() is deprecated", DeprecationWarning)
+ old_loop = asyncio.get_event_loop()
+ if old_loop in IOLoop._ioloop_for_asyncio:
+ del IOLoop._ioloop_for_asyncio[old_loop]
+ asyncio.set_event_loop(None)
def _clear_current_hook(self) ->None:
"""Instance method called when an IOLoop ceases to be current.
May be overridden by subclasses as a counterpart to make_current.
"""
- pass
+ if self.asyncio_loop in IOLoop._ioloop_for_asyncio:
+ del IOLoop._ioloop_for_asyncio[self.asyncio_loop]
def close(self, all_fds: bool=False) ->None:
"""Closes the `IOLoop`, freeing any resources used.
diff --git a/tornado/iostream.py b/tornado/iostream.py
index 1f9c2e76..98e83e4f 100644
--- a/tornado/iostream.py
+++ b/tornado/iostream.py
@@ -89,20 +89,53 @@ class _StreamBuffer(object):
"""
Append the given piece of data (should be a buffer-compatible object).
"""
- pass
+ if len(data) > self._large_buf_threshold:
+ self._buffers.append(memoryview(data))
+ else:
+ self._buffers.append(bytes(data))
+ self._size += len(data)
def peek(self, size: int) ->memoryview:
"""
Get a view over at most ``size`` bytes (possibly fewer) at the
current buffer position.
"""
- pass
+ if not self._buffers:
+ return memoryview(b"")
+
+ first_buf = self._buffers[0]
+ if len(first_buf) - self._first_pos >= size:
+ return memoryview(first_buf)[self._first_pos:self._first_pos + size]
+
+ view = bytearray(size)
+ pos = 0
+ for buf in self._buffers:
+ if pos == size:
+ break
+ if pos == 0:
+ chunk = buf[self._first_pos:]
+ else:
+ chunk = buf
+ if len(chunk) > size - pos:
+ chunk = chunk[:size - pos]
+ view[pos:pos + len(chunk)] = chunk
+ pos += len(chunk)
+
+ return memoryview(view)[:pos]
def advance(self, size: int) ->None:
"""
Advance the current buffer position by ``size`` bytes.
"""
- pass
+ self._size -= size
+ while size > 0 and self._buffers:
+ buf = self._buffers[0]
+ if self._first_pos + size < len(buf):
+ self._first_pos += size
+ return
+ size -= len(buf) - self._first_pos
+ self._first_pos = 0
+ del self._buffers[0]
class BaseIOStream(object):
@@ -171,7 +204,7 @@ class BaseIOStream(object):
def fileno(self) ->Union[int, ioloop._Selectable]:
"""Returns the file descriptor for this stream."""
- pass
+ return self.socket.fileno()
def close_fd(self) ->None:
"""Closes the file underlying this stream.
@@ -179,14 +212,22 @@ class BaseIOStream(object):
``close_fd`` is called by `BaseIOStream` and should not be called
elsewhere; other users should call `close` instead.
"""
- pass
+ if self.socket is not None:
+ self.socket.close()
+ self.socket = None
def write_to_fd(self, data: memoryview) ->int:
"""Attempts to write ``data`` to the underlying file.
Returns the number of bytes written.
"""
- pass
+ try:
+ return self.socket.send(data)
+ except (socket.error, IOError, OSError) as e:
+ if errno_from_exception(e) in _ERRNO_WOULDBLOCK:
+ return 0
+ else:
+ raise
def read_from_fd(self, buf: Union[bytearray, memoryview]) ->Optional[int]:
"""Attempts to read from the underlying file.
@@ -201,7 +242,15 @@ class BaseIOStream(object):
Interface redesigned to take a buffer and return a number
of bytes instead of a freshly-allocated object.
"""
- pass
+ try:
+ return self.socket.recv_into(buf)
+ except (socket.error, IOError, OSError) as e:
+ if errno_from_exception(e) in _ERRNO_WOULDBLOCK:
+ return None
+ elif errno_from_exception(e) in _ERRNO_CONNRESET:
+ return 0
+ else:
+ raise
def get_fd_error(self) ->Optional[Exception]:
"""Returns information about any error on the underlying file.
@@ -211,7 +260,13 @@ class BaseIOStream(object):
with additional information, or None if no such information is
available.
"""
- pass
+ if self.socket is None:
+ return None
+ err = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
+ if err != 0:
+ return socket.error(err, os.strerror(err))
+ else:
+ return None
def read_until_regex(self, regex: bytes, max_bytes: Optional[int]=None
) ->Awaitable[bytes]:
diff --git a/tornado/locale.py b/tornado/locale.py
index 201f720a..15b70711 100644
--- a/tornado/locale.py
+++ b/tornado/locale.py
@@ -51,7 +51,13 @@ def get(*locale_codes: str) ->'Locale':
the specified locales. You can change the default locale with
`set_default_locale()`.
"""
- pass
+ for code in locale_codes:
+ if code in _translations:
+ return _translations[code]
+ parts = code.split('_')
+ if len(parts) > 1 and parts[0] in _translations:
+ return _translations[parts[0]]
+ return _translations.get(_default_locale)
def set_default_locale(code: str) ->None:
@@ -62,7 +68,8 @@ def set_default_locale(code: str) ->None:
the default locale to the destination locale. Consequently, you don't
need to create a translation file for the default locale.
"""
- pass
+ global _default_locale
+ _default_locale = code
def load_translations(directory: str, encoding: Optional[str]=None) ->None:
@@ -100,7 +107,40 @@ def load_translations(directory: str, encoding: Optional[str]=None) ->None:
Added ``encoding`` parameter. Added support for BOM-based encoding
detection, UTF-16, and UTF-8-with-BOM.
"""
- pass
+ global _translations, _supported_locales
+ for path in glob.glob(os.path.join(directory, '*.csv')):
+ locale = os.path.basename(path).split('.')[0]
+ if encoding is None:
+ # Try to detect the encoding
+ with open(path, 'rb') as f:
+ data = f.read()
+ if data.startswith(codecs.BOM_UTF16):
+ encoding = 'utf-16'
+ elif data.startswith(codecs.BOM_UTF8):
+ encoding = 'utf-8-sig'
+ else:
+ encoding = 'utf-8'
+
+ with open(path, 'r', encoding=encoding) as f:
+ _translations[locale] = {}
+ for i, row in enumerate(csv.reader(f)):
+ if len(row) == 2:
+ singular, translation = row
+ plural = None
+ elif len(row) == 3:
+ singular, translation, plural = row
+ else:
+ gen_log.error(f"Malformed translation in {path}, line {i+1}")
+ continue
+
+ if plural in ('plural', 'singular'):
+ if singular not in _translations[locale]:
+ _translations[locale][singular] = {}
+ _translations[locale][singular][plural] = translation
+ else:
+ _translations[locale][singular] = translation
+
+ _supported_locales = frozenset(_translations.keys())
def load_gettext_translations(directory: str, domain: str) ->None:
@@ -124,12 +164,22 @@ def load_gettext_translations(directory: str, domain: str) ->None:
msgfmt mydomain.po -o {directory}/pt_BR/LC_MESSAGES/mydomain.mo
"""
- pass
+ global _translations, _supported_locales, _use_gettext
+ for lang in os.listdir(directory):
+ if os.path.isdir(os.path.join(directory, lang)):
+ try:
+ translation = gettext.translation(domain, directory, languages=[lang])
+ _translations[lang] = GettextLocale(lang, translation)
+ except Exception as e:
+ gen_log.error(f"Cannot load translation for '{lang}': {str(e)}")
+ continue
+ _supported_locales = frozenset(_translations.keys())
+ _use_gettext = True
def get_supported_locales() ->Iterable[str]:
"""Returns a list of all the supported locale codes."""
- pass
+ return list(_supported_locales)
class Locale(object):
@@ -143,7 +193,7 @@ class Locale(object):
@classmethod
def get_closest(cls, *locale_codes: str) ->'Locale':
"""Returns the closest match for the given locale code."""
- pass
+ return get(*locale_codes)
@classmethod
def get(cls, code: str) ->'Locale':
@@ -151,7 +201,9 @@ class Locale(object):
If it is not supported, we raise an exception.
"""
- pass
+ if code not in _supported_locales:
+ raise Exception(f"Unsupported locale: {code}")
+ return _translations[code]
def __init__(self, code: str) ->None:
self.code = code
@@ -177,7 +229,20 @@ class Locale(object):
and we return the singular form for the given message when
``count == 1``.
"""
- pass
+ if plural_message is not None:
+ assert count is not None
+ if _use_gettext:
+ return self.ngettext(message, plural_message, count)
+ else:
+ if count != 1:
+ return self.translations.get(message, {}).get('plural', plural_message)
+ else:
+ return self.translations.get(message, {}).get('singular', message)
+ else:
+ if _use_gettext:
+ return self.gettext(message)
+ else:
+ return self.translations.get(message, message)
def format_date(self, date: Union[int, float, datetime.datetime],
gmt_offset: int=0, relative: bool=True, shorter: bool=False,
@@ -197,16 +262,76 @@ class Locale(object):
Aware `datetime.datetime` objects are now supported (naive
datetimes are still assumed to be UTC).
"""
- pass
+ if isinstance(date, (int, float)):
+ date = datetime.datetime.fromtimestamp(date, datetime.timezone.utc)
+ elif isinstance(date, datetime.datetime):
+ if date.tzinfo is None:
+ date = date.replace(tzinfo=datetime.timezone.utc)
+
+ now = datetime.datetime.now(datetime.timezone.utc)
+ if date > now:
+ if relative and (date - now).total_seconds() < 60:
+ return self.translate("in a moment")
+ else:
+ return self.format_day(date, gmt_offset, dow=True)
+
+ local_date = date.astimezone(datetime.timezone(datetime.timedelta(hours=gmt_offset)))
+ local_now = now.astimezone(datetime.timezone(datetime.timedelta(hours=gmt_offset)))
+
+ delta = now - date
+ seconds = delta.total_seconds()
+ days = delta.days
+
+ if full_format:
+ return self.format_day(date, gmt_offset, dow=True)
+
+ if relative and days == 0:
+ if seconds < 50:
+ return self.translate("just now")
+ if seconds < 90:
+ return self.translate("1 minute ago")
+ elif seconds < 3600:
+ minutes = int(seconds / 60)
+ return self.translate(
+ "%(minutes)d minute ago",
+ "%(minutes)d minutes ago",
+ minutes) % {"minutes": minutes}
+ elif seconds < 7200:
+ return self.translate("1 hour ago")
+ elif seconds < 86400:
+ hours = int(seconds / 3600)
+ return self.translate(
+ "%(hours)d hour ago",
+ "%(hours)d hours ago",
+ hours) % {"hours": hours}
+ elif days == 1:
+ return self.translate("yesterday")
+ elif days < 5:
+ return self.format_day(date, gmt_offset, dow=True)
+ elif days < 30:
+ return self.translate("%(days)d days ago") % {"days": days}
+ elif days < 365:
+ months = int(days / 30)
+ return self.translate(
+ "%(months)d month ago",
+ "%(months)d months ago",
+ months) % {"months": months}
+ else:
+ return self.format_day(date, gmt_offset, dow=True)
def format_day(self, date: datetime.datetime, gmt_offset: int=0, dow:
- bool=True) ->bool:
+ bool=True) ->str:
"""Formats the given date as a day of week.
Example: "Monday, January 22". You can remove the day of week with
``dow=False``.
"""
- pass
+ local_date = date.astimezone(datetime.timezone(datetime.timedelta(hours=gmt_offset)))
+ if dow:
+ weekday = self._weekdays[local_date.weekday()]
+ return f"{weekday}, {self._months[local_date.month - 1]} {local_date.day}"
+ else:
+ return f"{self._months[local_date.month - 1]} {local_date.day}"
def list(self, parts: Any) ->str:
"""Returns a comma-separated list for the given list of parts.
@@ -214,11 +339,25 @@ class Locale(object):
The format is, e.g., "A, B and C", "A and B" or just "A" for lists
of size 1.
"""
- pass
+ if len(parts) == 0:
+ return ""
+ elif len(parts) == 1:
+ return parts[0]
+ elif len(parts) == 2:
+ return self.translate("%(first)s and %(second)s") % {
+ "first": parts[0],
+ "second": parts[1],
+ }
+ else:
+ return self.translate(
+ "%(commas)s and %(last)s") % {
+ "commas": ", ".join(parts[:-1]),
+ "last": parts[-1],
+ }
def friendly_number(self, value: int) ->str:
"""Returns a comma-separated number for the given integer."""
- pass
+ return "{:,}".format(value)
class CSVLocale(Locale):
@@ -260,4 +399,12 @@ class GettextLocale(Locale):
.. versionadded:: 4.2
"""
- pass
+ if plural_message is not None:
+ assert count is not None
+ msgctxt = f"{context}{CONTEXT_SEPARATOR}{message}"
+ tmsg = self.ngettext(msgctxt, plural_message, count)
+ return tmsg if tmsg != msgctxt else self.ngettext(message, plural_message, count)
+ else:
+ msgctxt = f"{context}{CONTEXT_SEPARATOR}{message}"
+ tmsg = self.gettext(msgctxt)
+ return tmsg if tmsg != msgctxt else self.gettext(message)
diff --git a/tornado/locks.py b/tornado/locks.py
index bacc3ebe..028ed817 100644
--- a/tornado/locks.py
+++ b/tornado/locks.py
@@ -98,15 +98,35 @@ class Condition(_TimeoutGarbageCollector):
Returns a `.Future` that resolves ``True`` if the condition is notified,
or ``False`` after a timeout.
"""
- pass
+ future = Future()
+ self._waiters.append(future)
+
+ if timeout:
+ def on_timeout():
+ self._waiters.remove(future)
+ if not future.done():
+ future.set_result(False)
+ io_loop = ioloop.IOLoop.current()
+ timeout_handle = io_loop.add_timeout(timeout, on_timeout)
+ future.add_done_callback(lambda _: io_loop.remove_timeout(timeout_handle))
+
+ return future
def notify(self, n: int=1) ->None:
"""Wake ``n`` waiters."""
- pass
+ waiters = []
+ while n > 0 and self._waiters:
+ waiter = self._waiters.popleft()
+ if not waiter.done():
+ n -= 1
+ waiters.append(waiter)
+
+ for waiter in waiters:
+ future_set_result_unless_cancelled(waiter, True)
def notify_all(self) ->None:
"""Wake all waiters."""
- pass
+ self.notify(len(self._waiters))
class Event(object):
@@ -159,21 +179,25 @@ class Event(object):
def is_set(self) ->bool:
"""Return ``True`` if the internal flag is true."""
- pass
+ return self._value
def set(self) ->None:
"""Set the internal flag to ``True``. All waiters are awakened.
Calling `.wait` once the flag is set will not block.
"""
- pass
+ self._value = True
+ for waiter in self._waiters:
+ if not waiter.done():
+ waiter.set_result(None)
+ self._waiters.clear()
def clear(self) ->None:
"""Reset the internal flag to ``False``.
Calls to `.wait` will block until `.set` is called.
"""
- pass
+ self._value = False
def wait(self, timeout: Optional[Union[float, datetime.timedelta]]=None
) ->Awaitable[None]:
@@ -182,7 +206,24 @@ class Event(object):
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
"""
- pass
+ if self._value:
+ future = Future()
+ future.set_result(None)
+ return future
+
+ waiter = Future()
+ self._waiters.add(waiter)
+
+ if timeout:
+ def on_timeout():
+ self._waiters.discard(waiter)
+ if not waiter.done():
+ waiter.set_exception(gen.TimeoutError())
+ 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
class _ReleasingContextManager(object):
@@ -198,7 +239,7 @@ class _ReleasingContextManager(object):
self._obj = obj
def __enter__(self) ->None:
- pass
+ return None
def __exit__(self, exc_type: 'Optional[Type[BaseException]]', exc_val:
Optional[BaseException], exc_tb: Optional[types.TracebackType]) ->None:
@@ -322,7 +363,12 @@ class Semaphore(_TimeoutGarbageCollector):
def release(self) ->None:
"""Increment the counter and wake one waiter."""
- pass
+ self._value += 1
+ while self._waiters:
+ waiter = self._waiters.popleft()
+ if not waiter.done():
+ future_set_result_unless_cancelled(waiter, _ReleasingContextManager(self))
+ break
def acquire(self, timeout: Optional[Union[float, datetime.timedelta]]=None
) ->Awaitable[_ReleasingContextManager]:
@@ -331,7 +377,25 @@ class Semaphore(_TimeoutGarbageCollector):
Block if the counter is zero and wait for a `.release`. The awaitable
raises `.TimeoutError` after the deadline.
"""
- pass
+ if self._value > 0:
+ self._value -= 1
+ future = Future()
+ future.set_result(_ReleasingContextManager(self))
+ return future
+
+ waiter = Future()
+ self._waiters.append(waiter)
+
+ if timeout:
+ def on_timeout():
+ self._waiters.remove(waiter)
+ if not waiter.done():
+ waiter.set_exception(gen.TimeoutError())
+ 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 __enter__(self) ->None:
raise RuntimeError("Use 'async with' instead of 'with' for Semaphore")
@@ -364,7 +428,9 @@ class BoundedSemaphore(Semaphore):
def release(self) ->None:
"""Increment the counter and wake one waiter."""
- pass
+ if self._value >= self._initial_value:
+ raise ValueError("Semaphore released too many times")
+ super().release()
class Lock(object):
@@ -417,7 +483,7 @@ class Lock(object):
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
"""
- pass
+ return self._block.acquire(timeout)
def release(self) ->None:
"""Unlock.
@@ -426,7 +492,10 @@ class Lock(object):
If not locked, raise a `RuntimeError`.
"""
- pass
+ try:
+ self._block.release()
+ except ValueError:
+ raise RuntimeError("release unlocked lock")
def __enter__(self) ->None:
raise RuntimeError('Use `async with` instead of `with` for Lock')
diff --git a/tornado/log.py b/tornado/log.py
index 6e3e6e4d..219c9bf2 100644
--- a/tornado/log.py
+++ b/tornado/log.py
@@ -111,7 +111,39 @@ def enable_pretty_logging(options: Any=None, logger: Optional[logging.
This is called automatically by `tornado.options.parse_command_line`
and `tornado.options.parse_config_file`.
"""
- pass
+ if options is None:
+ from tornado.options import options
+ if options.logging == '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)
+ 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)
+ 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 define_logging_options(options: Any=None) ->None:
@@ -123,4 +155,32 @@ def define_logging_options(options: Any=None) ->None:
.. versionadded:: 4.2
This function existed in prior versions but was broken and undocumented until 4.2.
"""
- pass
+ if options is None:
+ # late import to prevent cyclic dependencies
+ from tornado.options import 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)")
diff --git a/tornado/netutil.py b/tornado/netutil.py
index 5afa2659..157cf785 100644
--- a/tornado/netutil.py
+++ b/tornado/netutil.py
@@ -47,7 +47,40 @@ def bind_sockets(port: int, address: Optional[str]=None, family: socket.
in the list. If your platform doesn't support this option ValueError will
be raised.
"""
- pass
+ sockets = []
+ if address == "":
+ address = None
+ if not socket.has_ipv6 and family == socket.AF_UNSPEC:
+ family = socket.AF_INET
+ if flags is None:
+ flags = socket.AI_PASSIVE
+ for res in socket.getaddrinfo(address, port, family, socket.SOCK_STREAM,
+ 0, flags):
+ af, socktype, proto, canonname, sockaddr = res
+ try:
+ sock = socket.socket(af, socktype, proto)
+ except socket.error as e:
+ continue
+ set_close_exec(sock.fileno())
+ if os.name != 'nt':
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+ if reuse_port:
+ try:
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+ except AttributeError:
+ raise ValueError("reuse_port not supported on this platform")
+ try:
+ sock.bind(sockaddr)
+ except socket.error as e:
+ sock.close()
+ if e.errno == errno.EADDRINUSE:
+ raise
+ continue
+ sock.listen(backlog)
+ sockets.append(sock)
+ if not sockets:
+ raise socket.error("Could not bind to any available socket")
+ return sockets
if hasattr(socket, 'AF_UNIX'):
@@ -63,7 +96,22 @@ if hasattr(socket, 'AF_UNIX'):
Returns a socket object (not a list of socket objects like
`bind_sockets`)
"""
- pass
+ sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ set_close_exec(sock.fileno())
+ try:
+ sock.bind(file)
+ except OSError as e:
+ if errno_from_exception(e) == errno.EADDRINUSE:
+ if os.path.exists(file):
+ os.unlink(file)
+ sock.bind(file)
+ else:
+ raise
+ else:
+ raise
+ os.chmod(file, mode)
+ sock.listen(backlog)
+ return sock
def add_accept_handler(sock: socket.socket, callback: Callable[[socket.
@@ -85,7 +133,25 @@ def add_accept_handler(sock: socket.socket, callback: Callable[[socket.
.. versionchanged:: 5.0
A callable is returned (``None`` was returned before).
"""
- pass
+ io_loop = IOLoop.current()
+
+ def accept_handler(fd: int, events: int) -> None:
+ while True:
+ try:
+ connection, address = sock.accept()
+ except BlockingIOError:
+ return
+ except socket.error as e:
+ if errno_from_exception(e) in (errno.ECONNABORTED, errno.EMFILE):
+ return
+ raise
+ callback(connection, address)
+
+ def remove_handler() -> None:
+ io_loop.remove_handler(sock.fileno())
+
+ io_loop.add_handler(sock.fileno(), accept_handler, IOLoop.READ)
+ return remove_handler
def is_valid_ip(ip: str) ->bool:
@@ -93,7 +159,15 @@ def is_valid_ip(ip: str) ->bool:
Supports IPv4 and IPv6.
"""
- pass
+ try:
+ socket.inet_pton(socket.AF_INET, ip)
+ return True
+ except socket.error:
+ try:
+ socket.inet_pton(socket.AF_INET6, ip)
+ return True
+ except socket.error:
+ return False
class Resolver(Configurable):
diff --git a/tornado/options.py b/tornado/options.py
index 9356e4bd..fe29e473 100644
--- a/tornado/options.py
+++ b/tornado/options.py
@@ -143,14 +143,14 @@ class OptionParser(object):
.. versionadded:: 3.1
"""
- pass
+ return ((name, self[name]) for name in self)
def groups(self) ->Set[str]:
"""The set of option-groups created by ``define``.
.. versionadded:: 3.1
"""
- pass
+ return set(opt.group_name for opt in self._options.values() if opt.group_name)
def group_dict(self, group: str) ->Dict[str, Any]:
"""The names and values of options in a group.
@@ -169,14 +169,15 @@ class OptionParser(object):
.. versionadded:: 3.1
"""
- pass
+ return {name: self[name] for name, opt in self._options.items()
+ if opt.group_name == group}
def as_dict(self) ->Dict[str, Any]:
"""The names and values of all options.
.. versionadded:: 3.1
"""
- pass
+ return dict(self.items())
def define(self, name: str, default: Any=None, type: Optional[type]=
None, help: Optional[str]=None, metavar: Optional[str]=None,
@@ -216,7 +217,27 @@ class OptionParser(object):
by later flags.
"""
- pass
+ if name in self._options:
+ raise Error("Option %r already defined in %s" % (
+ name, self._options[name].file_name))
+
+ frame = sys._getframe(0)
+ options_file = frame.f_code.co_filename
+
+ if type is None:
+ if default is None:
+ type = str
+ else:
+ type = type(default)
+
+ if default is not None and not isinstance(default, type):
+ raise Error("Default value type should be %s (is %s)" %
+ (type, type(default)))
+
+ self._options[name] = _Option(name, file_name=options_file,
+ default=default, type=type, help=help,
+ metavar=metavar, multiple=multiple,
+ group_name=group, callback=callback)
def parse_command_line(self, args: Optional[List[str]]=None, final:
bool=True) ->List[str]:
@@ -241,7 +262,40 @@ class OptionParser(object):
from multiple sources.
"""
- pass
+ if args is None:
+ args = sys.argv
+ remaining = []
+ for i in range(1, len(args)):
+ arg = args[i]
+ if arg.startswith("--"):
+ if "=" in arg:
+ name, value = arg.split("=", 1)
+ else:
+ name, value = arg, "true"
+ name = name[2:]
+ else:
+ remaining.append(arg)
+ continue
+ name = self._normalize_name(name)
+ if name in self._options:
+ option = self._options[name]
+ if option.multiple:
+ if option.type == int:
+ values = []
+ for part in value.split(","):
+ if ":" in part:
+ low, high = part.split(":")
+ values.extend(range(int(low), int(high)))
+ else:
+ values.append(int(part))
+ option.set(values)
+ else:
+ option.set(value.split(","))
+ else:
+ option.set(value)
+ if final:
+ self.run_parse_callbacks()
+ return remaining
def parse_config_file(self, path: str, final: bool=True) ->None:
"""Parses and loads the config file at the given path.
@@ -289,15 +343,43 @@ class OptionParser(object):
Added the ability to set options via strings in config files.
"""
- pass
+ config = {}
+ with open(path, 'r', encoding='utf-8') as f:
+ exec_in(f.read(), config, dict(__file__=path))
+
+ for name in config:
+ if name in self._options:
+ self._options[name].set(config[name])
+
+ if final:
+ self.run_parse_callbacks()
def print_help(self, file: Optional[TextIO]=None) ->None:
"""Prints all the command line options to stderr (or another file)."""
- pass
+ if file is None:
+ file = sys.stderr
+ print("Usage: %s [OPTIONS]" % sys.argv[0], file=file)
+ print("\nOptions:\n", file=file)
+ by_group = {}
+ 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:
+ prefix = 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
+ print(" --%-30s %s" % (prefix, description), file=file)
def add_parse_callback(self, callback: Callable[[], None]) ->None:
"""Adds a parse callback, to be invoked when option parsing is done."""
- pass
+ self._parse_callbacks.append(callback)
def mockable(self) ->'_Mockable':
"""Returns a wrapper around self that is compatible with
@@ -314,7 +396,7 @@ class OptionParser(object):
with mock.patch.object(options.mockable(), 'name', value):
assert options.name == value
"""
- pass
+ return _Mockable(self)
class _Mockable(object):
diff --git a/tornado/platform/asyncio.py b/tornado/platform/asyncio.py
index e67cf2ca..c0d1cd75 100644
--- a/tornado/platform/asyncio.py
+++ b/tornado/platform/asyncio.py
@@ -103,7 +103,7 @@ def to_tornado_future(asyncio_future: asyncio.Future) ->asyncio.Future:
Tornado ``Futures`` have been merged with `asyncio.Future`,
so this method is now a no-op.
"""
- pass
+ return asyncio_future
def to_asyncio_future(tornado_future: asyncio.Future) ->asyncio.Future:
@@ -119,7 +119,7 @@ def to_asyncio_future(tornado_future: asyncio.Future) ->asyncio.Future:
Tornado ``Futures`` have been merged with `asyncio.Future`,
so this method is now equivalent to `tornado.gen.convert_yielded`.
"""
- pass
+ return convert_yielded(tornado_future)
if sys.platform == 'win32' and hasattr(asyncio,
diff --git a/tornado/platform/twisted.py b/tornado/platform/twisted.py
index 4546b24f..b8f3ab23 100644
--- a/tornado/platform/twisted.py
+++ b/tornado/platform/twisted.py
@@ -41,6 +41,28 @@ class TwistedResolver(Resolver):
thread-based resolver instead.
"""
+ def __init__(self):
+ self.resolver = twisted.names.client.createResolver()
+
+ def resolve(self, host, port, family=socket.AF_UNSPEC):
+ future = Future()
+ if family != socket.AF_UNSPEC and family != socket.AF_INET and family != socket.AF_INET6:
+ future.set_exception(NotImplementedError("Unsupported family"))
+ return future
+
+ def callback(result):
+ if result:
+ future.set_result([(family, (result[0][1], port))])
+ else:
+ future.set_exception(IOError("Resolution failed"))
+
+ def errback(failure):
+ future.set_exception(failure.value)
+
+ d = self.resolver.getHostByName(utf8(host))
+ d.addCallbacks(callback, errback)
+ return future
+
def install() ->None:
"""Install ``AsyncioSelectorReactor`` as the default Twisted reactor.
@@ -61,7 +83,7 @@ def install() ->None:
``asyncio`` reactor instead.
"""
- pass
+ twisted.internet.asyncioreactor.install()
if hasattr(gen.convert_yielded, 'register'):
diff --git a/tornado/process.py b/tornado/process.py
index 3afe7dc4..d03c5bdf 100644
--- a/tornado/process.py
+++ b/tornado/process.py
@@ -22,7 +22,7 @@ CalledProcessError = subprocess.CalledProcessError
def cpu_count() ->int:
"""Returns the number of processors on this machine."""
- pass
+ return multiprocessing.cpu_count()
_task_id = None
@@ -57,7 +57,82 @@ def fork_processes(num_processes: Optional[int], max_restarts: Optional[int
Availability: Unix
"""
- pass
+ global _task_id
+ if max_restarts is None:
+ max_restarts = 100
+
+ if num_processes is None or num_processes <= 0:
+ num_processes = cpu_count()
+
+ if ioloop.IOLoop.initialized():
+ raise RuntimeError("Cannot run in multiple processes: IOLoop instance "
+ "has already been initialized. You cannot call "
+ "IOLoop.instance() before calling fork_processes()")
+
+ def start_child(i):
+ _task_id = i
+ return i
+
+ def exit_callback(pid, status):
+ if os.WIFSIGNALED(status):
+ gen_log.warning("child %d (pid %d) killed by signal %d, restarting",
+ _task_id, pid, os.WTERMSIG(status))
+ elif os.WEXITSTATUS(status) != 0:
+ gen_log.warning("child %d (pid %d) exited with status %d, restarting",
+ _task_id, pid, os.WEXITSTATUS(status))
+ else:
+ gen_log.info("child %d (pid %d) exited normally", _task_id, pid)
+ return
+
+ remaining_restarts = max_restarts - 1
+ if remaining_restarts > 0:
+ fork_processes(num_processes, max_restarts=remaining_restarts)
+ else:
+ gen_log.error("child %d (pid %d) exited after too many restarts",
+ _task_id, pid)
+
+ if sys.platform == 'win32':
+ # Windows doesn't support fork()
+ raise NotImplementedError("fork_processes not implemented on Windows")
+
+ children = {}
+
+ def handle_child():
+ while True:
+ try:
+ pid, status = os.waitpid(-1, os.WNOHANG)
+ except OSError:
+ return
+ if pid == 0:
+ return
+ if pid in children:
+ exit_callback(pid, status)
+ del children[pid]
+
+ signal.signal(signal.SIGCHLD, lambda sig, frame: handle_child())
+
+ for i in range(num_processes):
+ pid = os.fork()
+ if pid == 0:
+ # child process
+ return start_child(i)
+ else:
+ children[pid] = i
+
+ while children:
+ try:
+ pid, status = os.wait()
+ except OSError as e:
+ if e.errno == errno.EINTR:
+ continue
+ raise
+ if pid not in children:
+ continue
+ exit_callback(pid, status)
+ del children[pid]
+
+ # All child processes have exited, so exit the parent process
+ sys.exit(0)
def task_id() ->Optional[int]:
@@ -65,7 +140,8 @@ def task_id() ->Optional[int]:
Returns None if this process was not created by `fork_processes`.
"""
- pass
+ global _task_id
+ return _task_id
class Subprocess(object):
@@ -147,7 +223,9 @@ class Subprocess(object):
Availability: Unix
"""
- pass
+ self._exit_callback = callback
+ Subprocess.initialize()
+ Subprocess._waiting[self.pid] = self
def wait_for_exit(self, raise_error: bool=True) ->'Future[int]':
"""Returns a `.Future` which resolves when the process exits.
@@ -167,7 +245,15 @@ class Subprocess(object):
Availability: Unix
"""
- pass
+ future = Future()
+ self.set_exit_callback(lambda returncode: self._set_wait_for_exit_future(future, returncode, raise_error))
+ return future
+
+ def _set_wait_for_exit_future(self, future, returncode, raise_error):
+ if raise_error and returncode != 0:
+ future_set_exception_unless_cancelled(future, CalledProcessError(returncode, str(self.pid)))
+ else:
+ future_set_result_unless_cancelled(future, returncode)
@classmethod
def initialize(cls) ->None:
@@ -184,9 +270,18 @@ class Subprocess(object):
Availability: Unix
"""
- pass
+ if cls._initialized:
+ return
+ cls._initialized = True
+ io_loop = ioloop.IOLoop.current()
+ def handle_sigchld(*args):
+ io_loop.add_callback_from_signal(cls._cleanup)
+ signal.signal(signal.SIGCHLD, handle_sigchld)
@classmethod
def uninitialize(cls) ->None:
"""Removes the ``SIGCHLD`` handler."""
- pass
+ if not cls._initialized:
+ return
+ cls._initialized = False
+ signal.signal(signal.SIGCHLD, signal.SIG_DFL)
diff --git a/tornado/queues.py b/tornado/queues.py
index fde4734a..8db3aba7 100644
--- a/tornado/queues.py
+++ b/tornado/queues.py
@@ -128,11 +128,11 @@ class Queue(Generic[_T]):
@property
def maxsize(self) ->int:
"""Number of items allowed in the queue."""
- pass
+ return self._maxsize
def qsize(self) ->int:
"""Number of items in the queue."""
- pass
+ return len(self._queue)
def put(self, item: _T, timeout: Optional[Union[float, datetime.
timedelta]]=None) ->'Future[None]':
@@ -146,14 +146,35 @@ class Queue(Generic[_T]):
`datetime.timedelta` object for a deadline relative to the
current time.
"""
- pass
+ future = Future()
+ try:
+ self.put_nowait(item)
+ except QueueFull:
+ self._putters.append((item, future))
+ ioloop.IOLoop.current().add_timeout(timeout, self._put_timeout, future)
+ else:
+ future_set_result_unless_cancelled(future, None)
+ return future
+
+ def _put_timeout(self, future):
+ try:
+ self._putters.remove((future.item, future))
+ except ValueError:
+ pass
+ else:
+ future.set_exception(gen.TimeoutError())
def put_nowait(self, item: _T) ->None:
"""Put an item into the queue without blocking.
If no free slot is immediately available, raise `QueueFull`.
"""
- pass
+ if self._maxsize > 0 and len(self._queue) >= self._maxsize:
+ raise QueueFull()
+ self._queue.append(item)
+ self._unfinished_tasks += 1
+ self._finished.clear()
+ self._consume()
def get(self, timeout: Optional[Union[float, datetime.timedelta]]=None
) ->Awaitable[_T]:
@@ -177,7 +198,21 @@ class Queue(Generic[_T]):
with other timeouts in Tornado).
"""
- pass
+ future = Future()
+ try:
+ future.set_result(self.get_nowait())
+ except QueueEmpty:
+ self._getters.append(future)
+ ioloop.IOLoop.current().add_timeout(timeout, self._get_timeout, future)
+ return future
+
+ def _get_timeout(self, future):
+ try:
+ self._getters.remove(future)
+ except ValueError:
+ pass
+ else:
+ future.set_exception(gen.TimeoutError())
def get_nowait(self) ->_T:
"""Remove and return an item from the queue without blocking.
@@ -185,7 +220,11 @@ class Queue(Generic[_T]):
Return an item if one is immediately available, else raise
`QueueEmpty`.
"""
- pass
+ if not self._queue:
+ raise QueueEmpty()
+ item = self._queue.popleft()
+ self._consume()
+ return item
def task_done(self) ->None:
"""Indicate that a formerly enqueued task is complete.
@@ -199,7 +238,11 @@ class Queue(Generic[_T]):
Raises `ValueError` if called more times than `.put`.
"""
- pass
+ if self._unfinished_tasks <= 0:
+ raise ValueError('task_done() called too many times')
+ self._unfinished_tasks -= 1
+ if self._unfinished_tasks == 0:
+ self._finished.set()
def join(self, timeout: Optional[Union[float, datetime.timedelta]]=None
) ->Awaitable[None]:
@@ -208,7 +251,7 @@ class Queue(Generic[_T]):
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
"""
- pass
+ return self._finished.wait(timeout)
def __aiter__(self) ->_QueueIterator[_T]:
return _QueueIterator(self)
@@ -220,6 +263,20 @@ class Queue(Generic[_T]):
def __str__(self) ->str:
return '<%s %s>' % (type(self).__name__, self._format())
+ def _consume(self):
+ while self._putters and self._getters:
+ item, putter = self._putters.popleft()
+ getter = self._getters.popleft()
+ self._queue.append(item)
+ future_set_result_unless_cancelled(putter, None)
+ future_set_result_unless_cancelled(getter, self._queue.popleft())
+
+ def _init(self):
+ self._queue = collections.deque()
+
+ def _format(self):
+ return 'maxsize=%r' % (self.maxsize,)
+
class PriorityQueue(Queue):
"""A `.Queue` that retrieves entries in priority order, lowest first.
@@ -250,6 +307,9 @@ class PriorityQueue(Queue):
(10, 'low-priority item')
"""
+ def _init(self):
+ self._queue = []
+
class LifoQueue(Queue):
"""A `.Queue` that retrieves the most recently put items first.
@@ -277,3 +337,9 @@ class LifoQueue(Queue):
2
3
"""
+
+ def _init(self):
+ self._queue = []
+
+ def _get(self):
+ return self._queue.pop()
diff --git a/tornado/routing.py b/tornado/routing.py
index 111cbaaa..ec318117 100644
--- a/tornado/routing.py
+++ b/tornado/routing.py
@@ -264,7 +264,11 @@ class RuleRouter(Router):
:arg rules: a list of Rule instances (or tuples of arguments, which are
passed to Rule constructor).
"""
- pass
+ for rule in rules:
+ if isinstance(rule, Rule):
+ self.rules.append(self.process_rule(rule))
+ else:
+ self.rules.append(self.process_rule(Rule(*rule)))
def process_rule(self, rule: 'Rule') ->'Rule':
"""Override this method for additional preprocessing of each rule.
@@ -272,7 +276,7 @@ class RuleRouter(Router):
:arg Rule rule: a rule to be processed.
:returns: the same or modified Rule instance.
"""
- pass
+ return rule
def get_target_delegate(self, target: Any, request: httputil.
HTTPServerRequest, **target_params: Any) ->Optional[httputil.
@@ -286,7 +290,13 @@ class RuleRouter(Router):
:arg target_params: additional parameters that can be useful
for `~.httputil.HTTPMessageDelegate` creation.
"""
- pass
+ if isinstance(target, Router):
+ return target.find_handler(request, **target_params)
+ elif isinstance(target, httputil.HTTPServerConnectionDelegate):
+ return target.start_request(request.server_connection, request.connection)
+ elif callable(target):
+ return _CallableAdapter(target, request.connection)
+ return None
class ReversibleRuleRouter(ReversibleRouter, RuleRouter):
@@ -349,16 +359,19 @@ class Matcher(object):
An empty dict is a valid (and common) return value to indicate a match
when the argument-passing features are not used.
``None`` must be returned to indicate that there is no match."""
- pass
+ return {}
def reverse(self, *args: Any) ->Optional[str]:
"""Reconstructs full url from matcher instance and additional arguments."""
- pass
+ return None
class AnyMatches(Matcher):
"""Matches any request."""
+ def match(self, request: httputil.HTTPServerRequest) ->Optional[Dict[str, Any]]:
+ return {}
+
class HostMatches(Matcher):
"""Matches requests from hosts specified by ``host_pattern`` regex."""
@@ -371,6 +384,12 @@ class HostMatches(Matcher):
else:
self.host_pattern = host_pattern
+ def match(self, request: httputil.HTTPServerRequest) ->Optional[Dict[str, Any]]:
+ host = request.host.lower().split(':')[0]
+ if self.host_pattern.match(host):
+ return {}
+ return None
+
class DefaultHostMatches(Matcher):
"""Matches requests from host that is equal to application's default_host.
@@ -381,6 +400,14 @@ class DefaultHostMatches(Matcher):
self.application = application
self.host_pattern = host_pattern
+ def match(self, request: httputil.HTTPServerRequest) ->Optional[Dict[str, Any]]:
+ if "X-Real-Ip" in request.headers:
+ return None
+ host = request.host.lower().split(':')[0]
+ if self.application.default_host and self.host_pattern.match(host):
+ return {}
+ return None
+
class PathMatches(Matcher):
"""Matches requests with paths specified by ``path_pattern`` regex."""
@@ -402,7 +429,21 @@ class PathMatches(Matcher):
For example: Given the url pattern /([0-9]{4})/([a-z-]+)/, this method
would return ('/%s/%s/', 2).
"""
- pass
+ pattern = self.regex.pattern
+ if pattern.startswith('^'):
+ pattern = pattern[1:]
+ if pattern.endswith('$'):
+ pattern = pattern[:-1]
+
+ if not pattern.startswith('/'):
+ pattern = '/' + pattern
+
+ group_count = self.regex.groups
+ if group_count == 0:
+ return (pattern, None)
+
+ reverse_pattern = re.sub(r'\([^)]+\)', '%s', pattern)
+ return (reverse_pattern, group_count)
class URLSpec(Rule):
@@ -450,4 +491,6 @@ def _unquote_or_none(s: Optional[str]) ->Optional[bytes]:
Note that args are passed as bytes so the handler can decide what
encoding to use.
"""
- pass
+ if s is None:
+ return None
+ return url_unescape(utf8(s), encoding=None, plus=False)
diff --git a/tornado/simple_httpclient.py b/tornado/simple_httpclient.py
index 5ce89b18..efe9f4fa 100644
--- a/tornado/simple_httpclient.py
+++ b/tornado/simple_httpclient.py
@@ -108,7 +108,12 @@ class SimpleAsyncHTTPClient(AsyncHTTPClient):
:arg object key: A simple object to mark the request.
:info string key: More detailed timeout information.
"""
- pass
+ timeout_response = HTTPResponse(
+ self.request, 599, error=HTTPTimeoutError("Timeout"),
+ request_time=self.io_loop.time() - self.start_time
+ )
+ self.final_callback(timeout_response)
+ self.release_callback()
class _HTTPConnection(httputil.HTTPMessageDelegate):
@@ -146,7 +151,14 @@ class _HTTPConnection(httputil.HTTPMessageDelegate):
:info string key: More detailed timeout information.
"""
- pass
+ message = "Timeout" if info is None else f"Timeout: {info}"
+ error = HTTPTimeoutError(message)
+ self.final_callback(HTTPResponse(
+ self.request, 599, error=error,
+ request_time=self.io_loop.time() - self.start_time
+ ))
+ if self.release_callback is not None:
+ self.release_callback()
if __name__ == '__main__':
diff --git a/tornado/tcpclient.py b/tornado/tcpclient.py
index 4e4fcdf6..862e623e 100644
--- a/tornado/tcpclient.py
+++ b/tornado/tcpclient.py
@@ -59,7 +59,10 @@ class _Connector(object):
be AF_INET and the other AF_INET6, although non-standard resolvers
may return additional families).
"""
- pass
+ primary_family = addrinfo[0][0]
+ primary = [(af, addr) for af, addr in addrinfo if af == primary_family]
+ secondary = [(af, addr) for af, addr in addrinfo if af != primary_family]
+ return primary, secondary
class TCPClient(object):
@@ -107,4 +110,23 @@ class TCPClient(object):
.. versionchanged:: 5.0
Added the ``timeout`` argument.
"""
- pass
+ addrinfo = await self.resolver.resolve(host, port, af)
+ connector = _Connector(addrinfo, self._create_stream)
+ stream = await gen.with_timeout(timeout or datetime.timedelta(seconds=_INITIAL_CONNECT_TIMEOUT),
+ connector.start())
+
+ if ssl_options is not None:
+ stream = await stream.start_tls(server_hostname=host, ssl_options=ssl_options)
+
+ if max_buffer_size is not None:
+ stream.set_max_buffer_size(max_buffer_size)
+
+ return stream
+
+ def _create_stream(self, af: socket.AddressFamily, addr: Tuple) -> Tuple[IOStream, Future[IOStream]]:
+ sock = socket.socket(af)
+ stream = IOStream(sock)
+ if self.source_ip is not None:
+ sock.bind((self.source_ip, self.source_port or 0))
+ future = stream.connect(addr)
+ return stream, future
diff --git a/tornado/tcpserver.py b/tornado/tcpserver.py
index be5dca18..c5b4f7da 100644
--- a/tornado/tcpserver.py
+++ b/tornado/tcpserver.py
@@ -137,7 +137,9 @@ class TCPServer(object):
Added ``family``, ``backlog``, ``flags``, and ``reuse_port``
arguments to match `tornado.netutil.bind_sockets`.
"""
- pass
+ sockets = bind_sockets(port, address=address, family=family,
+ backlog=backlog, flags=flags, reuse_port=reuse_port)
+ self.add_sockets(sockets)
def add_sockets(self, sockets: Iterable[socket.socket]) ->None:
"""Makes this server start accepting connections on the given sockets.
@@ -148,11 +150,15 @@ class TCPServer(object):
method and `tornado.process.fork_processes` to provide greater
control over the initialization of a multi-process server.
"""
- pass
+ for sock in sockets:
+ self.add_socket(sock)
def add_socket(self, socket: socket.socket) ->None:
"""Singular version of `add_sockets`. Takes a single socket object."""
- pass
+ if self._stopped:
+ return
+ self._sockets[socket.fileno()] = socket
+ add_accept_handler(socket, self._handle_connection)
def bind(self, port: int, address: Optional[str]=None, family: socket.
AddressFamily=socket.AF_UNSPEC, backlog: int=_DEFAULT_BACKLOG,
@@ -187,7 +193,12 @@ class TCPServer(object):
Use either ``listen()`` or ``add_sockets()`` instead of ``bind()``
and ``start()``.
"""
- pass
+ sockets = bind_sockets(port, address=address, family=family,
+ backlog=backlog, flags=flags, reuse_port=reuse_port)
+ if self._started:
+ self.add_sockets(sockets)
+ else:
+ self._pending_sockets.extend(sockets)
def start(self, num_processes: Optional[int]=1, max_restarts: Optional[
int]=None) ->None:
@@ -222,7 +233,13 @@ class TCPServer(object):
Use either ``listen()`` or ``add_sockets()`` instead of ``bind()``
and ``start()``.
"""
- pass
+ 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 stop(self) ->None:
"""Stops listening for new connections.
@@ -230,7 +247,13 @@ class TCPServer(object):
Requests currently in progress may still continue after the
server is stopped.
"""
- pass
+ if self._stopped:
+ return
+ self._stopped = True
+ for fd, sock in self._sockets.items():
+ assert sock.fileno() == fd
+ self._remove_handler(sock)
+ sock.close()
def handle_stream(self, stream: IOStream, address: tuple) ->Optional[
Awaitable[None]]:
@@ -248,4 +271,4 @@ class TCPServer(object):
.. versionchanged:: 4.2
Added the option for this method to be a coroutine.
"""
- pass
+ raise NotImplementedError()
diff --git a/tornado/template.py b/tornado/template.py
index 1f082087..64f79041 100644
--- a/tornado/template.py
+++ b/tornado/template.py
@@ -217,7 +217,14 @@ def filter_whitespace(mode: str, text: str) ->str:
.. versionadded:: 4.3
"""
- pass
+ if mode == 'all':
+ return text
+ elif mode == 'single':
+ return re.sub(r'([^\S\n]+)', ' ', text)
+ elif mode == 'oneline':
+ return re.sub(r'\s+', ' ', text)
+ else:
+ raise ValueError(f"Invalid whitespace mode: {mode}")
class Template(object):
@@ -288,7 +295,28 @@ class Template(object):
def generate(self, **kwargs: Any) ->bytes:
"""Generate this template with the given arguments."""
- pass
+ namespace = {
+ 'escape': escape.xhtml_escape,
+ 'xhtml_escape': escape.xhtml_escape,
+ 'url_escape': escape.url_escape,
+ 'json_encode': escape.json_encode,
+ 'squeeze': escape.squeeze,
+ '_tt_utf8': escape.utf8,
+ '_tt_string_types': (unicode_type, bytes),
+ '_tt_modules': ObjectDict(),
+ 'datetime': datetime,
+ }
+ namespace.update(self.namespace)
+ namespace.update(kwargs)
+ exec_in(self.compiled, namespace)
+ execute = namespace['_tt_execute']
+ try:
+ result = execute()
+ return escape.utf8(result)
+ except Exception:
+ formatted_code = _format_code(self.code).rstrip()
+ app_log.error('%s code:\n%s', self.name, formatted_code)
+ raise
class BaseLoader(object):
@@ -324,15 +352,24 @@ class BaseLoader(object):
def reset(self) ->None:
"""Resets the cache of compiled templates."""
- pass
+ with self.lock:
+ self.templates.clear()
def resolve_path(self, name: str, parent_path: Optional[str]=None) ->str:
"""Converts a possibly-relative path to absolute (used internally)."""
- pass
+ if parent_path and not parent_path.startswith("<") and not parent_path.startswith("/") and not name.startswith("/"):
+ current_path = os.path.join(os.path.dirname(parent_path), name)
+ file_dir = os.path.dirname(os.path.abspath(parent_path))
+ return os.path.normpath(os.path.join(file_dir, current_path))
+ return name
def load(self, name: str, parent_path: Optional[str]=None) ->Template:
"""Loads a template."""
- pass
+ name = self.resolve_path(name, parent_path=parent_path)
+ with self.lock:
+ if name not in self.templates:
+ self.templates[name] = self._create_template(name)
+ return self.templates[name]
class Loader(BaseLoader):
diff --git a/tornado/test/autoreload_functionality_test.py b/tornado/test/autoreload_functionality_test.py
new file mode 100644
index 00000000..a751713a
--- /dev/null
+++ b/tornado/test/autoreload_functionality_test.py
@@ -0,0 +1,34 @@
+import unittest
+import os
+import sys
+import time
+from tornado import autoreload
+from tornado.testing import AsyncTestCase, gen_test
+
+class AutoreloadFunctionalityTest(AsyncTestCase):
+ @gen_test
+ async def test_watch_file(self):
+ test_file = 'test_autoreload.txt'
+ with open(test_file, 'w') as f:
+ f.write('initial content')
+
+ autoreload.watch(test_file)
+
+ # Simulate file change
+ time.sleep(1) # Ensure file modification time is different
+ with open(test_file, 'w') as f:
+ f.write('modified content')
+
+ # Wait for autoreload to detect the change
+ for _ in range(10): # Try for up to 5 seconds
+ if autoreload._reload_attempted:
+ break
+ await self.io_loop.run_in_executor(None, time.sleep, 0.5)
+
+ self.assertTrue(autoreload._reload_attempted)
+
+ # Clean up
+ os.remove(test_file)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tornado/test/runtests.py b/tornado/test/runtests.py
index f35b3725..00bba972 100644
--- a/tornado/test/runtests.py
+++ b/tornado/test/runtests.py
@@ -22,6 +22,7 @@ TEST_MODULES = [
"tornado.test.asyncio_test",
"tornado.test.auth_test",
"tornado.test.autoreload_test",
+ "tornado.test.autoreload_functionality_test",
"tornado.test.circlerefs_test",
"tornado.test.concurrent_test",
"tornado.test.curl_httpclient_test",
diff --git a/tornado/testing.py b/tornado/testing.py
index 0dea2c63..6a6341c4 100644
--- a/tornado/testing.py
+++ b/tornado/testing.py
@@ -53,7 +53,13 @@ def bind_unused_port(reuse_port: bool=False, address: str='127.0.0.1') ->Tuple[
Added optional ``address`` argument to
override the default "127.0.0.1".
"""
- pass
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ if reuse_port:
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+ sock.bind((address, 0))
+ port = sock.getsockname()[1]
+ return sock, port
def get_async_test_timeout() ->float:
@@ -63,7 +69,10 @@ def get_async_test_timeout() ->float:
.. versionadded:: 3.1
"""
- pass
+ try:
+ return float(os.environ.get('ASYNC_TEST_TIMEOUT', 5))
+ except ValueError:
+ return 5.0
class AsyncTestCase(unittest.TestCase):
@@ -137,7 +146,8 @@ class AsyncTestCase(unittest.TestCase):
.. deprecated:: 6.3
This method will be removed in Tornado 7.0.
"""
- pass
+ warnings.warn("get_new_ioloop is deprecated, use asyncio instead", DeprecationWarning)
+ return IOLoop()
def _callTestMethod(self, method: Callable) ->None:
"""Run the given test method, raising an error if it returns non-None.
@@ -152,7 +162,17 @@ class AsyncTestCase(unittest.TestCase):
present in all supported versions of Python (3.8+), and if it goes away in the future that's
OK because we can just remove this override as noted above.
"""
- pass
+ result = method()
+ if result is not None:
+ if inspect.iscoroutine(result) or isinstance(result, Generator):
+ raise RuntimeError(
+ f"Test method {method.__name__} is asynchronous but not "
+ f"decorated with @gen_test or @unittest.IsolatedAsyncioTestCase.asyncTest"
+ )
+ else:
+ raise ValueError(
+ f"Test method {method.__name__} should return None, not {result!r}"
+ )
def stop(self, _arg: Any=None, **kwargs: Any) ->None:
"""Stops the `.IOLoop`, causing one pending (or future) call to `wait()`
diff --git a/tornado/util.py b/tornado/util.py
index 182c7dcd..258c7639 100644
--- a/tornado/util.py
+++ b/tornado/util.py
@@ -67,12 +67,12 @@ class GzipDecompressor(object):
in ``unconsumed_tail``; you must retrieve this value and pass
it back to a future call to `decompress` if it is not empty.
"""
- pass
+ return self.decompressobj.decompress(value, max_length)
@property
def unconsumed_tail(self) ->bytes:
"""Returns the unconsumed portion left over"""
- pass
+ return self.decompressobj.unconsumed_tail
def flush(self) ->bytes:
"""Return any remaining buffered data not yet returned by decompress.
@@ -80,7 +80,7 @@ class GzipDecompressor(object):
Also checks for errors such as truncated input.
No other methods may be called on this object after `flush`.
"""
- pass
+ return self.decompressobj.flush()
def import_object(name: str) ->Any:
@@ -101,7 +101,14 @@ def import_object(name: str) ->Any:
...
ImportError: No module named missing_module
"""
- pass
+ if '.' not in name:
+ return __import__(name)
+ parts = name.split('.')
+ obj = __import__('.'.join(parts[:-1]), fromlist=[parts[-1]])
+ try:
+ return getattr(obj, parts[-1])
+ except AttributeError:
+ raise ImportError("No module named %s" % parts[-1])
def errno_from_exception(e: BaseException) ->Optional[int]:
@@ -113,7 +120,12 @@ def errno_from_exception(e: BaseException) ->Optional[int]:
abstracts all that behavior to give you a safe way to get the
errno.
"""
- pass
+ if hasattr(e, 'errno'):
+ return e.errno
+ elif e.args:
+ return e.args[0] if isinstance(e.args[0], int) else None
+ else:
+ return None
_alphanum = frozenset(
@@ -130,7 +142,18 @@ def re_unescape(s: str) ->str:
.. versionadded:: 4.4
"""
- pass
+ def replace(match):
+ group = match.group(1)
+ if group in _alphanum:
+ return group
+ elif group == '\n':
+ return '\\n'
+ elif group == '\r':
+ return '\\r'
+ else:
+ return group
+
+ return _re_unescape_pattern.sub(replace, s)
class Configurable(object):
@@ -187,12 +210,12 @@ class Configurable(object):
parameter).
"""
- pass
+ raise NotImplementedError()
@classmethod
def configurable_default(cls):
"""Returns the implementation class to be used if none is configured."""
- pass
+ raise NotImplementedError()
initialize = _initialize
"""Initialize a `Configurable` subclass instance.
@@ -210,12 +233,21 @@ class Configurable(object):
to the constructor. This can be used to set global defaults for
some parameters.
"""
- pass
+ base = cls.configurable_base()
+ if isinstance(impl, str):
+ impl = import_object(impl)
+ if impl is not None and not issubclass(impl, cls):
+ raise ValueError("Invalid subclass of %s" % cls)
+ base.__impl_class = impl
+ base.__impl_kwargs = kwargs
@classmethod
def configured_class(cls):
"""Returns the currently configured class."""
- pass
+ base = cls.configurable_base()
+ if cls.__impl_class is None:
+ base.__impl_class = cls.configurable_default()
+ return base.__impl_class
class ArgReplacer(object):
@@ -239,7 +271,9 @@ class ArgReplacer(object):
Returns ``default`` if the argument is not present.
"""
- pass
+ if self.arg_pos is not None and len(args) > self.arg_pos:
+ return args[self.arg_pos]
+ return kwargs.get(self.name, default)
def replace(self, new_value: Any, args: Sequence[Any], kwargs: Dict[str,
Any]) ->Tuple[Any, Sequence[Any], Dict[str, Any]]:
@@ -252,12 +286,25 @@ class ArgReplacer(object):
If the named argument was not found, ``new_value`` will be added
to ``kwargs`` and None will be returned as ``old_value``.
"""
- pass
+ if self.arg_pos is not None and len(args) > self.arg_pos:
+ # The arg to replace is passed positionally
+ old_value = args[self.arg_pos]
+ args = list(args)
+ args[self.arg_pos] = new_value
+ elif self.name in kwargs:
+ # The arg to replace is passed by keyword
+ old_value = kwargs[self.name]
+ kwargs[self.name] = new_value
+ else:
+ # The arg to replace is not present; add it to kwargs
+ old_value = None
+ kwargs[self.name] = new_value
+ return old_value, args, kwargs
def timedelta_to_seconds(td):
"""Equivalent to ``td.total_seconds()`` (introduced in Python 2.7)."""
- pass
+ return td.total_seconds()
def _websocket_mask_python(mask: bytes, data: bytes) ->bytes:
@@ -269,7 +316,11 @@ def _websocket_mask_python(mask: bytes, data: bytes) ->bytes:
This pure-python implementation may be replaced by an optimized version when available.
"""
- pass
+ mask = array.array("B", mask)
+ unmasked = array.array("B", data)
+ for i in range(len(data)):
+ unmasked[i] ^= mask[i % 4]
+ return unmasked.tobytes()
if os.environ.get('TORNADO_NO_EXTENSION') or os.environ.get('TORNADO_EXTENSION'
diff --git a/tornado/websocket.py b/tornado/websocket.py
index 8d336cb2..5592c823 100644
--- a/tornado/websocket.py
+++ b/tornado/websocket.py
@@ -175,7 +175,7 @@ class WebSocketHandler(tornado.web.RequestHandler):
Set websocket_ping_interval = 0 to disable pings.
"""
- pass
+ return self.application.settings.get('websocket_ping_interval', None)
@property
def ping_timeout(self) ->Optional[float]:
@@ -183,7 +183,7 @@ class WebSocketHandler(tornado.web.RequestHandler):
close the websocket connection (VPNs, etc. can fail to cleanly close ws connections).
Default is max of 3 pings or 30 seconds.
"""
- pass
+ return self.application.settings.get('websocket_ping_timeout', None)
@property
def max_message_size(self) ->int:
@@ -194,7 +194,7 @@ class WebSocketHandler(tornado.web.RequestHandler):
Default is 10MiB.
"""
- pass
+ return self.application.settings.get('websocket_max_message_size', 10 * 1024 * 1024)
def write_message(self, message: Union[bytes, str, Dict[str, Any]],
binary: bool=False) ->'Future[None]':
@@ -219,7 +219,13 @@ class WebSocketHandler(tornado.web.RequestHandler):
Consistently raises `WebSocketClosedError`. Previously could
sometimes raise `.StreamClosedError`.
"""
- pass
+ 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)
def select_subprotocol(self, subprotocols: List[str]) ->Optional[str]:
"""Override to implement subprotocol negotiation.
@@ -244,7 +250,7 @@ class WebSocketHandler(tornado.web.RequestHandler):
an empty string instead of an empty list if no subprotocols
were proposed by the client.
"""
- pass
+ return None
@property
def selected_subprotocol(self) ->Optional[str]:
@@ -275,7 +281,7 @@ class WebSocketHandler(tornado.web.RequestHandler):
Added ``compression_level`` and ``mem_level``.
"""
- pass
+ return None
def open(self, *args: str, **kwargs: str) ->Optional[Awaitable[None]]:
"""Invoked when a new WebSocket is opened.
@@ -303,7 +309,7 @@ class WebSocketHandler(tornado.web.RequestHandler):
``on_message`` can be a coroutine.
"""
- pass
+ raise NotImplementedError("on_message must be overridden")
def ping(self, data: Union[str, bytes]=b'') ->None:
"""Send ping frame to the remote end.
@@ -321,7 +327,9 @@ class WebSocketHandler(tornado.web.RequestHandler):
The data argument is now optional.
"""
- pass
+ if self.ws_connection is None:
+ raise WebSocketClosedError()
+ self.ws_connection.write_ping(data)
def on_pong(self, data: bytes) ->None:
"""Invoked when the response to a ping frame is received."""
diff --git a/tornado/wsgi.py b/tornado/wsgi.py
index 227b0d77..b0ed4272 100644
--- a/tornado/wsgi.py
+++ b/tornado/wsgi.py
@@ -108,7 +108,34 @@ class WSGIContainer(object):
.. versionchanged:: 6.3
No longer a static method.
"""
- pass
+ environ = {
+ "REQUEST_METHOD": request.method,
+ "SCRIPT_NAME": "",
+ "PATH_INFO": escape.url_unescape(
+ request.path, encoding=None, plus=False),
+ "QUERY_STRING": request.query,
+ "REMOTE_ADDR": request.remote_ip,
+ "SERVER_NAME": request.host.split(":")[0],
+ "SERVER_PORT": str(request.port or 80),
+ "SERVER_PROTOCOL": request.version,
+ "wsgi.version": (1, 0),
+ "wsgi.url_scheme": request.protocol,
+ "wsgi.input": BytesIO(request.body),
+ "wsgi.errors": sys.stderr,
+ "wsgi.multithread": True,
+ "wsgi.multiprocess": False,
+ "wsgi.run_once": False,
+ }
+
+ if "Content-Type" in request.headers:
+ environ["CONTENT_TYPE"] = request.headers.pop("Content-Type")
+ if "Content-Length" in request.headers:
+ environ["CONTENT_LENGTH"] = request.headers.pop("Content-Length")
+
+ for key, value in request.headers.items():
+ environ["HTTP_" + key.replace("-", "_").upper()] = value
+
+ return environ
HTTPRequest = httputil.HTTPServerRequest