We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Upgrading to 2.2.x results in type errors when importing from werkzeug.routing
After upgrading to werkzeug 2.2.1 importing any class from `werkzeug.routing` results in an error from mypy if `no_implicit_reexport=True`. This was not the case in previous versions as `werkzeug.routing` was a single file submodule. 


### Reproduction
Given `eg.py`:
```python
from werkzeug.routing import Rule
```
With `werkzeug==2.2.1`
```shell
$ mypy eg.py --strict
eg.py:1: error: Module "werkzeug.routing" does not explicitly export attribute "Rule"; implicit reexport disabled  [attr-defined]
Found 1 error in 1 file (checked 1 source file)
```

With `werkzeug==2.1.0`
```shell
$ mypy eg.py --strict
Success: no issues found in 1 source file```
```

### Environment:

- Python version: 3.10
- Werkzeug version: 2.2.1


--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `src/werkzeug/routing/__init__.py`
Content:
```
1 """When it comes to combining multiple controller or view functions
2 (however you want to call them) you need a dispatcher. A simple way
3 would be applying regular expression tests on the ``PATH_INFO`` and
4 calling registered callback functions that return the value then.
5 
6 This module implements a much more powerful system than simple regular
7 expression matching because it can also convert values in the URLs and
8 build URLs.
9 
10 Here a simple example that creates a URL map for an application with
11 two subdomains (www and kb) and some URL rules:
12 
13 .. code-block:: python
14 
15     m = Map([
16         # Static URLs
17         Rule('/', endpoint='static/index'),
18         Rule('/about', endpoint='static/about'),
19         Rule('/help', endpoint='static/help'),
20         # Knowledge Base
21         Subdomain('kb', [
22             Rule('/', endpoint='kb/index'),
23             Rule('/browse/', endpoint='kb/browse'),
24             Rule('/browse/<int:id>/', endpoint='kb/browse'),
25             Rule('/browse/<int:id>/<int:page>', endpoint='kb/browse')
26         ])
27     ], default_subdomain='www')
28 
29 If the application doesn't use subdomains it's perfectly fine to not set
30 the default subdomain and not use the `Subdomain` rule factory. The
31 endpoint in the rules can be anything, for example import paths or
32 unique identifiers. The WSGI application can use those endpoints to get the
33 handler for that URL.  It doesn't have to be a string at all but it's
34 recommended.
35 
36 Now it's possible to create a URL adapter for one of the subdomains and
37 build URLs:
38 
39 .. code-block:: python
40 
41     c = m.bind('example.com')
42 
43     c.build("kb/browse", dict(id=42))
44     'http://kb.example.com/browse/42/'
45 
46     c.build("kb/browse", dict())
47     'http://kb.example.com/browse/'
48 
49     c.build("kb/browse", dict(id=42, page=3))
50     'http://kb.example.com/browse/42/3'
51 
52     c.build("static/about")
53     '/about'
54 
55     c.build("static/index", force_external=True)
56     'http://www.example.com/'
57 
58     c = m.bind('example.com', subdomain='kb')
59 
60     c.build("static/about")
61     'http://www.example.com/about'
62 
63 The first argument to bind is the server name *without* the subdomain.
64 Per default it will assume that the script is mounted on the root, but
65 often that's not the case so you can provide the real mount point as
66 second argument:
67 
68 .. code-block:: python
69 
70     c = m.bind('example.com', '/applications/example')
71 
72 The third argument can be the subdomain, if not given the default
73 subdomain is used.  For more details about binding have a look at the
74 documentation of the `MapAdapter`.
75 
76 And here is how you can match URLs:
77 
78 .. code-block:: python
79 
80     c = m.bind('example.com')
81 
82     c.match("/")
83     ('static/index', {})
84 
85     c.match("/about")
86     ('static/about', {})
87 
88     c = m.bind('example.com', '/', 'kb')
89 
90     c.match("/")
91     ('kb/index', {})
92 
93     c.match("/browse/42/23")
94     ('kb/browse', {'id': 42, 'page': 23})
95 
96 If matching fails you get a ``NotFound`` exception, if the rule thinks
97 it's a good idea to redirect (for example because the URL was defined
98 to have a slash at the end but the request was missing that slash) it
99 will raise a ``RequestRedirect`` exception. Both are subclasses of
100 ``HTTPException`` so you can use those errors as responses in the
101 application.
102 
103 If matching succeeded but the URL rule was incompatible to the given
104 method (for example there were only rules for ``GET`` and ``HEAD`` but
105 routing tried to match a ``POST`` request) a ``MethodNotAllowed``
106 exception is raised.
107 """
108 from .converters import AnyConverter
109 from .converters import BaseConverter
110 from .converters import FloatConverter
111 from .converters import IntegerConverter
112 from .converters import PathConverter
113 from .converters import UnicodeConverter
114 from .converters import UUIDConverter
115 from .converters import ValidationError
116 from .exceptions import BuildError
117 from .exceptions import NoMatch
118 from .exceptions import RequestAliasRedirect
119 from .exceptions import RequestPath
120 from .exceptions import RequestRedirect
121 from .exceptions import RoutingException
122 from .exceptions import WebsocketMismatch
123 from .map import Map
124 from .map import MapAdapter
125 from .matcher import StateMachineMatcher
126 from .rules import EndpointPrefix
127 from .rules import parse_converter_args
128 from .rules import Rule
129 from .rules import RuleFactory
130 from .rules import RuleTemplate
131 from .rules import RuleTemplateFactory
132 from .rules import Subdomain
133 from .rules import Submount
134
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/src/werkzeug/routing/__init__.py b/src/werkzeug/routing/__init__.py
--- a/src/werkzeug/routing/__init__.py
+++ b/src/werkzeug/routing/__init__.py
@@ -105,29 +105,29 @@
 routing tried to match a ``POST`` request) a ``MethodNotAllowed``
 exception is raised.
 """
-from .converters import AnyConverter
-from .converters import BaseConverter
-from .converters import FloatConverter
-from .converters import IntegerConverter
-from .converters import PathConverter
-from .converters import UnicodeConverter
-from .converters import UUIDConverter
-from .converters import ValidationError
-from .exceptions import BuildError
-from .exceptions import NoMatch
-from .exceptions import RequestAliasRedirect
-from .exceptions import RequestPath
-from .exceptions import RequestRedirect
-from .exceptions import RoutingException
-from .exceptions import WebsocketMismatch
-from .map import Map
-from .map import MapAdapter
-from .matcher import StateMachineMatcher
-from .rules import EndpointPrefix
-from .rules import parse_converter_args
-from .rules import Rule
-from .rules import RuleFactory
-from .rules import RuleTemplate
-from .rules import RuleTemplateFactory
-from .rules import Subdomain
-from .rules import Submount
+from .converters import AnyConverter as AnyConverter
+from .converters import BaseConverter as BaseConverter
+from .converters import FloatConverter as FloatConverter
+from .converters import IntegerConverter as IntegerConverter
+from .converters import PathConverter as PathConverter
+from .converters import UnicodeConverter as UnicodeConverter
+from .converters import UUIDConverter as UUIDConverter
+from .converters import ValidationError as ValidationError
+from .exceptions import BuildError as BuildError
+from .exceptions import NoMatch as NoMatch
+from .exceptions import RequestAliasRedirect as RequestAliasRedirect
+from .exceptions import RequestPath as RequestPath
+from .exceptions import RequestRedirect as RequestRedirect
+from .exceptions import RoutingException as RoutingException
+from .exceptions import WebsocketMismatch as WebsocketMismatch
+from .map import Map as Map
+from .map import MapAdapter as MapAdapter
+from .matcher import StateMachineMatcher as StateMachineMatcher
+from .rules import EndpointPrefix as EndpointPrefix
+from .rules import parse_converter_args as parse_converter_args
+from .rules import Rule as Rule
+from .rules import RuleFactory as RuleFactory
+from .rules import RuleTemplate as RuleTemplate
+from .rules import RuleTemplateFactory as RuleTemplateFactory
+from .rules import Subdomain as Subdomain
+from .rules import Submount as Submount

{"golden_diff": "diff --git a/src/werkzeug/routing/__init__.py b/src/werkzeug/routing/__init__.py\n--- a/src/werkzeug/routing/__init__.py\n+++ b/src/werkzeug/routing/__init__.py\n@@ -105,29 +105,29 @@\n routing tried to match a ``POST`` request) a ``MethodNotAllowed``\n exception is raised.\n \"\"\"\n-from .converters import AnyConverter\n-from .converters import BaseConverter\n-from .converters import FloatConverter\n-from .converters import IntegerConverter\n-from .converters import PathConverter\n-from .converters import UnicodeConverter\n-from .converters import UUIDConverter\n-from .converters import ValidationError\n-from .exceptions import BuildError\n-from .exceptions import NoMatch\n-from .exceptions import RequestAliasRedirect\n-from .exceptions import RequestPath\n-from .exceptions import RequestRedirect\n-from .exceptions import RoutingException\n-from .exceptions import WebsocketMismatch\n-from .map import Map\n-from .map import MapAdapter\n-from .matcher import StateMachineMatcher\n-from .rules import EndpointPrefix\n-from .rules import parse_converter_args\n-from .rules import Rule\n-from .rules import RuleFactory\n-from .rules import RuleTemplate\n-from .rules import RuleTemplateFactory\n-from .rules import Subdomain\n-from .rules import Submount\n+from .converters import AnyConverter as AnyConverter\n+from .converters import BaseConverter as BaseConverter\n+from .converters import FloatConverter as FloatConverter\n+from .converters import IntegerConverter as IntegerConverter\n+from .converters import PathConverter as PathConverter\n+from .converters import UnicodeConverter as UnicodeConverter\n+from .converters import UUIDConverter as UUIDConverter\n+from .converters import ValidationError as ValidationError\n+from .exceptions import BuildError as BuildError\n+from .exceptions import NoMatch as NoMatch\n+from .exceptions import RequestAliasRedirect as RequestAliasRedirect\n+from .exceptions import RequestPath as RequestPath\n+from .exceptions import RequestRedirect as RequestRedirect\n+from .exceptions import RoutingException as RoutingException\n+from .exceptions import WebsocketMismatch as WebsocketMismatch\n+from .map import Map as Map\n+from .map import MapAdapter as MapAdapter\n+from .matcher import StateMachineMatcher as StateMachineMatcher\n+from .rules import EndpointPrefix as EndpointPrefix\n+from .rules import parse_converter_args as parse_converter_args\n+from .rules import Rule as Rule\n+from .rules import RuleFactory as RuleFactory\n+from .rules import RuleTemplate as RuleTemplate\n+from .rules import RuleTemplateFactory as RuleTemplateFactory\n+from .rules import Subdomain as Subdomain\n+from .rules import Submount as Submount\n", "issue": "Upgrading to 2.2.x results in type errors when importing from werkzeug.routing\nAfter upgrading to werkzeug 2.2.1 importing any class from `werkzeug.routing` results in an error from mypy if `no_implicit_reexport=True`. This was not the case in previous versions as `werkzeug.routing` was a single file submodule. \r\n\r\n\r\n### Reproduction\r\nGiven `eg.py`:\r\n```python\r\nfrom werkzeug.routing import Rule\r\n```\r\nWith `werkzeug==2.2.1`\r\n```shell\r\n$ mypy eg.py --strict\r\neg.py:1: error: Module \"werkzeug.routing\" does not explicitly export attribute \"Rule\"; implicit reexport disabled  [attr-defined]\r\nFound 1 error in 1 file (checked 1 source file)\r\n```\r\n\r\nWith `werkzeug==2.1.0`\r\n```shell\r\n$ mypy eg.py --strict\r\nSuccess: no issues found in 1 source file```\r\n```\r\n\r\n### Environment:\r\n\r\n- Python version: 3.10\r\n- Werkzeug version: 2.2.1\r\n\n", "before_files": [{"content": "\"\"\"When it comes to combining multiple controller or view functions\n(however you want to call them) you need a dispatcher. A simple way\nwould be applying regular expression tests on the ``PATH_INFO`` and\ncalling registered callback functions that return the value then.\n\nThis module implements a much more powerful system than simple regular\nexpression matching because it can also convert values in the URLs and\nbuild URLs.\n\nHere a simple example that creates a URL map for an application with\ntwo subdomains (www and kb) and some URL rules:\n\n.. code-block:: python\n\n    m = Map([\n        # Static URLs\n        Rule('/', endpoint='static/index'),\n        Rule('/about', endpoint='static/about'),\n        Rule('/help', endpoint='static/help'),\n        # Knowledge Base\n        Subdomain('kb', [\n            Rule('/', endpoint='kb/index'),\n            Rule('/browse/', endpoint='kb/browse'),\n            Rule('/browse/<int:id>/', endpoint='kb/browse'),\n            Rule('/browse/<int:id>/<int:page>', endpoint='kb/browse')\n        ])\n    ], default_subdomain='www')\n\nIf the application doesn't use subdomains it's perfectly fine to not set\nthe default subdomain and not use the `Subdomain` rule factory. The\nendpoint in the rules can be anything, for example import paths or\nunique identifiers. The WSGI application can use those endpoints to get the\nhandler for that URL.  It doesn't have to be a string at all but it's\nrecommended.\n\nNow it's possible to create a URL adapter for one of the subdomains and\nbuild URLs:\n\n.. code-block:: python\n\n    c = m.bind('example.com')\n\n    c.build(\"kb/browse\", dict(id=42))\n    'http://kb.example.com/browse/42/'\n\n    c.build(\"kb/browse\", dict())\n    'http://kb.example.com/browse/'\n\n    c.build(\"kb/browse\", dict(id=42, page=3))\n    'http://kb.example.com/browse/42/3'\n\n    c.build(\"static/about\")\n    '/about'\n\n    c.build(\"static/index\", force_external=True)\n    'http://www.example.com/'\n\n    c = m.bind('example.com', subdomain='kb')\n\n    c.build(\"static/about\")\n    'http://www.example.com/about'\n\nThe first argument to bind is the server name *without* the subdomain.\nPer default it will assume that the script is mounted on the root, but\noften that's not the case so you can provide the real mount point as\nsecond argument:\n\n.. code-block:: python\n\n    c = m.bind('example.com', '/applications/example')\n\nThe third argument can be the subdomain, if not given the default\nsubdomain is used.  For more details about binding have a look at the\ndocumentation of the `MapAdapter`.\n\nAnd here is how you can match URLs:\n\n.. code-block:: python\n\n    c = m.bind('example.com')\n\n    c.match(\"/\")\n    ('static/index', {})\n\n    c.match(\"/about\")\n    ('static/about', {})\n\n    c = m.bind('example.com', '/', 'kb')\n\n    c.match(\"/\")\n    ('kb/index', {})\n\n    c.match(\"/browse/42/23\")\n    ('kb/browse', {'id': 42, 'page': 23})\n\nIf matching fails you get a ``NotFound`` exception, if the rule thinks\nit's a good idea to redirect (for example because the URL was defined\nto have a slash at the end but the request was missing that slash) it\nwill raise a ``RequestRedirect`` exception. Both are subclasses of\n``HTTPException`` so you can use those errors as responses in the\napplication.\n\nIf matching succeeded but the URL rule was incompatible to the given\nmethod (for example there were only rules for ``GET`` and ``HEAD`` but\nrouting tried to match a ``POST`` request) a ``MethodNotAllowed``\nexception is raised.\n\"\"\"\nfrom .converters import AnyConverter\nfrom .converters import BaseConverter\nfrom .converters import FloatConverter\nfrom .converters import IntegerConverter\nfrom .converters import PathConverter\nfrom .converters import UnicodeConverter\nfrom .converters import UUIDConverter\nfrom .converters import ValidationError\nfrom .exceptions import BuildError\nfrom .exceptions import NoMatch\nfrom .exceptions import RequestAliasRedirect\nfrom .exceptions import RequestPath\nfrom .exceptions import RequestRedirect\nfrom .exceptions import RoutingException\nfrom .exceptions import WebsocketMismatch\nfrom .map import Map\nfrom .map import MapAdapter\nfrom .matcher import StateMachineMatcher\nfrom .rules import EndpointPrefix\nfrom .rules import parse_converter_args\nfrom .rules import Rule\nfrom .rules import RuleFactory\nfrom .rules import RuleTemplate\nfrom .rules import RuleTemplateFactory\nfrom .rules import Subdomain\nfrom .rules import Submount\n", "path": "src/werkzeug/routing/__init__.py"}], "after_files": [{"content": "\"\"\"When it comes to combining multiple controller or view functions\n(however you want to call them) you need a dispatcher. A simple way\nwould be applying regular expression tests on the ``PATH_INFO`` and\ncalling registered callback functions that return the value then.\n\nThis module implements a much more powerful system than simple regular\nexpression matching because it can also convert values in the URLs and\nbuild URLs.\n\nHere a simple example that creates a URL map for an application with\ntwo subdomains (www and kb) and some URL rules:\n\n.. code-block:: python\n\n    m = Map([\n        # Static URLs\n        Rule('/', endpoint='static/index'),\n        Rule('/about', endpoint='static/about'),\n        Rule('/help', endpoint='static/help'),\n        # Knowledge Base\n        Subdomain('kb', [\n            Rule('/', endpoint='kb/index'),\n            Rule('/browse/', endpoint='kb/browse'),\n            Rule('/browse/<int:id>/', endpoint='kb/browse'),\n            Rule('/browse/<int:id>/<int:page>', endpoint='kb/browse')\n        ])\n    ], default_subdomain='www')\n\nIf the application doesn't use subdomains it's perfectly fine to not set\nthe default subdomain and not use the `Subdomain` rule factory. The\nendpoint in the rules can be anything, for example import paths or\nunique identifiers. The WSGI application can use those endpoints to get the\nhandler for that URL.  It doesn't have to be a string at all but it's\nrecommended.\n\nNow it's possible to create a URL adapter for one of the subdomains and\nbuild URLs:\n\n.. code-block:: python\n\n    c = m.bind('example.com')\n\n    c.build(\"kb/browse\", dict(id=42))\n    'http://kb.example.com/browse/42/'\n\n    c.build(\"kb/browse\", dict())\n    'http://kb.example.com/browse/'\n\n    c.build(\"kb/browse\", dict(id=42, page=3))\n    'http://kb.example.com/browse/42/3'\n\n    c.build(\"static/about\")\n    '/about'\n\n    c.build(\"static/index\", force_external=True)\n    'http://www.example.com/'\n\n    c = m.bind('example.com', subdomain='kb')\n\n    c.build(\"static/about\")\n    'http://www.example.com/about'\n\nThe first argument to bind is the server name *without* the subdomain.\nPer default it will assume that the script is mounted on the root, but\noften that's not the case so you can provide the real mount point as\nsecond argument:\n\n.. code-block:: python\n\n    c = m.bind('example.com', '/applications/example')\n\nThe third argument can be the subdomain, if not given the default\nsubdomain is used.  For more details about binding have a look at the\ndocumentation of the `MapAdapter`.\n\nAnd here is how you can match URLs:\n\n.. code-block:: python\n\n    c = m.bind('example.com')\n\n    c.match(\"/\")\n    ('static/index', {})\n\n    c.match(\"/about\")\n    ('static/about', {})\n\n    c = m.bind('example.com', '/', 'kb')\n\n    c.match(\"/\")\n    ('kb/index', {})\n\n    c.match(\"/browse/42/23\")\n    ('kb/browse', {'id': 42, 'page': 23})\n\nIf matching fails you get a ``NotFound`` exception, if the rule thinks\nit's a good idea to redirect (for example because the URL was defined\nto have a slash at the end but the request was missing that slash) it\nwill raise a ``RequestRedirect`` exception. Both are subclasses of\n``HTTPException`` so you can use those errors as responses in the\napplication.\n\nIf matching succeeded but the URL rule was incompatible to the given\nmethod (for example there were only rules for ``GET`` and ``HEAD`` but\nrouting tried to match a ``POST`` request) a ``MethodNotAllowed``\nexception is raised.\n\"\"\"\nfrom .converters import AnyConverter as AnyConverter\nfrom .converters import BaseConverter as BaseConverter\nfrom .converters import FloatConverter as FloatConverter\nfrom .converters import IntegerConverter as IntegerConverter\nfrom .converters import PathConverter as PathConverter\nfrom .converters import UnicodeConverter as UnicodeConverter\nfrom .converters import UUIDConverter as UUIDConverter\nfrom .converters import ValidationError as ValidationError\nfrom .exceptions import BuildError as BuildError\nfrom .exceptions import NoMatch as NoMatch\nfrom .exceptions import RequestAliasRedirect as RequestAliasRedirect\nfrom .exceptions import RequestPath as RequestPath\nfrom .exceptions import RequestRedirect as RequestRedirect\nfrom .exceptions import RoutingException as RoutingException\nfrom .exceptions import WebsocketMismatch as WebsocketMismatch\nfrom .map import Map as Map\nfrom .map import MapAdapter as MapAdapter\nfrom .matcher import StateMachineMatcher as StateMachineMatcher\nfrom .rules import EndpointPrefix as EndpointPrefix\nfrom .rules import parse_converter_args as parse_converter_args\nfrom .rules import Rule as Rule\nfrom .rules import RuleFactory as RuleFactory\nfrom .rules import RuleTemplate as RuleTemplate\nfrom .rules import RuleTemplateFactory as RuleTemplateFactory\nfrom .rules import Subdomain as Subdomain\nfrom .rules import Submount as Submount\n", "path": "src/werkzeug/routing/__init__.py"}]}